pax_global_header00006660000000000000000000000064142160055710014513gustar00rootroot0000000000000052 comment=a460244ffea75ae30186afbbf6defddddd999b8d openfst-1.7.9/000077500000000000000000000000001421600557100132075ustar00rootroot00000000000000openfst-1.7.9/AUTHORS000066400000000000000000000010421421600557100142540ustar00rootroot00000000000000Google, Inc. Principal developers: 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 Lawrence Wolf-Sonkin Ke Wu openfst-1.7.9/BUILD.bazel000066400000000000000000000645031421600557100150750ustar00rootroot00000000000000# Copyright 2015-2019 Google LLC. All Rights Reserved. # # 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. package(default_visibility = ["//visibility:public"]) licenses(["notice"]) # Apache 2.0 exports_files(["COPYING"]) config_setting( name = "has_absl", values = {"define": "absl=1"}, ) prefix_dir = "src/" static_binary = 1 # Core library (lib/) cc_library( name = "fst-decl", hdrs = [prefix_dir + "include/fst/fst-decl.h"], includes = [prefix_dir + "include"], deps = [":base"], ) PUBLIC_HEADERS = [ # One-stop header file which includes the remaining headers below: prefix_dir + "include/fst/fstlib.h", # Fine-grained headers: prefix_dir + "include/fst/accumulator.h", prefix_dir + "include/fst/add-on.h", prefix_dir + "include/fst/arc-arena.h", prefix_dir + "include/fst/arc-map.h", prefix_dir + "include/fst/arc.h", prefix_dir + "include/fst/arcfilter.h", prefix_dir + "include/fst/arcsort.h", prefix_dir + "include/fst/bi-table.h", prefix_dir + "include/fst/cache.h", prefix_dir + "include/fst/closure.h", prefix_dir + "include/fst/compact-fst.h", prefix_dir + "include/fst/complement.h", prefix_dir + "include/fst/compose-filter.h", prefix_dir + "include/fst/compose.h", prefix_dir + "include/fst/concat.h", prefix_dir + "include/fst/connect.h", prefix_dir + "include/fst/const-fst.h", prefix_dir + "include/fst/determinize.h", prefix_dir + "include/fst/dfs-visit.h", prefix_dir + "include/fst/difference.h", prefix_dir + "include/fst/disambiguate.h", prefix_dir + "include/fst/edit-fst.h", prefix_dir + "include/fst/encode.h", prefix_dir + "include/fst/epsnormalize.h", prefix_dir + "include/fst/equal.h", prefix_dir + "include/fst/equivalent.h", prefix_dir + "include/fst/expanded-fst.h", prefix_dir + "include/fst/factor-weight.h", prefix_dir + "include/fst/filter-state.h", prefix_dir + "include/fst/fst.h", prefix_dir + "include/fst/heap.h", prefix_dir + "include/fst/intersect.h", prefix_dir + "include/fst/invert.h", prefix_dir + "include/fst/isomorphic.h", prefix_dir + "include/fst/label-reachable.h", prefix_dir + "include/fst/lookahead-filter.h", prefix_dir + "include/fst/lookahead-matcher.h", prefix_dir + "include/fst/map.h", prefix_dir + "include/fst/matcher-fst.h", prefix_dir + "include/fst/matcher.h", prefix_dir + "include/fst/memory.h", prefix_dir + "include/fst/minimize.h", prefix_dir + "include/fst/mutable-fst.h", prefix_dir + "include/fst/partition.h", prefix_dir + "include/fst/project.h", prefix_dir + "include/fst/properties.h", prefix_dir + "include/fst/prune.h", prefix_dir + "include/fst/push.h", prefix_dir + "include/fst/queue.h", prefix_dir + "include/fst/randequivalent.h", prefix_dir + "include/fst/randgen.h", prefix_dir + "include/fst/rational.h", prefix_dir + "include/fst/relabel.h", prefix_dir + "include/fst/replace-util.h", prefix_dir + "include/fst/replace.h", prefix_dir + "include/fst/reverse.h", prefix_dir + "include/fst/reweight.h", prefix_dir + "include/fst/rmepsilon.h", prefix_dir + "include/fst/rmfinalepsilon.h", prefix_dir + "include/fst/shortest-distance.h", prefix_dir + "include/fst/shortest-path.h", prefix_dir + "include/fst/state-map.h", prefix_dir + "include/fst/state-reachable.h", prefix_dir + "include/fst/state-table.h", prefix_dir + "include/fst/statesort.h", prefix_dir + "include/fst/string.h", prefix_dir + "include/fst/symbol-table-ops.h", prefix_dir + "include/fst/synchronize.h", prefix_dir + "include/fst/test-properties.h", prefix_dir + "include/fst/topsort.h", prefix_dir + "include/fst/union.h", prefix_dir + "include/fst/vector-fst.h", prefix_dir + "include/fst/verify.h", prefix_dir + "include/fst/visit.h", ] # This version does not have the export-dynamic flag set and should not be # used to load dynamic-shared object FST extensions. Please see the # "lib_export_dynamic" target below for binaries that need DSO loading. cc_library( name = "lib_lite", srcs = [ prefix_dir + "lib/fst.cc", prefix_dir + "lib/properties.cc", prefix_dir + "lib/symbol-table-ops.cc", ], hdrs = PUBLIC_HEADERS, copts = ["-Wno-sign-compare"], includes = [prefix_dir + "include"], linkopts = ["-lm"], deps = [ ":base", ":fst-decl", ":icu", ":interval-set", ":register", ":symbol-table", ":union-find", ":util", ":weight", ], ) cc_library( name = "fst", hdrs = PUBLIC_HEADERS, includes = [prefix_dir + "include"], deps = [ ":fst-types", ":lib_lite", ], ) cc_library( name = "lib_export_dynamic", linkopts = ["-Wl,--export-dynamic"], deps = [":fst"], ) cc_library( name = "fst-types", srcs = [prefix_dir + "lib/fst-types.cc"], deps = [":lib_lite"], alwayslink = 1, # because of registration ) cc_library( name = "symbol-table", srcs = [prefix_dir + "lib/symbol-table.cc"], hdrs = [prefix_dir + "include/fst/symbol-table.h"], copts = ["-Wno-sign-compare"], includes = [prefix_dir + "include"], deps = [ ":base", ":util", ], ) cc_library( name = "weight", srcs = [prefix_dir + "lib/weight.cc"], hdrs = [ prefix_dir + "include/fst/expectation-weight.h", prefix_dir + "include/fst/float-weight.h", prefix_dir + "include/fst/lexicographic-weight.h", prefix_dir + "include/fst/pair-weight.h", prefix_dir + "include/fst/power-weight.h", prefix_dir + "include/fst/product-weight.h", prefix_dir + "include/fst/set-weight.h", prefix_dir + "include/fst/signed-log-weight.h", prefix_dir + "include/fst/sparse-power-weight.h", prefix_dir + "include/fst/sparse-tuple-weight.h", prefix_dir + "include/fst/string-weight.h", prefix_dir + "include/fst/tuple-weight.h", prefix_dir + "include/fst/union-weight.h", prefix_dir + "include/fst/weight.h", ], includes = [prefix_dir + "include"], linkopts = ["-lm"], deps = [ ":base", ":util", ], ) cc_library( name = "interval-set", hdrs = [prefix_dir + "include/fst/interval-set.h"], includes = [prefix_dir + "include"], deps = [ ":base", ":util", ], ) cc_library( name = "register", hdrs = [ prefix_dir + "include/fst/generic-register.h", prefix_dir + "include/fst/register.h", ], includes = [prefix_dir + "include"], linkopts = ["-ldl"], deps = [ ":base", ":util", ], ) cc_library( name = "icu", hdrs = [ prefix_dir + "include/fst/icu.h", ], ) cc_library( name = "union-find", hdrs = [prefix_dir + "include/fst/union-find.h"], includes = [prefix_dir + "include"], deps = [":base"], ) cc_library( name = "util", srcs = [ prefix_dir + "lib/mapped-file.cc", prefix_dir + "lib/util.cc", ], hdrs = [ prefix_dir + "include/fst/mapped-file.h", prefix_dir + "include/fst/util.h", ], includes = [prefix_dir + "include"], deps = [":base"], ) cc_library( name = "base", srcs = [ prefix_dir + "lib/compat.cc", prefix_dir + "lib/flags.cc", ], hdrs = [ prefix_dir + "include/fst/compat.h", prefix_dir + "include/fst/config.h", prefix_dir + "include/fst/flags.h", prefix_dir + "include/fst/icu.h", prefix_dir + "include/fst/lock.h", prefix_dir + "include/fst/log.h", prefix_dir + "include/fst/types.h", ], defines = select({ ":has_absl": ["OPENFST_HAS_ABSL=1"], "//conditions:default": [], }), includes = [prefix_dir + "include"], deps = select({ ":has_absl": ["@com_google_absl//absl/synchronization"], "//conditions:default": [], }), ) # Core library tests (test/) cc_test( name = "fst_test", timeout = "short", srcs = [ prefix_dir + "test/fst_test.cc", prefix_dir + "include/fst/test/fst_test.h", ], deps = [":fst"], ) cc_library( name = "weight-tester", testonly = 1, hdrs = [prefix_dir + "include/fst/test/weight-tester.h"], includes = [prefix_dir], deps = [":weight"], ) cc_test( name = "weight_test", timeout = "short", srcs = [prefix_dir + "test/weight_test.cc"], copts = ["-Wno-unused-local-typedefs"], deps = [ ":fst", ":weight-tester", ], ) [ cc_test( name = "algo_test_%s" % weight, srcs = [ prefix_dir + "test/algo_test.cc", prefix_dir + "include/fst/test/algo_test.h", prefix_dir + "include/fst/test/rand-fst.h", ], defines = ["TEST_%s" % weight.upper()], deps = [":fst"], ) for weight in [ "tropical", "log", "minmax", "lexicographic", "power", ] ] # Non-template scripting-language integration (script/) cc_library( name = "fstscript_base", srcs = [ prefix_dir + "script/arciterator-class.cc", prefix_dir + "script/encodemapper-class.cc", prefix_dir + "script/fst-class.cc", prefix_dir + "script/getters.cc", prefix_dir + "script/stateiterator-class.cc", prefix_dir + "script/text-io.cc", prefix_dir + "script/weight-class.cc", ], hdrs = [ prefix_dir + "include/fst/script/arc-class.h", prefix_dir + "include/fst/script/arciterator-class.h", prefix_dir + "include/fst/script/arg-packs.h", prefix_dir + "include/fst/script/encodemapper-class.h", prefix_dir + "include/fst/script/fst-class.h", prefix_dir + "include/fst/script/fstscript-decl.h", prefix_dir + "include/fst/script/fstscript.h", prefix_dir + "include/fst/script/getters.h", prefix_dir + "include/fst/script/register.h", prefix_dir + "include/fst/script/script-impl.h", prefix_dir + "include/fst/script/stateiterator-class.h", prefix_dir + "include/fst/script/text-io.h", prefix_dir + "include/fst/script/weight-class.h", # prefix_dir + "include/fst/script/arcsort.h", prefix_dir + "include/fst/script/closure.h", prefix_dir + "include/fst/script/compile.h", prefix_dir + "include/fst/script/compile-impl.h", prefix_dir + "include/fst/script/compose.h", prefix_dir + "include/fst/script/concat.h", prefix_dir + "include/fst/script/connect.h", prefix_dir + "include/fst/script/convert.h", prefix_dir + "include/fst/script/decode.h", prefix_dir + "include/fst/script/determinize.h", prefix_dir + "include/fst/script/difference.h", prefix_dir + "include/fst/script/disambiguate.h", prefix_dir + "include/fst/script/draw.h", prefix_dir + "include/fst/script/draw-impl.h", prefix_dir + "include/fst/script/encode.h", prefix_dir + "include/fst/script/epsnormalize.h", prefix_dir + "include/fst/script/equal.h", prefix_dir + "include/fst/script/equivalent.h", prefix_dir + "include/fst/script/info.h", prefix_dir + "include/fst/script/info-impl.h", prefix_dir + "include/fst/script/intersect.h", prefix_dir + "include/fst/script/invert.h", prefix_dir + "include/fst/script/isomorphic.h", prefix_dir + "include/fst/script/map.h", prefix_dir + "include/fst/script/minimize.h", prefix_dir + "include/fst/script/print.h", prefix_dir + "include/fst/script/print-impl.h", prefix_dir + "include/fst/script/project.h", prefix_dir + "include/fst/script/prune.h", prefix_dir + "include/fst/script/push.h", prefix_dir + "include/fst/script/randequivalent.h", prefix_dir + "include/fst/script/randgen.h", prefix_dir + "include/fst/script/relabel.h", prefix_dir + "include/fst/script/replace.h", prefix_dir + "include/fst/script/reverse.h", prefix_dir + "include/fst/script/reweight.h", prefix_dir + "include/fst/script/rmepsilon.h", prefix_dir + "include/fst/script/shortest-distance.h", prefix_dir + "include/fst/script/shortest-path.h", prefix_dir + "include/fst/script/synchronize.h", prefix_dir + "include/fst/script/topsort.h", prefix_dir + "include/fst/script/union.h", prefix_dir + "include/fst/script/verify.h", ], copts = ["-Wno-sign-compare"], includes = [prefix_dir + "include"], deps = [":fst"], ) [ cc_library( name = "fstscript_%s" % operation, srcs = [prefix_dir + "script/%s.cc" % operation], hdrs = [prefix_dir + "include/fst/script/%s.h" % operation], includes = [prefix_dir + "include"], deps = [":fstscript_base"], ) for operation in [ "arcsort", "closure", "concat", "connect", "convert", "decode", "determinize", "disambiguate", "encode", "epsnormalize", "equal", "equivalent", "invert", "isomorphic", "map", "minimize", "project", "prune", "push", "randgen", "relabel", "replace", "reverse", "reweight", "synchronize", "topsort", "union", "verify", ] ] cc_library( name = "fstscript_compile", srcs = [prefix_dir + "script/compile.cc"], hdrs = [ prefix_dir + "include/fst/script/compile.h", prefix_dir + "include/fst/script/compile-impl.h", ], includes = [prefix_dir + "include"], deps = [":fstscript_base"], ) cc_library( name = "fstscript_compose", srcs = [prefix_dir + "script/compose.cc"], hdrs = [prefix_dir + "include/fst/script/compose.h"], includes = [prefix_dir + "include"], deps = [ ":fstscript_base", ":fstscript_connect", ], ) cc_library( name = "fstscript_difference", srcs = [prefix_dir + "script/difference.cc"], hdrs = [prefix_dir + "include/fst/script/difference.h"], includes = [prefix_dir + "include"], deps = [ ":fstscript_base", ":fstscript_compose", ], ) cc_library( name = "fstscript_draw", srcs = [prefix_dir + "script/draw.cc"], hdrs = [ prefix_dir + "include/fst/script/draw.h", prefix_dir + "include/fst/script/draw-impl.h", ], includes = [prefix_dir + "include"], deps = [":fstscript_base"], ) cc_library( name = "fstscript_info", srcs = [ prefix_dir + "script/info.cc", prefix_dir + "script/info-impl.cc", ], hdrs = [ prefix_dir + "include/fst/script/info.h", prefix_dir + "include/fst/script/info-impl.h", ], includes = [prefix_dir + "include"], deps = [":fstscript_base"], ) cc_library( name = "fstscript_intersect", srcs = [prefix_dir + "script/intersect.cc"], hdrs = [prefix_dir + "include/fst/script/intersect.h"], includes = [prefix_dir + "include"], deps = [ ":fstscript_base", ":fstscript_compose", ], ) cc_library( name = "fstscript_print", srcs = [prefix_dir + "script/print.cc"], hdrs = [ prefix_dir + "include/fst/script/print.h", prefix_dir + "include/fst/script/print-impl.h", ], includes = [prefix_dir + "include"], deps = [":fstscript_base"], ) cc_library( name = "fstscript_randequivalent", srcs = [prefix_dir + "script/randequivalent.cc"], hdrs = [prefix_dir + "include/fst/script/randequivalent.h"], includes = [prefix_dir + "include"], deps = [ ":fstscript_base", ":fstscript_randgen", ], ) cc_library( name = "fstscript_rmepsilon", srcs = [prefix_dir + "script/rmepsilon.cc"], hdrs = [prefix_dir + "include/fst/script/rmepsilon.h"], includes = [prefix_dir + "include"], deps = [ ":fstscript_base", ":fstscript_shortest_distance", ], ) cc_library( name = "fstscript_shortest_distance", srcs = [prefix_dir + "script/shortest-distance.cc"], hdrs = [prefix_dir + "include/fst/script/shortest-distance.h"], includes = [prefix_dir + "include"], deps = [ ":fstscript_base", ":fstscript_prune", ], ) cc_library( name = "fstscript_shortest_path", srcs = [prefix_dir + "script/shortest-path.cc"], hdrs = [prefix_dir + "include/fst/script/shortest-path.h"], includes = [prefix_dir + "include"], deps = [ ":fstscript_base", ":fstscript_shortest_distance", ], ) cc_library( name = "fstscript", deps = [ ":fstscript_arcsort", ":fstscript_closure", ":fstscript_compile", ":fstscript_compose", ":fstscript_concat", ":fstscript_connect", ":fstscript_convert", ":fstscript_decode", ":fstscript_determinize", ":fstscript_difference", ":fstscript_disambiguate", ":fstscript_draw", ":fstscript_encode", ":fstscript_epsnormalize", ":fstscript_equal", ":fstscript_equivalent", ":fstscript_info", ":fstscript_intersect", ":fstscript_invert", ":fstscript_isomorphic", ":fstscript_map", ":fstscript_minimize", ":fstscript_print", ":fstscript_project", ":fstscript_prune", ":fstscript_push", ":fstscript_randequivalent", ":fstscript_randgen", ":fstscript_relabel", ":fstscript_replace", ":fstscript_reverse", ":fstscript_reweight", ":fstscript_rmepsilon", ":fstscript_shortest_distance", ":fstscript_shortest_path", ":fstscript_synchronize", ":fstscript_topsort", ":fstscript_union", ":fstscript_verify", ], ) # Command-line binaries (bin/) [ cc_binary( name = "fst%s" % operation.replace("_", ""), srcs = [ prefix_dir + "bin/fst%s.cc" % operation.replace("_", ""), prefix_dir + "bin/fst%s-main.cc" % operation.replace("_", ""), ], linkstatic = static_binary, deps = [":fstscript_%s" % operation], ) for operation in [ "arcsort", "closure", "compile", "compose", "concat", "connect", "convert", "determinize", "difference", "disambiguate", "draw", "epsnormalize", "equal", "info", "intersect", "invert", "isomorphic", "map", "minimize", "print", "project", "prune", "push", "randgen", "relabel", "replace", "reverse", "reweight", "rmepsilon", "shortest_distance", "shortest_path", "synchronize", "topsort", "union", ] ] cc_binary( name = "fstencode", srcs = [ prefix_dir + "bin/fstencode.cc", prefix_dir + "bin/fstencode-main.cc", ], linkstatic = static_binary, deps = [ ":fstscript_decode", ":fstscript_encode", ], ) cc_binary( name = "fstequivalent", srcs = [ prefix_dir + "bin/fstequivalent.cc", prefix_dir + "bin/fstequivalent-main.cc", ], linkstatic = static_binary, deps = [ ":fstscript_equivalent", ":fstscript_randequivalent", ], ) cc_binary( name = "fstsymbols", srcs = [ prefix_dir + "bin/fstsymbols.cc", prefix_dir + "bin/fstsymbols-main.cc", ], linkstatic = static_binary, deps = [":fstscript_verify"], ) # Extension: Fst ARchive a/k/a FAR (extensions/far/) cc_library( name = "sttable", srcs = [ prefix_dir + "extensions/far/stlist.cc", prefix_dir + "extensions/far/sttable.cc", ], hdrs = [ prefix_dir + "include/fst/extensions/far/stlist.h", prefix_dir + "include/fst/extensions/far/sttable.h", ], includes = [prefix_dir + "include"], deps = [":util"], ) cc_library( name = "far_base", hdrs = [ prefix_dir + "include/fst/extensions/far/far.h", ], includes = [prefix_dir + "include"], deps = [ ":fst", ":sttable", ], ) cc_library( name = "far", srcs = [prefix_dir + "extensions/far/strings.cc"], hdrs = [ prefix_dir + "include/fst/extensions/far/compile-strings.h", prefix_dir + "include/fst/extensions/far/create.h", prefix_dir + "include/fst/extensions/far/equal.h", prefix_dir + "include/fst/extensions/far/extract.h", prefix_dir + "include/fst/extensions/far/farlib.h", prefix_dir + "include/fst/extensions/far/info.h", prefix_dir + "include/fst/extensions/far/isomorphic.h", prefix_dir + "include/fst/extensions/far/print-strings.h", ], includes = [prefix_dir + "include"], deps = [ ":far_base", ":fst", ], ) cc_library( name = "farscript", srcs = [ prefix_dir + "extensions/far/far-class.cc", prefix_dir + "extensions/far/farscript.cc", prefix_dir + "extensions/far/getters.cc", prefix_dir + "extensions/far/script-impl.cc", prefix_dir + "extensions/far/strings.cc", ], hdrs = [ prefix_dir + "include/fst/extensions/far/compile-strings.h", prefix_dir + "include/fst/extensions/far/far-class.h", prefix_dir + "include/fst/extensions/far/farscript.h", prefix_dir + "include/fst/extensions/far/getters.h", prefix_dir + "include/fst/extensions/far/script-impl.h", ], includes = [prefix_dir + "include"], deps = [ ":base", ":far", ":fstscript_base", ], ) [ cc_binary( name = "far%s" % operation, srcs = [ prefix_dir + "extensions/far/far%s.cc" % operation, prefix_dir + "extensions/far/far%s-main.cc" % operation, ], linkstatic = static_binary, deps = [":farscript"], ) for operation in [ "compilestrings", "create", "equal", "extract", "info", "isomorphic", "printstrings", ] ] # Extension: PushDown Transducers a/k/a PDT (extensions/pdt/) cc_library( name = "pdt", hdrs = [ prefix_dir + "include/fst/extensions/pdt/collection.h", prefix_dir + "include/fst/extensions/pdt/compose.h", prefix_dir + "include/fst/extensions/pdt/expand.h", prefix_dir + "include/fst/extensions/pdt/getters.h", prefix_dir + "include/fst/extensions/pdt/info.h", prefix_dir + "include/fst/extensions/pdt/paren.h", prefix_dir + "include/fst/extensions/pdt/pdt.h", prefix_dir + "include/fst/extensions/pdt/pdtlib.h", prefix_dir + "include/fst/extensions/pdt/replace.h", prefix_dir + "include/fst/extensions/pdt/reverse.h", prefix_dir + "include/fst/extensions/pdt/shortest-path.h", ], includes = [prefix_dir + "include"], deps = [ ":fst", ], ) cc_library( name = "pdtscript", srcs = [ prefix_dir + "extensions/pdt/getters.cc", prefix_dir + "extensions/pdt/pdtscript.cc", ], hdrs = [ prefix_dir + "include/fst/extensions/pdt/getters.h", prefix_dir + "include/fst/extensions/pdt/pdtscript.h", ], includes = [prefix_dir + "include"], deps = [ ":fst", ":fstscript_base", ":pdt", ], ) cc_binary( name = "pdtcompose", srcs = [prefix_dir + "extensions/pdt/pdtcompose.cc"], linkstatic = static_binary, deps = [ ":fstscript_connect", ":pdtscript", ], ) [ cc_binary( name = "pdt%s" % operation, srcs = [prefix_dir + "extensions/pdt/pdt%s.cc" % operation], linkstatic = static_binary, deps = [":pdtscript"], ) for operation in [ "expand", "info", "replace", "reverse", "shortestpath", ] ] # Extension: Multi PushDown Transducers a/k/a MPDT (extensions/mpdt/) cc_library( name = "mpdt", hdrs = [ prefix_dir + "include/fst/extensions/mpdt/compose.h", prefix_dir + "include/fst/extensions/mpdt/expand.h", prefix_dir + "include/fst/extensions/mpdt/info.h", prefix_dir + "include/fst/extensions/mpdt/mpdt.h", prefix_dir + "include/fst/extensions/mpdt/mpdtlib.h", prefix_dir + "include/fst/extensions/mpdt/read_write_utils.h", prefix_dir + "include/fst/extensions/mpdt/reverse.h", ], includes = [prefix_dir + "include"], deps = [ ":fst", ":pdt", ], ) cc_library( name = "mpdtscript", srcs = [prefix_dir + "extensions/mpdt/mpdtscript.cc"], hdrs = [prefix_dir + "include/fst/extensions/mpdt/mpdtscript.h"], includes = [prefix_dir + "include"], deps = [ ":fst", ":fstscript_base", ":mpdt", ":pdtscript", ], ) cc_binary( name = "mpdtcompose", srcs = [prefix_dir + "extensions/mpdt/mpdtcompose.cc"], linkstatic = static_binary, deps = [ ":fstscript_connect", ":mpdtscript", ], ) [ cc_binary( name = "mpdt%s" % operation, srcs = [prefix_dir + "extensions/mpdt/mpdt%s.cc" % operation], linkstatic = static_binary, deps = [":mpdtscript"], ) for operation in [ "expand", "info", "reverse", ] ] # Extension: LOUDS compressed n-gram language models (extensions/ngram/) cc_library( name = "ngram", srcs = [ prefix_dir + "extensions/ngram/bitmap-index.cc", prefix_dir + "extensions/ngram/ngram-fst.cc", prefix_dir + "extensions/ngram/nthbit.cc", ], hdrs = [ prefix_dir + "include/fst/extensions/ngram/bitmap-index.h", prefix_dir + "include/fst/extensions/ngram/ngram-fst.h", prefix_dir + "include/fst/extensions/ngram/nthbit.h", ], includes = [prefix_dir + "include"], deps = [ ":fst", ], ) # TODO: Extensions compact, compress, const, linear, lookahead, python, special openfst-1.7.9/COPYING000066400000000000000000000010601421600557100142370ustar00rootroot00000000000000Licensed 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. openfst-1.7.9/INSTALL000066400000000000000000000224501421600557100142430ustar00rootroot00000000000000Installation 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. openfst-1.7.9/Makefile.am000066400000000000000000000001121421600557100152350ustar00rootroot00000000000000SUBDIRS = src ACLOCAL_AMFLAGS = -I m4 EXTRA_DIST = BUILD.bazel WORKSPACE openfst-1.7.9/Makefile.in000066400000000000000000000637531421600557100152720ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \ $(am__configure_deps) $(am__DIST_COMMON) 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 distdir-am 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) am__DIST_COMMON = $(srcdir)/Makefile.in $(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 ltmain.sh missing 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 EXTRA_DIST = BUILD.bazel WORKSPACE 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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \ 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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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) | eval GZIP= gzip $(GZIP_ENV) -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 distribution archives compressed with" \ "legacy program 'compress' 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 shar distribution archives is" \ "deprecated." >&2 @echo WARNING: "It will be removed altogether in Automake 2.0" >&2 shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -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*) \ eval GZIP= gzip $(GZIP_ENV) -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*) \ eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\ *.zip*) \ unzip $(distdir).zip ;;\ esac chmod -R a-w $(distdir) chmod u+w $(distdir) mkdir $(distdir)/_build $(distdir)/_build/sub $(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/sub \ && ../../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 .PRECIOUS: Makefile # 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: openfst-1.7.9/NEWS000066400000000000000000000361161421600557100137150ustar00rootroot00000000000000OpenFst: Release 1.7 * Compatibility release for Thrax and Pynini improvements (1.7.9) * TokenType is now a scoped enum (1.7.8) * pywrapfst is now Python 3-only (1.7.8) * fstproject now has --project_type flag (1.7.8) * BitmapIndex is now 2x faster for Select0/Select1 (1.7.8) * Property testing is now thread-safe (1.7.7) * Modernizes random generation (1.7.7) * Adds MakeArcMapFst (1.7.6) * Adds RealWeight and Real64Weight (1.7.6) * Adds a new, idiomatic SymbolTable iterator interface (1.7.6) * Improves symbol table lifetime management in pywrapfst (1.7.6) * Improves the design of the FST class hierarchy in pywrapfst (1.7.6) * Removes unnecessary template parameters in constructors (1.7.5) * Converts RmEpsilonFstOptions from class to struct (1.7.5) * Eliminates redundant checks in Minimize (1.7.5) * CompactFst is now templated on Compactor rather than ArcCompactor (1.7.4) * Removes harmful constexpr specifications in the FAR extension (1.7.4) * Improved script API support for EncodeMapper (1.7.4) * New header format for the EncodeMapper (1.7.4) * Many cleanups to the n-gram extension (1.7.4) * Improved C++17 compatibility shims (1.7.4) * Overloads Arc constructors with default weight argument (1.7.3) * Fixes RmEpsilon and Union property checking bugs (1.7.3) * Makes Isomorphic more robust to nondeterminism (1.7.3) * Adds default weight argument to SetFinal (1.7.3) * Cleans up low-level logging (1.7.3) * Adds power-weight mappers (1.7.3) * Adds expander cache (1.7.3) * Fixes bug with coinaccessible states in NaturalAStarEstimate (1.7.2) * Optionally allows building with Bazel (1.7.2) * Simplifies string printing interface (1.7.2) * Marks weight converters const (1.7.2) * Adds NoMatchComposeFilter (1.7.2) * Removed static assertions that trigger bugs in GCC (1.7.1) * Evaluates many weight operations at compile-time (1.7.1) * Improved use of move semantics, especially in cache-backed FSTs (1.7.0) * Adds configure-time test for float equality reflexivity (1.7.0) * Removes volatile qualifiers from float weights (1.7.0) * Protections for signedness in string compiler (1.7.0) * Adds additional overloads to Equals (1.7.0) * Clean-up to weight constructors (1.7.0) OpenFst: Release 1.6 * Optimized label lookup in SymbolTable (1.6.9) * Fixed HashMatcher issues with SetState() and Find() consistency (1.6.8) * Fixed PROGRAM_FLAGS documentation string in binaries (1.6.8) * Fixed handling of symbol tables in EpsNormalize (1.6.8) * Fixed error reporting when FST arc type unknown (1.6.8) * 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) * 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) * Fixes error handling in HashMatcher (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) * Adds float format support to FST drawing (1.6.1) * Fixes missing includes of (1.6.1) * 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) * Many classes and constants moved into an internal namespace (1.6.0) * Extensive modernization for C++11 style (1.6.0) * Adds Member method to SymbolTable (1.6.0) * Adds HashMatcher (1.6.0) OpenFst: Release 1.5 * Generalized epsilon normalization to non-functional case (1.5.0) * Added multiple pushdown transducer (MPDT) support (1.5.0) * Added general gallic (plus is union) semiring (1.5.0) * Added p-subsequential determinization (1.5.0) * Fixed missing Isomorphic components (1.5.0) * Added FST compression extension (1.5.0) * Added final method to matchers (1.5.0) * Fixed various compiler issues (1.5.0) * Fixed Isomorphic function (1.5.0) * Added Python extension (1.5.0) * Added UnionWeight (1.5.0) * Added missing const qualification to (1.5.1): - SymbolTableIterator access - EncodeMapper writing to file - EncodeMapper SymbolTable access * Added TrivialComposeFilter for more efficient composition when one of the arguments is epsilon-free (1.5.1) * Added InputEpsilonMapper and OutputEpsilonMapper arc mappers (1.5.1) * Added properties bits kUnweightedCycles and kWeightedCycles (1.5.1) * Replaced internal custom reference-counting (RefCounter) with C++11 smart pointers where possible, and fixed 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): - Adds methods for creating an empty mutable FST - Adds methods for FST access via state and arc iteration - Adds FST compilation from arclists (cf. fstcompile) - Adds FST printing and drawing - Adds FarReader and FarWriter classes. * Consolidated Python extension into single module (1.5.2) * FarReader's GetFst method now returns a pointer (1.5.2) * Python add_arc now takes an Arc object (1.5.2) * Fixed build flags for dlopen (1.5.2) * Fixed FSTERROR macro (1.5.2) * Scripting API and Python weight objects now support semiring arithmetic (1.5.3) * Mutation methods of the Python Fst object now support chaining (1.5.3) * Adds optional minimization of non-deterministic FSTs (1.5.3) * Adds check for error when opening files when compiling strings into FARs (1.5.4) * Prevents underflow when using LogProbArcSelector in random generation (1.5.4) * Adds routines for parsing string flags to the scripting API (1.5.4) * Makes random weight generators a single template class (1.5.4) * Makes weight Properties constexpr where possible (1.5.4) * Adds RemoveSymbol method to SymbolTable (1.5.4) OpenFst: Release 1.4 * Port to C++11 (1.4.0) * Isomorphic function added (1.4.0) * Disambiguate 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 openfst-1.7.9/README000066400000000000000000000074521421600557100140770ustar00rootroot00000000000000OpenFst 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.9) 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-fsts Enable all FST SO 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. If `import pywrapfst` fails from a PYthon 3.6 or better interpreter after installation, relocate pywrapfst.so to a directory in your interpreter's `sys.path` or $PYTHONPATH. 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. BUILDING WITH BAZEL: Release 1.7.2 provides the ability to build the core library and binaries as well as several extensions with Bazel and to depend on OpenFst as an external dependency in other projects compiled with Bazel. Please refer to https://bazel.build for information on using Bazel. OpenFst can be compiled from anywhere in the source tree, as follows: $ bazel build //:all Tests can be run in a similar fashion: $ bazel test //:all The Bazel build-file is provided as-is. DOCUMENTATION: See www.openfst.org for general documentation. See ./NEWS for updates since the last release. openfst-1.7.9/WORKSPACE000066400000000000000000000006461421600557100144760ustar00rootroot00000000000000workspace(name = "openfst") load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") http_archive( name = "com_google_absl", strip_prefix = "abseil-cpp-master", urls = ["https://github.com/abseil/abseil-cpp/archive/master.zip"], ) http_archive( name = "com_google_googletest", strip_prefix = "googletest-master", urls = ["https://github.com/google/googletest/archive/master.zip"], ) openfst-1.7.9/aclocal.m4000066400000000000000000001474571421600557100150710ustar00rootroot00000000000000# generated automatically by aclocal 1.16.1 -*- Autoconf -*- # Copyright (C) 1996-2018 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-2018 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.16' 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.16.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.16.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-2018 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-2018 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], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl # Expand $ac_aux_dir to an absolute path. am_aux_dir=`cd "$ac_aux_dir" && pwd` ]) # AM_CONDITIONAL -*- Autoconf -*- # Copyright (C) 1997-2018 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-2018 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-2018 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. # TODO: see whether this extra hack can be removed once we start # requiring Autoconf 2.70 or later. AS_CASE([$CONFIG_FILES], [*\'*], [eval set x "$CONFIG_FILES"], [*], [set x $CONFIG_FILES]) shift # Used to flag and report bootstrapping failures. am_rc=0 for am_mf do # Strip MF so we end up with the name of the file. am_mf=`AS_ECHO(["$am_mf"]) | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile which includes # dependency-tracking related rules and includes. # Grep'ing the whole file directly is not great: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \ || continue am_dirpart=`AS_DIRNAME(["$am_mf"])` am_filepart=`AS_BASENAME(["$am_mf"])` AM_RUN_LOG([cd "$am_dirpart" \ && sed -e '/# am--include-marker/d' "$am_filepart" \ | $MAKE -f - am--depfiles]) || am_rc=$? done if test $am_rc -ne 0; then AC_MSG_FAILURE([Something went wrong bootstrapping makefile fragments for automatic dependency tracking. Try re-running configure with the '--disable-dependency-tracking' option to at least be able to build the package (albeit without support for automatic dependency tracking).]) fi AS_UNSET([am_dirpart]) AS_UNSET([am_filepart]) AS_UNSET([am_mf]) AS_UNSET([am_rc]) rm -f conftest-deps.mk } ])# _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. # This creates each '.Po' and '.Plo' makefile fragment that we'll 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" MAKE="${MAKE-make}"])]) # Do all the work for Automake. -*- Autoconf -*- # Copyright (C) 1996-2018 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 (and possibly the TAP driver). 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 The trailing newline in this macro's definition is deliberate, for dnl backward compatibility and to allow trailing 'dnl'-style comments dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841. ]) 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-2018 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+set}" != 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-2018 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-2018 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 whether make has an 'include' directive that can support all # the idioms we need for our automatic dependency tracking code. AC_DEFUN([AM_MAKE_INCLUDE], [AC_MSG_CHECKING([whether ${MAKE-make} supports the include directive]) cat > confinc.mk << 'END' am__doit: @echo this is the am__doit target >confinc.out .PHONY: am__doit END am__include="#" am__quote= # BSD make does it like this. echo '.include "confinc.mk" # ignored' > confmf.BSD # Other make implementations (GNU, Solaris 10, AIX) do it like this. echo 'include confinc.mk # ignored' > confmf.GNU _am_result=no for s in GNU BSD; do AM_RUN_LOG([${MAKE-make} -f confmf.$s && cat confinc.out]) AS_CASE([$?:`cat confinc.out 2>/dev/null`], ['0:this is the am__doit target'], [AS_CASE([$s], [BSD], [am__include='.include' am__quote='"'], [am__include='include' am__quote=''])]) if test "$am__include" != "#"; then _am_result="yes ($s style)" break fi done rm -f confinc.* confmf.* AC_MSG_RESULT([${_am_result}]) AC_SUBST([am__include])]) AC_SUBST([am__quote])]) # Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- # Copyright (C) 1997-2018 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-2018 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-2018 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-2018 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 dnl python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 dnl python3.2 python3.1 python3.0 dnl python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 dnl 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-2018 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-2018 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-2018 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-2018 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-2018 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-2018 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/ax_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]) openfst-1.7.9/ar-lib000077500000000000000000000133031421600557100143030ustar00rootroot00000000000000#! /bin/sh # Wrapper for Microsoft lib.exe me=ar-lib scriptversion=2012-03-01.08; # UTC # Copyright (C) 2010-2018 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 | \ icl | *[/\\]icl | icl.exe | *[/\\]icl.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 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: openfst-1.7.9/config.guess000077500000000000000000001263731421600557100155430ustar00rootroot00000000000000#! /bin/sh # Attempt to guess a canonical system name. # Copyright 1992-2018 Free Software Foundation, Inc. timestamp='2018-02-24' # 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; maintained since 2000 by Ben Elliston. # # You can get the latest version of this script from: # https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess # # Please send patches to . me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Options: -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-2018 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' | sed 's, ,,g'`" # If ldd exists, use it to detect musl libc. if command -v ldd >/dev/null && \ ldd --version 2>&1 | grep -q ^musl then LIBC=musl fi ;; 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=`(uname -p 2>/dev/null || \ "/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 ;; earmv*) arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` machine="${arch}${endian}"-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) and ABI. case "$UNAME_MACHINE_ARCH" in earm*) os=netbsdelf ;; 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 # Determine ABI tags. case "$UNAME_MACHINE_ARCH" in earm*) expr='s/^earmv[0-9]/-eabi/;s/eb$//' abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` ;; 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/[-_].*//' | cut -d. -f1,2` ;; 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}${abi}" 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 ;; *:LibertyBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE" exit ;; *:MidnightBSD:*:*) echo "$UNAME_MACHINE"-unknown-midnightbsd"$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 ;; *:Sortix:*:*) echo "$UNAME_MACHINE"-unknown-sortix exit ;; *:Redox:*:*) echo "$UNAME_MACHINE"-unknown-redox exit ;; mips:OSF1:*.*) echo mips-dec-osf1 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 ;; 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/lslpp ] ; then IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` 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:4.4BSD:*) 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) UNAME_PROCESSOR=x86_64 ;; i386) UNAME_PROCESSOR=i586 ;; esac echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" exit ;; i*:CYGWIN*:*) echo "$UNAME_MACHINE"-pc-cygwin exit ;; *:MINGW64*:*) echo "$UNAME_MACHINE"-pc-mingw64 exit ;; *:MINGW*:*) echo "$UNAME_MACHINE"-pc-mingw32 exit ;; *:MSYS*:*) echo "$UNAME_MACHINE"-pc-msys 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 ;; i*:UWIN*:*) echo "$UNAME_MACHINE"-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-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 "[:upper:]" "[:lower:]"``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 ;; e2k:Linux:*:*) echo "$UNAME_MACHINE"-unknown-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 ;; k1om: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; } ;; mips64el:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; openrisc*:Linux:*:*) echo or1k-unknown-linux-"$LIBC" exit ;; or32:Linux:*:* | or1k*: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 ;; riscv32:Linux:*:* | riscv64:Linux:*:*) echo "$UNAME_MACHINE"-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:*:*) if objdump -f /bin/sh | grep -q elf32-x86-64; then echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32 else echo "$UNAME_MACHINE"-pc-linux-"$LIBC" fi 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.*:*) 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 configure 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 ;; SX-ACE:SUPER-UX:*:*) echo sxace-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 test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then 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 # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_PPC >/dev/null then UNAME_PROCESSOR=powerpc fi fi elif test "$UNAME_PROCESSOR" = i386 ; then # Avoid executing cc on OS X 10.9, as it ships with a stub # that puts up a graphical alert prompting to install # developer tools. Any system running Mac OS X 10.7 or # later (Darwin 11 and later) is required to have a 64-bit # processor. This is not true of the ARM version of Darwin # that Apple uses in portable devices. UNAME_PROCESSOR=x86_64 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 ;; NSV-*:NONSTOP_KERNEL:*:*) echo nsv-tandem-nsk"$UNAME_RELEASE" exit ;; NSX-*:NONSTOP_KERNEL:*:*) echo nsx-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 ;; amd64:Isilon\ OneFS:*:*) echo x86_64-unknown-onefs exit ;; esac echo "$0: unable to guess system type" >&2 case "$UNAME_MACHINE:$UNAME_SYSTEM" in mips:Linux | mips64:Linux) # If we got here on MIPS GNU/Linux, output extra information. cat >&2 <&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-functions 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: openfst-1.7.9/config.h.in000066400000000000000000000032501421600557100152320ustar00rootroot00000000000000/* 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 /* If available, contains the Python version number currently in use. */ #undef HAVE_PYTHON /* 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 where 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 openfst-1.7.9/config.sub000077500000000000000000001064501421600557100152000ustar00rootroot00000000000000#! /bin/sh # Configuration validation subroutine script. # Copyright 1992-2018 Free Software Foundation, Inc. timestamp='2018-02-22' # 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 to . # # 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: # https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub # 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 or ALIAS Canonicalize a configuration name. Options: -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-2018 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* | netbsd*-eabi* | \ kopensolaris*-gnu* | cloudabi*-eabi* | \ 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/'` ;; -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 \ | ba \ | be32 | be64 \ | bfin \ | c4x | c8051 | clipper \ | d10v | d30v | dlx | dsp16xx \ | e2k | epiphany \ | fido | fr30 | frv | ft32 \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | hexagon \ | i370 | i860 | i960 | ia16 | ia64 \ | ip2k | iq2000 \ | k1om \ | 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 \ | mipsisa32r6 | mipsisa32r6el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64r6 | mipsisa64r6el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipsr5900 | mipsr5900el \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nds32 | nds32le | nds32be \ | nios | nios2 | nios2eb | nios2el \ | ns16k | ns32k \ | open8 | or1k | or1knd | or32 \ | pdp10 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle \ | pru \ | pyramid \ | riscv32 | riscv64 \ | rl78 | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]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 \ | visium \ | wasm32 \ | 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 ;; leon|leon[3-9]) basic_machine=sparc-$basic_machine ;; m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip) basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65) ;; 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-* \ | ba-* \ | be32-* | be64-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* \ | c8051-* | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | e2k-* | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | hexagon-* \ | i*86-* | i860-* | i960-* | ia16-* | ia64-* \ | ip2k-* | iq2000-* \ | k1om-* \ | 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-* \ | mipsisa32r6-* | mipsisa32r6el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64r6-* | mipsisa64r6el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipsr5900-* | mipsr5900el-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* | nios2eb-* | nios2el-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | open8-* \ | or1k*-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ | pru-* \ | pyramid-* \ | riscv32-* | riscv64-* \ | 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-* \ | visium-* \ | wasm32-* \ | 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-pc 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 ;; asmjs) basic_machine=asmjs-unknown ;; 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*) basic_machine=m68k-bull os=-sysv3 ;; e500v[12]) basic_machine=powerpc-unknown os=$os"spe" ;; e500v[12]-*) basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'` os=$os"spe" ;; 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 ;; 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 ;; 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 ;; leon-*|leon[3-9]-*) basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'` ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'` os=-linux ;; 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 ;; moxiebox) basic_machine=moxie-unknown os=-moxiebox ;; 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 ;; nsv-tandem) basic_machine=nsv-tandem ;; nsx-tandem) basic_machine=nsx-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) 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) 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 ;; sh5el) basic_machine=sh5le-unknown ;; 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 ;; x64) basic_machine=x86_64-pc ;; 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 ;; 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 ;; 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 ;; 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 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # es1800 is here to avoid being matched by es* (a different OS) -es1800*) os=-ose ;; # Now 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* | -cloudabi* | -sortix* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \ | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \ | -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* | -glidix* \ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ | -linux-newlib* | -linux-musl* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \ | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \ | -midnightbsd*) # 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 | -xray | -os68k* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* \ | -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 ;; -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 ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -pikeos*) # Until real need of OS specific support for # particular features comes up, bare metal # configurations are quite functional. case $basic_machine in arm*) os=-eabi ;; *) os=-elf ;; esac ;; -nacl*) ;; -ios) ;; -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 ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; pru-*) os=-elf ;; *-be) os=-beos ;; *-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 ;; *-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-functions 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: openfst-1.7.9/configure000077500000000000000000022575771421600557100151470ustar00rootroot00000000000000#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for OpenFst 1.7.9. # # 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.7.9' PACKAGE_STRING='OpenFst 1.7.9' 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_FSTS_FALSE HAVE_FSTS_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_LIBS 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 LT_SYS_LIBRARY_PATH 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__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 runstatedir 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 am__quote' 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_aix_soname 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_fsts enable_grm with_libfstdir ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CXX CXXFLAGS CCC LT_SYS_LIBRARY_PATH 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' runstatedir='${localstatedir}/run' 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 ;; -runstatedir | --runstatedir | --runstatedi | --runstated \ | --runstate | --runstat | --runsta | --runst | --runs \ | --run | --ru | --r) ac_prev=runstatedir ;; -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ | --run=* | --ru=* | --r=*) runstatedir=$ac_optarg ;; -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 runstatedir 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.7.9 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] --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] --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.7.9:";; 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-fsts enable all FST SOs --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-aix-soname=aix|svr4|both shared library versioning (aka "SONAME") variant to provide on AIX, [default=aix]. --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 LT_SYS_LIBRARY_PATH User-defined run-time library search path. 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.7.9 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 # ac_fn_cxx_try_run LINENO # ------------------------ # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_cxx_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_cxx_try_run 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.7.9, 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.16' 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+set}" != 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.7.9' 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 (and possibly the TAP driver). 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" { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5 $as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; } cat > confinc.mk << 'END' am__doit: @echo this is the am__doit target >confinc.out .PHONY: am__doit END am__include="#" am__quote= # BSD make does it like this. echo '.include "confinc.mk" # ignored' > confmf.BSD # Other make implementations (GNU, Solaris 10, AIX) do it like this. echo 'include confinc.mk # ignored' > confmf.GNU _am_result=no for s in GNU BSD; do { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5 (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } case $?:`cat confinc.out 2>/dev/null` in #( '0:this is the am__doit target') : case $s in #( BSD) : am__include='.include' am__quote='"' ;; #( *) : am__include='include' am__quote='' ;; esac ;; #( *) : ;; esac if test "$am__include" != "#"; then _am_result="yes ($s style)" break fi done rm -f confinc.* confmf.* { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5 $as_echo "${_am_result}" >&6; } # 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 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 # This library does not throw exceptions, so we do not generate exception # handling code. However, users are free to re-enable exception handling. CXX="$CXX -std=c++11 -fno-exceptions" # 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.6' macro_revision='2.4.6' 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 no = "$withval" || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld if test yes = "$GCC"; 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 yes = "$with_gnu_ld"; 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 # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty case $build_os in mingw*) lt_bad_file=conftest.nm/nofile ;; *) lt_bad_file=/dev/null ;; esac case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in *$lt_bad_file* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break 2 ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break 2 ;; *) 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 no != "$lt_cv_path_NM"; 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 -headers /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols -headers" ;; *) 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; ;; bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*) # 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 17 != "$i" # 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"} 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 yes != "$GCC"; then reload_cmds=false fi ;; darwin*) if test yes = "$GCC"; 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 # that 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. if ( 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* | bitrig*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; 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 ;; os2*) 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 one 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=cr} { $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 0 -eq "$ac_status"; 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 0 -ne "$ac_status"; 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 no = "$lt_cv_ar_at_file"; 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 bitrig* | 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 ia64 = "$host_cpu"; 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 if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Gets list of data symbols to import. lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'" # Adjust the below global symbol transforms to fixup imported variables. lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'" lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'" lt_c_name_lib_hook="\ -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\ -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'" else # Disable hooks by default. lt_cv_sys_global_symbol_to_import= lt_cdecl_hook= lt_c_name_hook= lt_c_name_lib_hook= fi # 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"\ $lt_cdecl_hook\ " -e 's/^T .* \(.*\)$/extern int \1();/p'"\ " -e 's/^$symcode$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"\ $lt_c_name_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'" # Transform an extracted symbol line into symbol name with lib prefix and # symbol address. lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\ $lt_c_name_lib_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/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, # D for any global variable and I for any imported 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};"\ " /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ " /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ " /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ " {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ " s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print f,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 $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&5 if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&5 && 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 can'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* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$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 yes = "$pipe_works"; 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 yes = "$GCC"; 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; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5 $as_echo_n "checking for a working dd... " >&6; } if ${ac_cv_path_lt_DD+:} false; then : $as_echo_n "(cached) " >&6 else printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i : ${lt_DD:=$DD} if test -z "$lt_DD"; then ac_path_lt_DD_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 dd; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_lt_DD" || continue if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: fi $ac_path_lt_DD_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_lt_DD"; then : fi else ac_cv_path_lt_DD=$lt_DD fi rm -f conftest.i conftest2.i conftest.out fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5 $as_echo "$ac_cv_path_lt_DD" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5 $as_echo_n "checking how to truncate binary pipes... " >&6; } if ${lt_cv_truncate_bin+:} false; then : $as_echo_n "(cached) " >&6 else printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i lt_cv_truncate_bin= if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" fi rm -f conftest.i conftest2.i conftest.out test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5 $as_echo "$lt_cv_truncate_bin" >&6; } # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in $*""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } # Check whether --enable-libtool-lock was given. if test "${enable_libtool_lock+set}" = set; then : enableval=$enable_libtool_lock; fi test no = "$enable_libtool_lock" || 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 what ABI is being produced by ac_compile, and set mode # options accordingly. 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 what ABI is being produced by ac_compile, and set linker # options accordingly. 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 yes = "$lt_cv_prog_gnu_ld"; 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* ;; mips64*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. 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 emul=elf case `/usr/bin/file conftest.$ac_objext` in *32-bit*) emul="${emul}32" ;; *64-bit*) emul="${emul}64" ;; esac case `/usr/bin/file conftest.$ac_objext` in *MSB*) emul="${emul}btsmip" ;; *LSB*) emul="${emul}ltsmip" ;; esac case `/usr/bin/file conftest.$ac_objext` in *N32*) emul="${emul}n32" ;; esac LD="${LD-ld} -m $emul" fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. Note that the listed cases only cover the # situations where additional linker options are needed (such as when # doing 32-bit compilation for a host where ld defaults to 64-bit, or # vice versa); the common cases where no linker options are needed do # not appear in the list. 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-*linux*) LD="${LD-ld} -m elf32lppclinux" ;; powerpc64-*linux*) 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-*linux*) LD="${LD-ld} -m elf64lppc" ;; powerpc-*linux*) 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 yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS=$SAVE_CFLAGS fi ;; *-*solaris*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. 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*|x86_64-*-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 yes != "$lt_cv_path_mainfest_tool"; 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 0 = "$_lt_result"; 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 cr libconftest.a conftest.o" >&5 $AR cr 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 0 = "$_lt_result" && $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 yes = "$lt_cv_apple_cc_single_mod"; then _lt_dar_single_mod='$single_module' fi if test yes = "$lt_cv_ld_exported_symbols_list"; 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 no = "$lt_cv_ld_force_load"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= fi ;; esac # func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x$2 in x) ;; *:) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" ;; x:*) eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" ;; *::*) eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" ;; *) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" ;; 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 # 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 shared_archive_member_spec= case $host,$enable_shared in power*-*-aix[5-9]*,yes) { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5 $as_echo_n "checking which variant of shared library versioning to provide... " >&6; } # Check whether --with-aix-soname was given. if test "${with_aix_soname+set}" = set; then : withval=$with_aix_soname; case $withval in aix|svr4|both) ;; *) as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5 ;; esac lt_cv_with_aix_soname=$with_aix_soname else if ${lt_cv_with_aix_soname+:} false; then : $as_echo_n "(cached) " >&6 else lt_cv_with_aix_soname=aix fi with_aix_soname=$lt_cv_with_aix_soname fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5 $as_echo "$with_aix_soname" >&6; } if test aix != "$with_aix_soname"; then # For the AIX way of multilib, we name the shared archive member # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, # the AIX toolchain works better with OBJECT_MODE set (default 32). if test 64 = "${OBJECT_MODE-32}"; then shared_archive_member_spec=shr_64 else shared_archive_member_spec=shr fi fi ;; *) with_aix_soname=aix ;; esac # 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 set != "${COLLECT_NAMES+set}"; 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 func_cc_basename $compiler cc_basename=$func_cc_basename_result # 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 yes = "$GCC"; 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_rtti_exceptions"; 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 yes = "$GCC"; then lt_prog_compiler_wl='-Wl,' lt_prog_compiler_static='-static' case $host_os in aix*) # All AIX code is PIC. if test ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' fi lt_prog_compiler_pic='-fPIC' ;; 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' case $host_os in os2*) lt_prog_compiler_static='$wl-static' ;; esac ;; 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 ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static='-Bstatic' else lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' fi ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files lt_prog_compiler_pic='-fno-common' case $cc_basename in nagfor*) # NAG Fortran compiler lt_prog_compiler_wl='-Wl,-Wl,,' lt_prog_compiler_pic='-PIC' lt_prog_compiler_static='-Bstatic' ;; esac ;; 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' case $host_os in os2*) lt_prog_compiler_static='$wl-static' ;; esac ;; 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' ;; # flang / f18. f95 an alias for gfortran or flang on Debian flang* | f18* | f95*) lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fPIC' 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' ;; tcc*) # Fabrice Bellard et al's Tiny C Compiler lt_prog_compiler_wl='-Wl,' lt_prog_compiler_pic='-fPIC' lt_prog_compiler_static='-static' ;; 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 that 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_pic_works"; 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 yes = "$lt_cv_prog_compiler_static_works"; 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 no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; 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 no = "$hard_links"; 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 yes != "$GCC"; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd* | bitrig*) 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 yes = "$with_gnu_ld"; 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 yes = "$lt_use_gnu_ld_interface"; 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 | $SED -e 's/(^)\+)\s\+//' 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 ia64 != "$host_cpu"; 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, use it as # is; otherwise, prepend EXPORTS... archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; 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 ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported shrext_cmds=.dll archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes=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 linux-dietlibc = "$host_os"; 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 no = "$tmp_diet" 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' ;; nagfor*) # NAGFOR 5.3 tmp_sharedflag='-Wl,-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 yes = "$supports_anon_versioning"; 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 tcc*) export_dynamic_flag_spec='-rdynamic' ;; 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 yes = "$supports_anon_versioning"; 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 cannot *** 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 no = "$ld_shlibs"; 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 yes = "$GCC" && 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 ia64 = "$host_cpu"; 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. 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) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) for ld_flag in $LDFLAGS; do if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then aix_use_runtimelinking=yes break fi done if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # traditional, no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. hardcode_direct=no hardcode_direct_absolute=no ;; esac if test yes = "$GCC"; 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 yes = "$aix_use_runtimelinking"; then shared_flag="$shared_flag "'$wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' 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,yes = "$with_aix_soname,$aix_use_runtimelinking"; 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 set = "${lt_cv_aix_libpath+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 -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; 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 set = "${lt_cv_aix_libpath+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 yes = "$with_gnu_ld"; 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 archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared libraries. archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols archive_expsym_cmds="$archive_expsym_cmds"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d' 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,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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 yes = "$lt_cv_ld_force_load"; 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*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test yes = "$_lt_dar_can_shared"; 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 yes = "$GCC"; 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 "x$output_objdir/$soname" = "x$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 "x$output_objdir/$soname" = "x$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 yes,no = "$GCC,$with_gnu_ld"; 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 no = "$with_gnu_ld"; 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 yes,no = "$GCC,$with_gnu_ld"; 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 yes = "$lt_cv_prog_compiler__b"; 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 no = "$with_gnu_ld"; 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 yes = "$GCC"; 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 yes = "$lt_cv_irix_exported_symbol"; 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 link_all_deplibs=no 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 ;; linux*) case $cc_basename in tcc*) # Fabrice Bellard et al's Tiny C Compiler ld_shlibs=yes archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; 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* | bitrig*) 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__`"; 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 archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' hardcode_libdir_flag_spec='$wl-rpath,$libdir' fi else ld_shlibs=no fi ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes allow_undefined_flag=unsupported shrext_cmds=.dll archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes=yes ;; osf3*) if test yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 sequent = "$host_vendor"; 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 yes = "$GCC"; 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 CANNOT 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 yes = "$GCC"; 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 sni = "$host_vendor"; 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 no = "$ld_shlibs" && 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 yes,yes = "$GCC,$enable_shared"; 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 yes = "$GCC"; 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` # ...but if some path component already ends with the multilib dir we assume # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). case "$lt_multi_os_dir; $lt_search_path_spec " in "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) lt_multi_os_dir= ;; esac 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" elif test -n "$lt_multi_os_dir"; then 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 ia64 = "$host_cpu"; 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 # Using Import Files as archive members, it is possible to support # filename-based versioning of shared library archives on AIX. While # this would work for both with and without runtime linking, it will # prevent static linking of such archives. So we do filename-based # shared library versioning with .so extension only, which is used # when both runtime linking and shared linking is enabled. # Unfortunately, runtime linking may impact performance, so we do # not want this to be the default eventually. Also, we use the # versioned .so libs for executables only if there is the -brtl # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. # To allow for filename-based versioning support, we need to create # libNAME.so.V as an archive file, containing: # *) an Import File, referring to the versioned filename of the # archive as well as the shared archive member, telling the # bitwidth (32 or 64) of that shared object, and providing the # list of exported symbols of that shared object, eventually # decorated with the 'weak' keyword # *) the shared object with the F_LOADONLY flag set, to really avoid # it being seen by the linker. # At run time we better use the real file rather than another symlink, # but for link time we create the symlink libNAME.so -> libNAME.so.V case $with_aix_soname,$aix_use_runtimelinking in # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. aix,yes) # traditional libtool dynamic_linker='AIX unversionable lib.so' # 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' ;; aix,no) # traditional AIX only dynamic_linker='AIX lib.a(lib.so.V)' # 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' ;; svr4,*) # full svr4 only dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,yes) # both, prefer svr4 dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # unpreferred sharedlib libNAME.a needs extra handling postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,no) # both, prefer aix dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release.a $libname.a' soname_spec='$libname$release$shared_ext$major' # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' ;; esac 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%'\''`; $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$major $libname$shared_ext' soname_spec='$libname$release$shared_ext$major' 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=no 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 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi ;; 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 yes = "$lt_cv_prog_gnu_ld"; 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 ;; linux*android*) version_type=none # Android doesn't support versioned libraries. need_lib_prefix=no need_version=no library_names_spec='$libname$release$shared_ext' soname_spec='$libname$release$shared_ext' finish_cmds= shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # 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 dynamic_linker='Android linker' # Don't embed -rpath directories since the linker doesn't support them. hardcode_libdir_flag_spec='-L$libdir' ;; # 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 # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, # even though it is searched at run-time. Try to do the best guess by # appending ld.so.conf contents (and includes) 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* | bitrig*) version_type=sunos sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then need_version=no else need_version=yes fi 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 shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' version_type=windows shrext_cmds=.dll need_version=no need_lib_prefix=no # OS/2 can only load a DLL with a base name of 8 characters or less. soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; v=$($ECHO $release$versuffix | tr -d .-); n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); $ECHO $n$v`$shared_ext' library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' shlibpath_var=BEGINLIBPATH sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec 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' ;; 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 yes = "$with_gnu_ld"; 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=sco 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 yes = "$with_gnu_ld"; 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 no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi # remember unaugmented sys_lib_dlsearch_path content for libtool script decls... configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH { $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 yes = "$hardcode_automatic"; then # We can hardcode non-existent directories. if test no != "$hardcode_direct" && # 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 no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" && test no != "$hardcode_minus_L"; 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 relink = "$hardcode_action" || test yes = "$inherit_rpath"; then # Fast installation is not supported enable_fast_install=no elif test yes = "$shlibpath_overrides_runpath" || test no = "$enable_shared"; then # Fast installation is not necessary enable_fast_install=needless fi if test yes != "$enable_dlopen"; 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 ;; tpf*) # Don't try to run any link tests for TPF. We know it's impossible # because TPF is a cross-compiler, and we know how we open DSOs. lt_cv_dlopen=dlopen lt_cv_dlopen_libs= lt_cv_dlopen_self=no ;; *) 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 no = "$lt_cv_dlopen"; then enable_dlopen=no else enable_dlopen=yes fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS=$CPPFLAGS test yes = "$ac_cv_header_dlfcn_h" && 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 yes = "$cross_compiling"; 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 -fvisibility=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 yes = "$lt_cv_dlopen_self"; 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 yes = "$cross_compiling"; 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 -fvisibility=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 what 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 no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[4-9]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac 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 yes = "$enable_shared" || 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 no != "$CXX" && ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) || (test g++ != "$CXX"))); 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 yes != "$_lt_caught_CXX_error"; 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 func_cc_basename $compiler cc_basename=$func_cc_basename_result if test -n "$compiler"; then # We don't want -fno-exception when compiling C++ code, so set the # no_builtin_flag separately if test yes = "$GXX"; then lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' else lt_prog_compiler_no_builtin_flag_CXX= fi if test yes = "$GXX"; 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 no = "$withval" || with_gnu_ld=yes else with_gnu_ld=no fi ac_prog=ld if test yes = "$GCC"; 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 yes = "$with_gnu_ld"; 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 yes = "$with_gnu_ld"; 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 ia64 = "$host_cpu"; 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive 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 if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. hardcode_direct_CXX=no hardcode_direct_absolute_CXX=no ;; esac if test yes = "$GXX"; 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 yes = "$aix_use_runtimelinking"; then shared_flag=$shared_flag' $wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' 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,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. # The "-G" linker flag allows undefined symbols. no_undefined_flag_CXX='-bernotok' # Determine the default libpath from the value encoded in an empty # executable. if test set = "${lt_cv_aix_libpath+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 -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; 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 set = "${lt_cv_aix_libpath+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 yes = "$with_gnu_ld"; 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 archive_expsym_cmds_CXX='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([, ]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared # libraries. Need -bnortl late, we may have -brtl in LDFLAGS. archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$RM -r $output_objdir/$realname.d' 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,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' archive_expsym_cmds_CXX='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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, use it as # is; otherwise, prepend EXPORTS... archive_expsym_cmds_CXX='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; 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 yes = "$lt_cv_ld_force_load"; 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*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test yes = "$_lt_dar_can_shared"; 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 yes != "$lt_cv_apple_cc_single_mod"; 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 ;; os2*) hardcode_libdir_flag_spec_CXX='-L$libdir' hardcode_minus_L_CXX=yes allow_undefined_flag_CXX=unsupported shrext_cmds=.dll archive_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' archive_expsym_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' old_archive_From_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' enable_shared_with_static_runtimes_CXX=yes ;; 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 "x$output_objdir/$soname" = "x$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 yes = "$GXX"; 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 "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' else # FIXME: insert proper C++ library support ld_shlibs_CXX=no fi ;; esac ;; hpux10*|hpux11*) if test no = "$with_gnu_ld"; 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 yes = "$GXX"; then if test no = "$with_gnu_ld"; 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 yes = "$GXX"; then if test no = "$with_gnu_ld"; 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 yes = "$supports_anon_versioning"; 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 ;; openbsd* | bitrig*) 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__`"; 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 yes,no = "$GXX,$with_gnu_ld"; 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 yes,no = "$GXX,$with_gnu_ld"; 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 $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 $wl-h $wl$soname -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 $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 $wl-h $wl$soname -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 CANNOT 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 no = "$ld_shlibs_CXX" && 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 x-L = "$p" || test x-R = "$p"; 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 no = "$pre_test_object_deps_done"; 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 no = "$pre_test_object_deps_done"; 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= ;; 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 yes = "$GXX"; 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 ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor lt_prog_compiler_static_CXX='-Bstatic' fi lt_prog_compiler_pic_CXX='-fPIC' ;; 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' case $host_os in os2*) lt_prog_compiler_static_CXX='$wl-static' ;; esac ;; 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 ia64 = "$host_cpu"; 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 ia64 != "$host_cpu"; 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 that 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "$lt_cv_prog_compiler_pic_works_CXX"; 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 yes = "$lt_cv_prog_compiler_static_works_CXX"; 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 no = "$lt_cv_prog_compiler_c_o_CXX" && test no != "$need_locks"; 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 no = "$hard_links"; 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. 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) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B\([^B]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | 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 no = "$ld_shlibs_CXX" && 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 yes,yes = "$GCC,$enable_shared"; 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 ia64 = "$host_cpu"; 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 # Using Import Files as archive members, it is possible to support # filename-based versioning of shared library archives on AIX. While # this would work for both with and without runtime linking, it will # prevent static linking of such archives. So we do filename-based # shared library versioning with .so extension only, which is used # when both runtime linking and shared linking is enabled. # Unfortunately, runtime linking may impact performance, so we do # not want this to be the default eventually. Also, we use the # versioned .so libs for executables only if there is the -brtl # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. # To allow for filename-based versioning support, we need to create # libNAME.so.V as an archive file, containing: # *) an Import File, referring to the versioned filename of the # archive as well as the shared archive member, telling the # bitwidth (32 or 64) of that shared object, and providing the # list of exported symbols of that shared object, eventually # decorated with the 'weak' keyword # *) the shared object with the F_LOADONLY flag set, to really avoid # it being seen by the linker. # At run time we better use the real file rather than another symlink, # but for link time we create the symlink libNAME.so -> libNAME.so.V case $with_aix_soname,$aix_use_runtimelinking in # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. aix,yes) # traditional libtool dynamic_linker='AIX unversionable lib.so' # 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' ;; aix,no) # traditional AIX only dynamic_linker='AIX lib.a(lib.so.V)' # 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' ;; svr4,*) # full svr4 only dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,yes) # both, prefer svr4 dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # unpreferred sharedlib libNAME.a needs extra handling postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,no) # both, prefer aix dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)" library_names_spec='$libname$release.a $libname.a' soname_spec='$libname$release$shared_ext$major' # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' ;; esac 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%'\''`; $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$major $libname$shared_ext' soname_spec='$libname$release$shared_ext$major' 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=no 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 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi ;; 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 yes = "$lt_cv_prog_gnu_ld"; 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 ;; linux*android*) version_type=none # Android doesn't support versioned libraries. need_lib_prefix=no need_version=no library_names_spec='$libname$release$shared_ext' soname_spec='$libname$release$shared_ext' finish_cmds= shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # 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 dynamic_linker='Android linker' # Don't embed -rpath directories since the linker doesn't support them. hardcode_libdir_flag_spec_CXX='-L$libdir' ;; # 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 # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, # even though it is searched at run-time. Try to do the best guess by # appending ld.so.conf contents (and includes) 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* | bitrig*) version_type=sunos sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then need_version=no else need_version=yes fi 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 shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' version_type=windows shrext_cmds=.dll need_version=no need_lib_prefix=no # OS/2 can only load a DLL with a base name of 8 characters or less. soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; v=$($ECHO $release$versuffix | tr -d .-); n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); $ECHO $n$v`$shared_ext' library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' shlibpath_var=BEGINLIBPATH sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec 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' ;; 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 yes = "$with_gnu_ld"; 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=sco 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 yes = "$with_gnu_ld"; 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 no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi # remember unaugmented sys_lib_dlsearch_path content for libtool script decls... configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH { $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 yes = "$hardcode_automatic_CXX"; then # We can hardcode non-existent directories. if test no != "$hardcode_direct_CXX" && # 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 no != "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" && test no != "$hardcode_minus_L_CXX"; 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 relink = "$hardcode_action_CXX" || test yes = "$inherit_rpath_CXX"; then # Fast installation is not supported enable_fast_install=no elif test yes = "$shlibpath_overrides_runpath" || test no = "$enable_shared"; 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 yes != "$_lt_caught_CXX_error" 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 >= 3.6" >&5 $as_echo_n "checking whether $PYTHON version is >= 3.6... " >&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, '3.6'.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 >= 3.6" >&5 $as_echo_n "checking for a Python interpreter with version >= 3.6... " >&6; } if ${am_cv_pathless_PYTHON+:} false; then : $as_echo_n "(cached) " >&6 else for am_cv_pathless_PYTHON in python python2 python3 python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 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, '3.6'.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; \ ver = sys.version.split ()[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_LIBS, 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 ">= '3.6'"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a version of Python >= '3.6'" >&5 $as_echo_n "checking for a version of Python >= '3.6'... " >&6; } ac_supports_python_ver=`$PYTHON -c "import sys; \ ver = sys.version.split ()[0]; \ print (ver >= '3.6')"` 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 >= '3.6'. 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 $? -eq 0; 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 ());"` plat_python_path=`$PYTHON -c "import distutils.sysconfig; \ print (distutils.sysconfig.get_python_inc (plat_specific=1));"` if test -n "${python_path}"; then if test "${plat_python_path}" != "${python_path}"; then python_path="-I$python_path -I$plat_python_path" else python_path="-I$python_path" fi 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_LIBS"; then # (makes two attempts to ensure we've got a version number # from the interpreter) ac_python_version=`cat<>confdefs.h <<_ACEOF #define HAVE_PYTHON "$ac_python_version" _ACEOF # First, the library directory: ac_python_libdir=`cat<&5 $as_echo "$PYTHON_LIBS" >&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('LIBS') + ' ' + conf('SYSLIBS'))"` 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; } # save current global flags ac_save_LIBS="$LIBS" ac_save_LDFLAGS="$LDFLAGS" ac_save_CPPFLAGS="$CPPFLAGS" LIBS="$ac_save_LIBS $PYTHON_LIBS $PYTHON_EXTRA_LIBS $PYTHON_EXTRA_LIBS" LDFLAGS="$ac_save_LDFLAGS $PYTHON_EXTRA_LDFLAGS" CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS" 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. */ #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 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" LDFLAGS="$ac_save_LDFLAGS" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $pythonexists" >&5 $as_echo "$pythonexists" >&6; } if test ! "x$pythonexists" = "xyes"; then { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} 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 LIBS environment variable. Example: ./configure LIBS=\"-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. ============================================================================ See \`config.log' for more details" "$LINENO" 5; } PYTHON_VERSION="" fi # # 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-fsts is an alias to enable FST SO extensions: compact, const, # linear, lookahead, and ngram. # Check whether --enable-fsts was given. if test "${enable_fsts+set}" = set; then : enableval=$enable_fsts; else enable_fsts=no fi if test "x$enable_fsts" != xno; then HAVE_FSTS_TRUE= HAVE_FSTS_FALSE='#' else HAVE_FSTS_TRUE='#' HAVE_FSTS_FALSE= fi # --enable-grm is an alias to enable all 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 # Flags may be changed after configuring, so this is checked again by # weight_test.cc. The check here is to save time in the common case, # or when someone does not run `make check`. if test "$cross_compiling" = yes; then : { { $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 test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include template bool FloatEqIsReflexive(T m) { volatile T x = 1.111; x *= m; T y = 1.111; y *= m; return x == y; } int main () { volatile double test_value = 1.1; if (!FloatEqIsReflexive(static_cast(test_value))) { printf("float FAIL\n"); return 1; } if (!FloatEqIsReflexive(test_value)) { printf("double FAIL\n"); return 1; } ; return 0; } _ACEOF if ac_fn_cxx_try_run "$LINENO"; then : echo "Float equality is good" 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 $? "Test float equality failed! Compile with -msse -mfpmath=sse if using g++. See \`config.log' for more details" "$LINENO" 5; } fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi { $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_FSTS_TRUE}" && test -z "${HAVE_FSTS_FALSE}"; then as_fn_error $? "conditional \"HAVE_FSTS\" 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.7.9, 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.7.9 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" MAKE="${MAKE-make}" # 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"`' shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $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_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $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"`' lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $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"`' lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $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"`' configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`' configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $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_import \ lt_cv_sys_global_symbol_to_c_name_address \ lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ lt_cv_nm_interface \ nm_file_list_spec \ lt_cv_truncate_bin \ 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\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) 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 \ configure_time_dlsearch_path \ configure_time_lt_sys_library_path \ 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\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done ac_aux_dir='$ac_aux_dir' # See if we are running on zsh, and set the options that 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' 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. # TODO: see whether this extra hack can be removed once we start # requiring Autoconf 2.70 or later. case $CONFIG_FILES in #( *\'*) : eval set x "$CONFIG_FILES" ;; #( *) : set x $CONFIG_FILES ;; #( *) : ;; esac shift # Used to flag and report bootstrapping failures. am_rc=0 for am_mf do # Strip MF so we end up with the name of the file. am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile which includes # dependency-tracking related rules and includes. # Grep'ing the whole file directly is not great: AIX grep has a line # limit of 2048, but all sed's we know have understand at least 4000. sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \ || continue am_dirpart=`$as_dirname -- "$am_mf" || $as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$am_mf" : 'X\(//\)[^/]' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$am_mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` am_filepart=`$as_basename -- "$am_mf" || $as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$am_mf" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` { echo "$as_me:$LINENO: cd "$am_dirpart" \ && sed -e '/# am--include-marker/d' "$am_filepart" \ | $MAKE -f - am--depfiles" >&5 (cd "$am_dirpart" \ && sed -e '/# am--include-marker/d' "$am_filepart" \ | $MAKE -f - am--depfiles) >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } || am_rc=$? done if test $am_rc -ne 0; then { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "Something went wrong bootstrapping makefile fragments for automatic dependency tracking. Try re-running configure with the '--disable-dependency-tracking' option to at least be able to build the package (albeit without support for automatic dependency tracking). See \`config.log' for more details" "$LINENO" 5; } fi { am_dirpart=; unset am_dirpart;} { am_filepart=; unset am_filepart;} { am_mf=; unset am_mf;} { am_rc=; unset am_rc;} rm -f conftest-deps.mk } ;; "libtool":C) # See if we are running on zsh, and set the options that 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 # Generated automatically by $as_me ($PACKAGE) $VERSION # NOTE: Changes made to this file will be lost: look at ltmain.sh. # Provide generalized library-building support services. # Written by Gordon Matzigkeit, 1996 # Copyright (C) 2014 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 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 this program. If not, see . # The names of the tagged configurations supported by this script. available_tags='CXX ' # Configured defaults for sys_lib_dlsearch_path munging. : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} # ### 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 # Shared archive member basename,for filename based shared library versioning on AIX. shared_archive_member_spec=$shared_archive_member_spec # 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 into a list of symbols to manually relocate. global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import # 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 # The name lister interface. nm_interface=$lt_lt_cv_nm_interface # 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 where our libraries should be installed. lt_sysroot=$lt_sysroot # Command to truncate a binary pipe. lt_truncate_bin=$lt_lt_cv_truncate_bin # 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 # Detected run-time system search path for libraries. sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path # Explicit LT_SYS_LIBRARY_PATH set during ./configure time. configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path # 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 cat <<'_LT_EOF' >> "$cfgfile" # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE # func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x$2 in x) ;; *:) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\" ;; x:*) eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\" ;; *::*) eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\" ;; *) eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\" ;; esac } # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in $*""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } # ### END FUNCTIONS SHARED WITH CONFIGURE _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 set != "${COLLECT_NAMES+set}"; 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) 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 openfst-1.7.9/configure.ac000066400000000000000000000140471421600557100155030ustar00rootroot00000000000000AC_INIT([OpenFst], [1.7.9], [help@www.openfst.org]) AM_INIT_AUTOMAKE([foreign nostdinc -Wall -Werror subdir-objects]) AM_PROG_AR AC_PROG_CXX # This library does not throw exceptions, so we do not generate exception # handling code. However, users are free to re-enable exception handling. CXX="$CXX -std=c++11 -fno-exceptions" 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(3.6) AC_PYTHON_DEVEL([>= '3.6']) 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-fsts is an alias to enable FST SO extensions: compact, const, # linear, lookahead, and ngram. AC_ARG_ENABLE([fsts], [AS_HELP_STRING([--enable-fsts], [enable all FST SOs])], [], [enable_fsts=no]) AM_CONDITIONAL([HAVE_FSTS], [test "x$enable_fsts" != xno]) # --enable-grm is an alias to enable all 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) # Flags may be changed after configuring, so this is checked again by # weight_test.cc. The check here is to save time in the common case, # or when someone does not run `make check`. AC_RUN_IFELSE([AC_LANG_PROGRAM([ #include template bool FloatEqIsReflexive(T m) { volatile T x = 1.111; x *= m; T y = 1.111; y *= m; return x == y; } ], [ volatile double test_value = 1.1; if (!FloatEqIsReflexive(static_cast(test_value))) { printf("float FAIL\n"); return 1; } if (!FloatEqIsReflexive(test_value)) { printf("double FAIL\n"); return 1; } ])], [echo "Float equality is good"], [AC_MSG_FAILURE(m4_normalize([ Test float equality failed! Compile with -msse -mfpmath=sse if using g++. ]))]) AC_CHECK_LIB([dl], dlopen, [DL_LIBS=-ldl]) AC_SUBST([DL_LIBS]) AC_OUTPUT openfst-1.7.9/depcomp000077500000000000000000000560201421600557100145670ustar00rootroot00000000000000#! /bin/sh # depcomp - compile a program generating dependencies as side-effects scriptversion=2018-03-07.03; # UTC # Copyright (C) 1999-2018 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 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: openfst-1.7.9/install-sh000077500000000000000000000360101421600557100152130ustar00rootroot00000000000000#!/bin/sh # install - install a program, script, or datafile scriptversion=2018-03-11.20; # 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. tab=' ' nl=' ' IFS=" $tab$nl" # Set DOITPROG to "echo" to test this script. doit=${DOITPROG-} doit_exec=${doit:-exec} # 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_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 is_target_a_directory=possibly 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 *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*) echo "$0: invalid mode: $mode" >&2 exit 1;; esac shift;; -o) chowncmd="$chownprog $2" shift;; -s) stripcmd=$stripprog;; -t) is_target_a_directory=always dst_arg=$2 # Protect names problematic for 'test' and other utilities. case $dst_arg in -* | [=\(\)!]) dst_arg=./$dst_arg;; esac shift;; -T) is_target_a_directory=never;; --version) echo "$0 $scriptversion"; exit $?;; --) shift break;; -*) echo "$0: invalid option: $1" >&2 exit 1;; *) break;; esac shift done # We allow the use of options -d and -T together, by making -d # take the precedence; this is for compatibility with GNU install. if test -n "$dir_arg"; then if test -n "$dst_arg"; then echo "$0: target directory not allowed when installing a directory." >&2 exit 1 fi fi 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 if test $# -gt 1 || test "$is_target_a_directory" = always; then if test ! -d "$dst_arg"; then echo "$0: $dst_arg: Is not a directory." >&2 exit 1 fi fi 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. if test -d "$dst"; then if test "$is_target_a_directory" = never; then echo "$0: $dst_arg: Is a directory" >&2 exit 1 fi dstdir=$dst dstbase=`basename "$src"` case $dst in */) dst=$dst$dstbase;; *) dst=$dst/$dstbase;; esac dstdir_status=0 else dstdir=`dirname "$dst"` test -d "$dstdir" dstdir_status=$? fi fi case $dstdir in */) dstdirslash=$dstdir;; *) dstdirslash=$dstdir/;; esac 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. ;; *) # Note that $RANDOM variable is not portable (e.g. dash); Use it # here however when possible just to lower collision chance. tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0 # Because "mkdir -p" follows existing symlinks and we likely work # directly in world-writeable /tmp, make sure that the '$tmpdir' # directory is successfully created first before we actually test # 'mkdir -p' feature. if (umask $mkdir_umask && $mkdirprog $mkdir_mode "$tmpdir" && exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/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. test_tmpdir="$tmpdir/a" ls_ld_tmpdir=`ls -ld "$test_tmpdir"` case $ls_ld_tmpdir in d????-?r-*) different_mode=700;; d????-?--*) different_mode=755;; *) false;; esac && $mkdirprog -m$different_mode -p -- "$test_tmpdir" && { ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"` test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" } } then posix_mkdir=: fi rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" else # Remove any dirs left behind by ancient mkdir implementations. rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 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 oIFS=$IFS IFS=/ set -f set fnord $dstdir shift 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=${dstdirslash}_inst.$$_ rmtmp=${dstdirslash}_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` && set -f && set X $old && old=:$2:$4:$5:$6 && set X $new && new=:$2:$4:$5:$6 && 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 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: openfst-1.7.9/ltmain.sh000066400000000000000000011771671421600557100150530ustar00rootroot00000000000000#! /bin/sh ## DO NOT EDIT - This file generated from ./build-aux/ltmain.in ## by inline-source v2014-01-03.01 # libtool (GNU libtool) 2.4.6 # Provide generalized library-building support services. # Written by Gordon Matzigkeit , 1996 # Copyright (C) 1996-2015 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 this program. If not, see . PROGRAM=libtool PACKAGE=libtool VERSION="2.4.6 Debian-2.4.6-14" package_revision=2.4.6 ## ------ ## ## Usage. ## ## ------ ## # Run './libtool --help' for help with using this script from the # command line. ## ------------------------------- ## ## User overridable command paths. ## ## ------------------------------- ## # After configure completes, it has a better idea of some of the # shell tools we need than the defaults used by the functions shared # with bootstrap, so set those here where they can still be over- # ridden by the user, but otherwise take precedence. : ${AUTOCONF="autoconf"} : ${AUTOMAKE="automake"} ## -------------------------- ## ## Source external libraries. ## ## -------------------------- ## # Much of our low-level functionality needs to be sourced from external # libraries, which are installed to $pkgauxdir. # Set a version string for this script. scriptversion=2015-01-20.17; # UTC # General shell script boiler plate, and helper functions. # Written by Gary V. Vaughan, 2004 # Copyright (C) 2004-2015 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. # 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 3 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. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNES 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 . # Please report bugs or propose patches to gary@gnu.org. ## ------ ## ## Usage. ## ## ------ ## # Evaluate this file near the top of your script to gain access to # the functions and variables defined here: # # . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh # # If you need to override any of the default environment variable # settings, do that before evaluating this file. ## -------------------- ## ## Shell normalisation. ## ## -------------------- ## # Some shells need a little help to be as Bourne compatible as possible. # Before doing anything else, make sure all that help has been provided! 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 # NLS nuisances: We save the old values in case they are required later. _G_user_locale= _G_safe_locale= for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES do eval "if test set = \"\${$_G_var+set}\"; then save_$_G_var=\$$_G_var $_G_var=C export $_G_var _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\" _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\" fi" done # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Make sure IFS has a sensible default sp=' ' nl=' ' IFS="$sp $nl" # There are apparently some retarded systems that use ';' as a PATH separator! 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 ## ------------------------- ## ## Locate command utilities. ## ## ------------------------- ## # func_executable_p FILE # ---------------------- # Check that FILE is an executable regular file. func_executable_p () { test -f "$1" && test -x "$1" } # func_path_progs PROGS_LIST CHECK_FUNC [PATH] # -------------------------------------------- # Search for either a program that responds to --version with output # containing "GNU", or else returned by CHECK_FUNC otherwise, by # trying all the directories in PATH with each of the elements of # PROGS_LIST. # # CHECK_FUNC should accept the path to a candidate program, and # set $func_check_prog_result if it truncates its output less than # $_G_path_prog_max characters. func_path_progs () { _G_progs_list=$1 _G_check_func=$2 _G_PATH=${3-"$PATH"} _G_path_prog_max=0 _G_path_prog_found=false _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:} for _G_dir in $_G_PATH; do IFS=$_G_save_IFS test -z "$_G_dir" && _G_dir=. for _G_prog_name in $_G_progs_list; do for _exeext in '' .EXE; do _G_path_prog=$_G_dir/$_G_prog_name$_exeext func_executable_p "$_G_path_prog" || continue case `"$_G_path_prog" --version 2>&1` in *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;; *) $_G_check_func $_G_path_prog func_path_progs_result=$func_check_prog_result ;; esac $_G_path_prog_found && break 3 done done done IFS=$_G_save_IFS test -z "$func_path_progs_result" && { echo "no acceptable sed could be found in \$PATH" >&2 exit 1 } } # We want to be able to use the functions in this file before configure # has figured out where the best binaries are kept, which means we have # to search for them ourselves - except when the results are already set # where we skip the searches. # Unless the user overrides by setting SED, search the path for either GNU # sed, or the sed that truncates its output the least. test -z "$SED" && { _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ for _G_i in 1 2 3 4 5 6 7; do _G_sed_script=$_G_sed_script$nl$_G_sed_script done echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed _G_sed_script= func_check_prog_sed () { _G_path_prog=$1 _G_count=0 printf 0123456789 >conftest.in while : do cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo '' >> conftest.nl "$_G_path_prog" -f conftest.sed conftest.out 2>/dev/null || break diff conftest.out conftest.nl >/dev/null 2>&1 || break _G_count=`expr $_G_count + 1` if test "$_G_count" -gt "$_G_path_prog_max"; then # Best one so far, save it but keep looking for a better one func_check_prog_result=$_G_path_prog _G_path_prog_max=$_G_count fi # 10*(2^10) chars as input seems more than enough test 10 -lt "$_G_count" && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out } func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin rm -f conftest.sed SED=$func_path_progs_result } # Unless the user overrides by setting GREP, search the path for either GNU # grep, or the grep that truncates its output the least. test -z "$GREP" && { func_check_prog_grep () { _G_path_prog=$1 _G_count=0 _G_path_prog_max=0 printf 0123456789 >conftest.in while : do cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo 'GREP' >> conftest.nl "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' conftest.out 2>/dev/null || break diff conftest.out conftest.nl >/dev/null 2>&1 || break _G_count=`expr $_G_count + 1` if test "$_G_count" -gt "$_G_path_prog_max"; then # Best one so far, save it but keep looking for a better one func_check_prog_result=$_G_path_prog _G_path_prog_max=$_G_count fi # 10*(2^10) chars as input seems more than enough test 10 -lt "$_G_count" && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out } func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin GREP=$func_path_progs_result } ## ------------------------------- ## ## User overridable command paths. ## ## ------------------------------- ## # All uppercase variable names are used for environment variables. These # variables can be overridden by the user before calling a script that # uses them if a suitable command of that name is not already available # in the command search PATH. : ${CP="cp -f"} : ${ECHO="printf %s\n"} : ${EGREP="$GREP -E"} : ${FGREP="$GREP -F"} : ${LN_S="ln -s"} : ${MAKE="make"} : ${MKDIR="mkdir"} : ${MV="mv -f"} : ${RM="rm -f"} : ${SHELL="${CONFIG_SHELL-/bin/sh}"} ## -------------------- ## ## Useful sed snippets. ## ## -------------------- ## sed_dirname='s|/[^/]*$||' sed_basename='s|^.*/||' # Sed substitution that helps us do robust quoting. It backslashifies # metacharacters that are still active within double-quoted strings. sed_quote_subst='s|\([`"$\\]\)|\\\1|g' # Same as above, but do not quote variable references. sed_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 # that contains forward slashes, into one that contains # (escaped) backslashes. A very naive implementation. sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' # Re-'\' parameter expansions in output of sed_double_quote_subst that # were '\'-ed in input to the same. If an odd number of '\' preceded a # '$' in input to sed_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 '$'. _G_bs='\\' _G_bs2='\\\\' _G_bs4='\\\\\\\\' _G_dollar='\$' sed_double_backslash="\ s/$_G_bs4/&\\ /g s/^$_G_bs2$_G_dollar/$_G_bs&/ s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g s/\n//g" ## ----------------- ## ## Global variables. ## ## ----------------- ## # Except for the global variables explicitly listed below, the following # functions in the '^func_' namespace, and the '^require_' namespace # variables initialised in the 'Resource management' section, sourcing # this file will not pollute your global namespace with anything # else. There's no portable way to scope variables in Bourne shell # though, so actually running these functions will sometimes place # results into a variable named after the function, and often use # temporary variables in the '^_G_' namespace. If you are careful to # avoid using those namespaces casually in your sourcing script, things # should continue to work as you expect. And, of course, you can freely # overwrite any of the functions or variables defined here before # calling anything to customize them. 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. # Allow overriding, eg assuming that you follow the convention of # putting '$debug_cmd' at the start of all your functions, you can get # bash to show function call trace with: # # debug_cmd='echo "${FUNCNAME[0]} $*" >&2' bash your-script-name debug_cmd=${debug_cmd-":"} exit_cmd=: # By convention, finish your script with: # # exit $exit_status # # so that you can set exit_status to non-zero if you want to indicate # something went wrong during execution without actually bailing out at # the point of failure. exit_status=$EXIT_SUCCESS # 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 # The name of this program. progname=`$ECHO "$progpath" |$SED "$sed_basename"` # Make sure we have an absolute progpath for reexecution: case $progpath in [\\/]*|[A-Za-z]:\\*) ;; *[\\/]*) progdir=`$ECHO "$progpath" |$SED "$sed_dirname"` progdir=`cd "$progdir" && pwd` progpath=$progdir/$progname ;; *) _G_IFS=$IFS IFS=${PATH_SEPARATOR-:} for progdir in $PATH; do IFS=$_G_IFS test -x "$progdir/$progname" && break done IFS=$_G_IFS test -n "$progdir" || progdir=`pwd` progpath=$progdir/$progname ;; esac ## ----------------- ## ## Standard options. ## ## ----------------- ## # The following options affect the operation of the functions defined # below, and should be set appropriately depending on run-time para- # meters passed on the command line. opt_dry_run=false opt_quiet=false opt_verbose=false # Categories 'all' and 'none' are always available. Append any others # you will pass as the first argument to func_warning from your own # code. warning_categories= # By default, display warnings according to 'opt_warning_types'. Set # 'warning_func' to ':' to elide all warnings, or func_fatal_error to # treat the next displayed warning as a fatal error. warning_func=func_warn_and_continue # Set to 'all' to display all warnings, 'none' to suppress all # warnings, or a space delimited list of some subset of # 'warning_categories' to display only the listed warnings. opt_warning_types=all ## -------------------- ## ## Resource management. ## ## -------------------- ## # This section contains definitions for functions that each ensure a # particular resource (a file, or a non-empty configuration variable for # example) is available, and if appropriate to extract default values # from pertinent package files. Call them using their associated # 'require_*' variable to ensure that they are executed, at most, once. # # It's entirely deliberate that calling these functions can set # variables that don't obey the namespace limitations obeyed by the rest # of this file, in order that that they be as useful as possible to # callers. # require_term_colors # ------------------- # Allow display of bold text on terminals that support it. require_term_colors=func_require_term_colors func_require_term_colors () { $debug_cmd test -t 1 && { # COLORTERM and USE_ANSI_COLORS environment variables take # precedence, because most terminfo databases neglect to describe # whether color sequences are supported. test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"} if test 1 = "$USE_ANSI_COLORS"; then # Standard ANSI escape sequences tc_reset='' tc_bold=''; tc_standout='' tc_red=''; tc_green='' tc_blue=''; tc_cyan='' else # Otherwise trust the terminfo database after all. test -n "`tput sgr0 2>/dev/null`" && { tc_reset=`tput sgr0` test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold` tc_standout=$tc_bold test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso` test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1` test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2` test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4` test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5` } fi } require_term_colors=: } ## ----------------- ## ## Function library. ## ## ----------------- ## # This section contains a variety of useful functions to call in your # scripts. Take note of the portable wrappers for features provided by # some modern shells, which will fall back to slower equivalents on # less featureful shells. # func_append VAR VALUE # --------------------- # Append VALUE onto the existing contents of VAR. # We should try to minimise forks, especially on Windows where they are # unreasonably slow, so skip the feature probes when bash or zsh are # being used: if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then : ${_G_HAVE_ARITH_OP="yes"} : ${_G_HAVE_XSI_OPS="yes"} # The += operator was introduced in bash 3.1 case $BASH_VERSION in [12].* | 3.0 | 3.0*) ;; *) : ${_G_HAVE_PLUSEQ_OP="yes"} ;; esac fi # _G_HAVE_PLUSEQ_OP # Can be empty, in which case the shell is probed, "yes" if += is # useable or anything else if it does not work. test -z "$_G_HAVE_PLUSEQ_OP" \ && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \ && _G_HAVE_PLUSEQ_OP=yes if test yes = "$_G_HAVE_PLUSEQ_OP" then # This is an XSI compatible shell, allowing a faster implementation... eval 'func_append () { $debug_cmd eval "$1+=\$2" }' else # ...otherwise fall back to using expr, which is often a shell builtin. func_append () { $debug_cmd eval "$1=\$$1\$2" } fi # func_append_quoted VAR VALUE # ---------------------------- # Quote VALUE and append to the end of shell variable VAR, separated # by a space. if test yes = "$_G_HAVE_PLUSEQ_OP"; then eval 'func_append_quoted () { $debug_cmd func_quote_for_eval "$2" eval "$1+=\\ \$func_quote_for_eval_result" }' else func_append_quoted () { $debug_cmd func_quote_for_eval "$2" eval "$1=\$$1\\ \$func_quote_for_eval_result" } fi # func_append_uniq VAR VALUE # -------------------------- # Append unique VALUE onto the existing contents of VAR, assuming # entries are delimited by the first character of VALUE. For example: # # func_append_uniq options " --another-option option-argument" # # will only append to $options if " --another-option option-argument " # is not already present somewhere in $options already (note spaces at # each end implied by leading space in second argument). func_append_uniq () { $debug_cmd eval _G_current_value='`$ECHO $'$1'`' _G_delim=`expr "$2" : '\(.\)'` case $_G_delim$_G_current_value$_G_delim in *"$2$_G_delim"*) ;; *) func_append "$@" ;; esac } # func_arith TERM... # ------------------ # Set func_arith_result to the result of evaluating TERMs. test -z "$_G_HAVE_ARITH_OP" \ && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \ && _G_HAVE_ARITH_OP=yes if test yes = "$_G_HAVE_ARITH_OP"; then eval 'func_arith () { $debug_cmd func_arith_result=$(( $* )) }' else func_arith () { $debug_cmd func_arith_result=`expr "$@"` } fi # func_basename FILE # ------------------ # Set func_basename_result to FILE with everything up to and including # the last / stripped. if test yes = "$_G_HAVE_XSI_OPS"; then # If this shell supports suffix pattern removal, then use it to avoid # forking. Hide the definitions single quotes in case the shell chokes # on unsupported syntax... _b='func_basename_result=${1##*/}' _d='case $1 in */*) func_dirname_result=${1%/*}$2 ;; * ) func_dirname_result=$3 ;; esac' else # ...otherwise fall back to using sed. _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`' _d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"` if test "X$func_dirname_result" = "X$1"; then func_dirname_result=$3 else func_append func_dirname_result "$2" fi' fi eval 'func_basename () { $debug_cmd '"$_b"' }' # func_dirname FILE APPEND NONDIR_REPLACEMENT # ------------------------------------------- # Compute the dirname of FILE. If nonempty, add APPEND to the result, # otherwise set result to NONDIR_REPLACEMENT. eval 'func_dirname () { $debug_cmd '"$_d"' }' # 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" # For efficiency, we do not delegate to the functions above but instead # duplicate the functionality here. eval 'func_dirname_and_basename () { $debug_cmd '"$_b"' '"$_d"' }' # func_echo ARG... # ---------------- # Echo program name prefixed message. func_echo () { $debug_cmd _G_message=$* func_echo_IFS=$IFS IFS=$nl for _G_line in $_G_message; do IFS=$func_echo_IFS $ECHO "$progname: $_G_line" done IFS=$func_echo_IFS } # func_echo_all ARG... # -------------------- # Invoke $ECHO with all args, space-separated. func_echo_all () { $ECHO "$*" } # func_echo_infix_1 INFIX ARG... # ------------------------------ # Echo program name, followed by INFIX on the first line, with any # additional lines not showing INFIX. func_echo_infix_1 () { $debug_cmd $require_term_colors _G_infix=$1; shift _G_indent=$_G_infix _G_prefix="$progname: $_G_infix: " _G_message=$* # Strip color escape sequences before counting printable length for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan" do test -n "$_G_tc" && { _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"` _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"` } done _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes func_echo_infix_1_IFS=$IFS IFS=$nl for _G_line in $_G_message; do IFS=$func_echo_infix_1_IFS $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2 _G_prefix=$_G_indent done IFS=$func_echo_infix_1_IFS } # func_error ARG... # ----------------- # Echo program name prefixed message to standard error. func_error () { $debug_cmd $require_term_colors func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2 } # func_fatal_error ARG... # ----------------------- # Echo program name prefixed message to standard error, and exit. func_fatal_error () { $debug_cmd func_error "$*" exit $EXIT_FAILURE } # func_grep EXPRESSION FILENAME # ----------------------------- # Check whether EXPRESSION matches any line of FILENAME, without output. func_grep () { $debug_cmd $GREP "$1" "$2" >/dev/null 2>&1 } # func_len STRING # --------------- # Set func_len_result to the length of STRING. STRING may not # start with a hyphen. test -z "$_G_HAVE_XSI_OPS" \ && (eval 'x=a/b/c; test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ && _G_HAVE_XSI_OPS=yes if test yes = "$_G_HAVE_XSI_OPS"; then eval 'func_len () { $debug_cmd func_len_result=${#1} }' else func_len () { $debug_cmd func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len` } fi # func_mkdir_p DIRECTORY-PATH # --------------------------- # Make sure the entire path to DIRECTORY-PATH is available. func_mkdir_p () { $debug_cmd _G_directory_path=$1 _G_dir_list= if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then # Protect directory names starting with '-' case $_G_directory_path in -*) _G_directory_path=./$_G_directory_path ;; esac # While some portion of DIR does not yet exist... while test ! -d "$_G_directory_path"; do # ...make a list in topmost first order. Use a colon delimited # list incase some portion of path contains whitespace. _G_dir_list=$_G_directory_path:$_G_dir_list # If the last portion added has no slash in it, the list is done case $_G_directory_path in */*) ;; *) break ;; esac # ...otherwise throw away the child directory and loop _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"` done _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'` func_mkdir_p_IFS=$IFS; IFS=: for _G_dir in $_G_dir_list; do IFS=$func_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 "$_G_dir" 2>/dev/null || : done IFS=$func_mkdir_p_IFS # Bail out if we (or some other process) failed to create a directory. test -d "$_G_directory_path" || \ func_fatal_error "Failed to create '$1'" fi } # func_mktempdir [BASENAME] # ------------------------- # Make a temporary directory that won't clash with other running # libtool processes, and avoids race conditions if possible. If # given, BASENAME is the basename for that directory. func_mktempdir () { $debug_cmd _G_template=${TMPDIR-/tmp}/${1-$progname} if test : = "$opt_dry_run"; then # Return a directory name, but don't create it in dry-run mode _G_tmpdir=$_G_template-$$ else # If mktemp works, use that first and foremost _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null` if test ! -d "$_G_tmpdir"; then # Failing that, at least try and use $RANDOM to avoid a race _G_tmpdir=$_G_template-${RANDOM-0}$$ func_mktempdir_umask=`umask` umask 0077 $MKDIR "$_G_tmpdir" umask $func_mktempdir_umask fi # If we're not in dry-run mode, bomb out on failure test -d "$_G_tmpdir" || \ func_fatal_error "cannot create temporary directory '$_G_tmpdir'" fi $ECHO "$_G_tmpdir" } # 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. func_normal_abspath () { $debug_cmd # These SED scripts presuppose an absolute path with a trailing slash. _G_pathcar='s|^/\([^/]*\).*$|\1|' _G_pathcdr='s|^/[^/]*||' _G_removedotparts=':dotsl s|/\./|/|g t dotsl s|/\.$|/|' _G_collapseslashes='s|/\{1,\}|/|g' _G_finalslash='s|/*$|/|' # 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 "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_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 "$_G_pathcar"` func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ -e "$_G_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_append 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_notquiet ARG... # -------------------- # Echo program name prefixed message only when not in quiet mode. func_notquiet () { $debug_cmd $opt_quiet || 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_relative_path SRCDIR DSTDIR # -------------------------------- # Set func_relative_path_result to the relative path from SRCDIR to DSTDIR. func_relative_path () { $debug_cmd 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 -z "$func_relative_path_tlibdir"; 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 -n "$func_stripname_result"; then func_append func_relative_path_result "/$func_stripname_result" fi # Normalisation. If bindir is libdir, return '.' else relative path. if test -n "$func_relative_path_result"; then func_stripname './' '' "$func_relative_path_result" func_relative_path_result=$func_stripname_result fi test -n "$func_relative_path_result" || func_relative_path_result=. : } # func_quote_for_eval ARG... # -------------------------- # Aesthetically quote ARGs to be evaled later. # This function returns two values: # i) func_quote_for_eval_result # double-quoted, suitable for a subsequent eval # ii) func_quote_for_eval_unquoted_result # has all characters that are still active within double # quotes backslashified. func_quote_for_eval () { $debug_cmd func_quote_for_eval_unquoted_result= func_quote_for_eval_result= while test 0 -lt $#; do case $1 in *[\\\`\"\$]*) _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;; *) _G_unquoted_arg=$1 ;; esac if test -n "$func_quote_for_eval_unquoted_result"; then func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg" else func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg" fi case $_G_unquoted_arg in # Double-quote args containing shell metacharacters to delay # word splitting, command substitution and variable expansion # for a subsequent eval. # Many Bourne shells cannot handle close brackets correctly # in scan sets, so we specify it separately. *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") _G_quoted_arg=\"$_G_unquoted_arg\" ;; *) _G_quoted_arg=$_G_unquoted_arg ;; esac if test -n "$func_quote_for_eval_result"; then func_append func_quote_for_eval_result " $_G_quoted_arg" else func_append func_quote_for_eval_result "$_G_quoted_arg" fi shift done } # 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 () { $debug_cmd case $1 in *[\\\`\"]*) _G_arg=`$ECHO "$1" | $SED \ -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;; *) _G_arg=$1 ;; esac case $_G_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. *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") _G_arg=\"$_G_arg\" ;; esac func_quote_for_expand_result=$_G_arg } # func_stripname PREFIX SUFFIX NAME # --------------------------------- # strip PREFIX and SUFFIX from NAME, and store in func_stripname_result. # 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). if test yes = "$_G_HAVE_XSI_OPS"; then eval 'func_stripname () { $debug_cmd # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are # positional parameters, so assign one to ordinary variable first. func_stripname_result=$3 func_stripname_result=${func_stripname_result#"$1"} func_stripname_result=${func_stripname_result%"$2"} }' else func_stripname () { $debug_cmd case $2 in .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;; *) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;; esac } fi # func_show_eval CMD [FAIL_EXP] # ----------------------------- # Unless opt_quiet 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 () { $debug_cmd _G_cmd=$1 _G_fail_exp=${2-':'} func_quote_for_expand "$_G_cmd" eval "func_notquiet $func_quote_for_expand_result" $opt_dry_run || { eval "$_G_cmd" _G_status=$? if test 0 -ne "$_G_status"; then eval "(exit $_G_status); $_G_fail_exp" fi } } # func_show_eval_locale CMD [FAIL_EXP] # ------------------------------------ # Unless opt_quiet 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 () { $debug_cmd _G_cmd=$1 _G_fail_exp=${2-':'} $opt_quiet || { func_quote_for_expand "$_G_cmd" eval "func_echo $func_quote_for_expand_result" } $opt_dry_run || { eval "$_G_user_locale $_G_cmd" _G_status=$? eval "$_G_safe_locale" if test 0 -ne "$_G_status"; then eval "(exit $_G_status); $_G_fail_exp" 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 () { $debug_cmd case $1 in [0-9]* | *[!a-zA-Z0-9_]*) func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'` ;; * ) func_tr_sh_result=$1 ;; esac } # func_verbose ARG... # ------------------- # Echo program name prefixed message in verbose mode only. func_verbose () { $debug_cmd $opt_verbose && func_echo "$*" : } # func_warn_and_continue ARG... # ----------------------------- # Echo program name prefixed warning message to standard error. func_warn_and_continue () { $debug_cmd $require_term_colors func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2 } # func_warning CATEGORY ARG... # ---------------------------- # Echo program name prefixed warning message to standard error. Warning # messages can be filtered according to CATEGORY, where this function # elides messages where CATEGORY is not listed in the global variable # 'opt_warning_types'. func_warning () { $debug_cmd # CATEGORY must be in the warning_categories list! case " $warning_categories " in *" $1 "*) ;; *) func_internal_error "invalid warning category '$1'" ;; esac _G_category=$1 shift case " $opt_warning_types " in *" $_G_category "*) $warning_func ${1+"$@"} ;; esac } # func_sort_ver VER1 VER2 # ----------------------- # 'sort -V' is not generally available. # Note this deviates from the version comparison in automake # in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a # but this should suffice as we won't be specifying old # version formats or redundant trailing .0 in bootstrap.conf. # If we did want full compatibility then we should probably # use m4_version_compare from autoconf. func_sort_ver () { $debug_cmd printf '%s\n%s\n' "$1" "$2" \ | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n } # func_lt_ver PREV CURR # --------------------- # Return true if PREV and CURR are in the correct order according to # func_sort_ver, otherwise false. Use it like this: # # func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..." func_lt_ver () { $debug_cmd test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q` } # Local variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" # time-stamp-time-zone: "UTC" # End: #! /bin/sh # Set a version string for this script. scriptversion=2015-10-07.11; # UTC # A portable, pluggable option parser for Bourne shell. # Written by Gary V. Vaughan, 2010 # Copyright (C) 2010-2015 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. # 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 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 . # Please report bugs or propose patches to gary@gnu.org. ## ------ ## ## Usage. ## ## ------ ## # This file is a library for parsing options in your shell scripts along # with assorted other useful supporting features that you can make use # of too. # # For the simplest scripts you might need only: # # #!/bin/sh # . relative/path/to/funclib.sh # . relative/path/to/options-parser # scriptversion=1.0 # func_options ${1+"$@"} # eval set dummy "$func_options_result"; shift # ...rest of your script... # # In order for the '--version' option to work, you will need to have a # suitably formatted comment like the one at the top of this file # starting with '# Written by ' and ending with '# warranty; '. # # For '-h' and '--help' to work, you will also need a one line # description of your script's purpose in a comment directly above the # '# Written by ' line, like the one at the top of this file. # # The default options also support '--debug', which will turn on shell # execution tracing (see the comment above debug_cmd below for another # use), and '--verbose' and the func_verbose function to allow your script # to display verbose messages only when your user has specified # '--verbose'. # # After sourcing this file, you can plug processing for additional # options by amending the variables from the 'Configuration' section # below, and following the instructions in the 'Option parsing' # section further down. ## -------------- ## ## Configuration. ## ## -------------- ## # You should override these variables in your script after sourcing this # file so that they reflect the customisations you have added to the # option parser. # The usage line for option parsing errors and the start of '-h' and # '--help' output messages. You can embed shell variables for delayed # expansion at the time the message is displayed, but you will need to # quote other shell meta-characters carefully to prevent them being # expanded when the contents are evaled. usage='$progpath [OPTION]...' # Short help message in response to '-h' and '--help'. Add to this or # override it after sourcing this library to reflect the full set of # options your script accepts. usage_message="\ --debug enable verbose shell tracing -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all] -v, --verbose verbosely report processing --version print version information and exit -h, --help print short or long help message and exit " # Additional text appended to 'usage_message' in response to '--help'. long_help_message=" Warning categories include: 'all' show all warnings 'none' turn off all the warnings 'error' warnings are treated as fatal errors" # Help message printed before fatal option parsing errors. fatal_help="Try '\$progname --help' for more information." ## ------------------------- ## ## Hook function management. ## ## ------------------------- ## # This section contains functions for adding, removing, and running hooks # to the main code. A hook is just a named list of of function, that can # be run in order later on. # func_hookable FUNC_NAME # ----------------------- # Declare that FUNC_NAME will run hooks added with # 'func_add_hook FUNC_NAME ...'. func_hookable () { $debug_cmd func_append hookable_fns " $1" } # func_add_hook FUNC_NAME HOOK_FUNC # --------------------------------- # Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must # first have been declared "hookable" by a call to 'func_hookable'. func_add_hook () { $debug_cmd case " $hookable_fns " in *" $1 "*) ;; *) func_fatal_error "'$1' does not accept hook functions." ;; esac eval func_append ${1}_hooks '" $2"' } # func_remove_hook FUNC_NAME HOOK_FUNC # ------------------------------------ # Remove HOOK_FUNC from the list of functions called by FUNC_NAME. func_remove_hook () { $debug_cmd eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`' } # func_run_hooks FUNC_NAME [ARG]... # --------------------------------- # Run all hook functions registered to FUNC_NAME. # It is assumed that the list of hook functions contains nothing more # than a whitespace-delimited list of legal shell function names, and # no effort is wasted trying to catch shell meta-characters or preserve # whitespace. func_run_hooks () { $debug_cmd _G_rc_run_hooks=false case " $hookable_fns " in *" $1 "*) ;; *) func_fatal_error "'$1' does not support hook funcions.n" ;; esac eval _G_hook_fns=\$$1_hooks; shift for _G_hook in $_G_hook_fns; do if eval $_G_hook '"$@"'; then # store returned options list back into positional # parameters for next 'cmd' execution. eval _G_hook_result=\$${_G_hook}_result eval set dummy "$_G_hook_result"; shift _G_rc_run_hooks=: fi done $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result } ## --------------- ## ## Option parsing. ## ## --------------- ## # In order to add your own option parsing hooks, you must accept the # full positional parameter list in your hook function, you may remove/edit # any options that you action, and then pass back the remaining unprocessed # options in '_result', escaped suitably for # 'eval'. In this case you also must return $EXIT_SUCCESS to let the # hook's caller know that it should pay attention to # '_result'. Returning $EXIT_FAILURE signalizes that # arguments are left untouched by the hook and therefore caller will ignore the # result variable. # # Like this: # # my_options_prep () # { # $debug_cmd # # # Extend the existing usage message. # usage_message=$usage_message' # -s, --silent don'\''t print informational messages # ' # # No change in '$@' (ignored completely by this hook). There is # # no need to do the equivalent (but slower) action: # # func_quote_for_eval ${1+"$@"} # # my_options_prep_result=$func_quote_for_eval_result # false # } # func_add_hook func_options_prep my_options_prep # # # my_silent_option () # { # $debug_cmd # # args_changed=false # # # Note that for efficiency, we parse as many options as we can # # recognise in a loop before passing the remainder back to the # # caller on the first unrecognised argument we encounter. # while test $# -gt 0; do # opt=$1; shift # case $opt in # --silent|-s) opt_silent=: # args_changed=: # ;; # # Separate non-argument short options: # -s*) func_split_short_opt "$_G_opt" # set dummy "$func_split_short_opt_name" \ # "-$func_split_short_opt_arg" ${1+"$@"} # shift # args_changed=: # ;; # *) # Make sure the first unrecognised option "$_G_opt" # # is added back to "$@", we could need that later # # if $args_changed is true. # set dummy "$_G_opt" ${1+"$@"}; shift; break ;; # esac # done # # if $args_changed; then # func_quote_for_eval ${1+"$@"} # my_silent_option_result=$func_quote_for_eval_result # fi # # $args_changed # } # func_add_hook func_parse_options my_silent_option # # # my_option_validation () # { # $debug_cmd # # $opt_silent && $opt_verbose && func_fatal_help "\ # '--silent' and '--verbose' options are mutually exclusive." # # false # } # func_add_hook func_validate_options my_option_validation # # You'll also need to manually amend $usage_message to reflect the extra # options you parse. It's preferable to append if you can, so that # multiple option parsing hooks can be added safely. # func_options_finish [ARG]... # ---------------------------- # Finishing the option parse loop (call 'func_options' hooks ATM). func_options_finish () { $debug_cmd _G_func_options_finish_exit=false if func_run_hooks func_options ${1+"$@"}; then func_options_finish_result=$func_run_hooks_result _G_func_options_finish_exit=: fi $_G_func_options_finish_exit } # func_options [ARG]... # --------------------- # All the functions called inside func_options are hookable. See the # individual implementations for details. func_hookable func_options func_options () { $debug_cmd _G_rc_options=false for my_func in options_prep parse_options validate_options options_finish do if eval func_$my_func '${1+"$@"}'; then eval _G_res_var='$'"func_${my_func}_result" eval set dummy "$_G_res_var" ; shift _G_rc_options=: fi done # Save modified positional parameters for caller. As a top-level # options-parser function we always need to set the 'func_options_result' # variable (regardless the $_G_rc_options value). if $_G_rc_options; then func_options_result=$_G_res_var else func_quote_for_eval ${1+"$@"} func_options_result=$func_quote_for_eval_result fi $_G_rc_options } # func_options_prep [ARG]... # -------------------------- # All initialisations required before starting the option parse loop. # Note that when calling hook functions, we pass through the list of # positional parameters. If a hook function modifies that list, and # needs to propagate that back to rest of this script, then the complete # modified list must be put in 'func_run_hooks_result' before # returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned). func_hookable func_options_prep func_options_prep () { $debug_cmd # Option defaults: opt_verbose=false opt_warning_types= _G_rc_options_prep=false if func_run_hooks func_options_prep ${1+"$@"}; then _G_rc_options_prep=: # save modified positional parameters for caller func_options_prep_result=$func_run_hooks_result fi $_G_rc_options_prep } # func_parse_options [ARG]... # --------------------------- # The main option parsing loop. func_hookable func_parse_options func_parse_options () { $debug_cmd func_parse_options_result= _G_rc_parse_options=false # this just eases exit handling while test $# -gt 0; do # Defer to hook functions for initial option parsing, so they # get priority in the event of reusing an option name. if func_run_hooks func_parse_options ${1+"$@"}; then eval set dummy "$func_run_hooks_result"; shift _G_rc_parse_options=: fi # Break out of the loop if we already parsed every option. test $# -gt 0 || break _G_match_parse_options=: _G_opt=$1 shift case $_G_opt in --debug|-x) debug_cmd='set -x' func_echo "enabling shell trace mode" $debug_cmd ;; --no-warnings|--no-warning|--no-warn) set dummy --warnings none ${1+"$@"} shift ;; --warnings|--warning|-W) if test $# = 0 && func_missing_arg $_G_opt; then _G_rc_parse_options=: break fi case " $warning_categories $1" in *" $1 "*) # trailing space prevents matching last $1 above func_append_uniq opt_warning_types " $1" ;; *all) opt_warning_types=$warning_categories ;; *none) opt_warning_types=none warning_func=: ;; *error) opt_warning_types=$warning_categories warning_func=func_fatal_error ;; *) func_fatal_error \ "unsupported warning category: '$1'" ;; esac shift ;; --verbose|-v) opt_verbose=: ;; --version) func_version ;; -\?|-h) func_usage ;; --help) func_help ;; # Separate optargs to long options (plugins may need this): --*=*) func_split_equals "$_G_opt" set dummy "$func_split_equals_lhs" \ "$func_split_equals_rhs" ${1+"$@"} shift ;; # Separate optargs to short options: -W*) func_split_short_opt "$_G_opt" set dummy "$func_split_short_opt_name" \ "$func_split_short_opt_arg" ${1+"$@"} shift ;; # Separate non-argument short options: -\?*|-h*|-v*|-x*) func_split_short_opt "$_G_opt" set dummy "$func_split_short_opt_name" \ "-$func_split_short_opt_arg" ${1+"$@"} shift ;; --) _G_rc_parse_options=: ; break ;; -*) func_fatal_help "unrecognised option: '$_G_opt'" ;; *) set dummy "$_G_opt" ${1+"$@"}; shift _G_match_parse_options=false break ;; esac $_G_match_parse_options && _G_rc_parse_options=: done if $_G_rc_parse_options; then # save modified positional parameters for caller func_quote_for_eval ${1+"$@"} func_parse_options_result=$func_quote_for_eval_result fi $_G_rc_parse_options } # func_validate_options [ARG]... # ------------------------------ # Perform any sanity checks on option settings and/or unconsumed # arguments. func_hookable func_validate_options func_validate_options () { $debug_cmd _G_rc_validate_options=false # Display all warnings if -W was not given. test -n "$opt_warning_types" || opt_warning_types=" $warning_categories" if func_run_hooks func_validate_options ${1+"$@"}; then # save modified positional parameters for caller func_validate_options_result=$func_run_hooks_result _G_rc_validate_options=: fi # Bail if the options were screwed! $exit_cmd $EXIT_FAILURE $_G_rc_validate_options } ## ----------------- ## ## Helper functions. ## ## ----------------- ## # This section contains the helper functions used by the rest of the # hookable option parser framework in ascii-betical order. # func_fatal_help ARG... # ---------------------- # Echo program name prefixed message to standard error, followed by # a help hint, and exit. func_fatal_help () { $debug_cmd eval \$ECHO \""Usage: $usage"\" eval \$ECHO \""$fatal_help"\" func_error ${1+"$@"} exit $EXIT_FAILURE } # func_help # --------- # Echo long help message to standard output and exit. func_help () { $debug_cmd func_usage_message $ECHO "$long_help_message" exit 0 } # func_missing_arg ARGNAME # ------------------------ # Echo program name prefixed message to standard error and set global # exit_cmd. func_missing_arg () { $debug_cmd func_error "Missing argument for '$1'." exit_cmd=exit } # func_split_equals STRING # ------------------------ # Set func_split_equals_lhs and func_split_equals_rhs shell variables after # splitting STRING at the '=' sign. test -z "$_G_HAVE_XSI_OPS" \ && (eval 'x=a/b/c; test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ && _G_HAVE_XSI_OPS=yes if test yes = "$_G_HAVE_XSI_OPS" then # This is an XSI compatible shell, allowing a faster implementation... eval 'func_split_equals () { $debug_cmd func_split_equals_lhs=${1%%=*} func_split_equals_rhs=${1#*=} test "x$func_split_equals_lhs" = "x$1" \ && func_split_equals_rhs= }' else # ...otherwise fall back to using expr, which is often a shell builtin. func_split_equals () { $debug_cmd func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'` func_split_equals_rhs= test "x$func_split_equals_lhs" = "x$1" \ || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'` } fi #func_split_equals # 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. if test yes = "$_G_HAVE_XSI_OPS" then # This is an XSI compatible shell, allowing a faster implementation... eval 'func_split_short_opt () { $debug_cmd func_split_short_opt_arg=${1#??} func_split_short_opt_name=${1%"$func_split_short_opt_arg"} }' else # ...otherwise fall back to using expr, which is often a shell builtin. func_split_short_opt () { $debug_cmd func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'` func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'` } fi #func_split_short_opt # func_usage # ---------- # Echo short help message to standard output and exit. func_usage () { $debug_cmd func_usage_message $ECHO "Run '$progname --help |${PAGER-more}' for full usage" exit 0 } # func_usage_message # ------------------ # Echo short help message to standard output. func_usage_message () { $debug_cmd eval \$ECHO \""Usage: $usage"\" echo $SED -n 's|^# || /^Written by/{ x;p;x } h /^Written by/q' < "$progpath" echo eval \$ECHO \""$usage_message"\" } # func_version # ------------ # Echo version message to standard output and exit. func_version () { $debug_cmd printf '%s\n' "$progname $scriptversion" $SED -n ' /(C)/!b go :more /\./!{ N s|\n# | | b more } :go /^# Written by /,/# warranty; / { s|^# || s|^# *$|| s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2| p } /^# Written by / { s|^# || p } /^warranty; /q' < "$progpath" exit $? } # Local variables: # mode: shell-script # sh-indentation: 2 # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" # time-stamp-time-zone: "UTC" # End: # Set a version string. scriptversion='(GNU libtool) 2.4.6' # func_echo ARG... # ---------------- # Libtool also displays the current mode in messages, so override # funclib.sh func_echo with this custom definition. func_echo () { $debug_cmd _G_message=$* func_echo_IFS=$IFS IFS=$nl for _G_line in $_G_message; do IFS=$func_echo_IFS $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line" done IFS=$func_echo_IFS } # func_warning ARG... # ------------------- # Libtool warnings are not categorized, so override funclib.sh # func_warning with this simpler definition. func_warning () { $debug_cmd $warning_func ${1+"$@"} } ## ---------------- ## ## Options parsing. ## ## ---------------- ## # Hook in the functions to make sure our own options are parsed during # the option parsing loop. usage='$progpath [OPTION]... [MODE-ARG]...' # Short help message in response to '-h'. usage_message="Options: --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 --no-warnings equivalent to '-Wnone' --preserve-dup-deps don't remove duplicate dependency libraries --quiet, --silent don't print informational messages --tag=TAG use configuration variables from tag TAG -v, --verbose print more informational messages than default --version print version information -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all] -h, --help, --help-all print short, long, or detailed help message " # Additional text appended to 'usage_message' in response to '--help'. func_help () { $debug_cmd func_usage_message $ECHO "$long_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) version: $progname $scriptversion Debian-2.4.6-14 automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q` autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q` Report bugs to . GNU libtool home page: . General help using GNU software: ." exit 0 } # func_lo2o OBJECT-NAME # --------------------- # Transform OBJECT-NAME from a '.lo' suffix to the platform specific # object suffix. lo2o=s/\\.lo\$/.$objext/ o2lo=s/\\.$objext\$/.lo/ if test yes = "$_G_HAVE_XSI_OPS"; then eval 'func_lo2o () { case $1 in *.lo) func_lo2o_result=${1%.lo}.$objext ;; * ) func_lo2o_result=$1 ;; esac }' # func_xform LIBOBJ-OR-SOURCE # --------------------------- # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise) # suffix to a '.lo' libtool-object suffix. eval 'func_xform () { func_xform_result=${1%.*}.lo }' else # ...otherwise fall back to using sed. func_lo2o () { func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"` } func_xform () { func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'` } fi # func_fatal_configuration ARG... # ------------------------------- # Echo program name prefixed message to standard error, followed by # a configuration failure hint, and exit. func_fatal_configuration () { func__fatal_error ${1+"$@"} \ "See the $PACKAGE documentation for more information." \ "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 yes = "$build_libtool_libs"; then echo "enable shared libraries" else echo "disable shared libraries" fi if test yes = "$build_old_libs"; 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 } # libtool_options_prep [ARG]... # ----------------------------- # Preparation for options parsed by libtool. libtool_options_prep () { $debug_mode # Option defaults: opt_config=false opt_dlopen= opt_dry_run=false opt_help=false opt_mode= opt_preserve_dup_deps=false opt_quiet=false nonopt= preserve_args= _G_rc_lt_options_prep=: # 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 ;; *) _G_rc_lt_options_prep=false ;; esac if $_G_rc_lt_options_prep; then # Pass back the list of options. func_quote_for_eval ${1+"$@"} libtool_options_prep_result=$func_quote_for_eval_result fi $_G_rc_lt_options_prep } func_add_hook func_options_prep libtool_options_prep # libtool_parse_options [ARG]... # --------------------------------- # Provide handling for libtool specific options. libtool_parse_options () { $debug_cmd _G_rc_lt_parse_options=false # Perform our own loop to consume as many options as possible in # each iteration. while test $# -gt 0; do _G_match_lt_parse_options=: _G_opt=$1 shift case $_G_opt in --dry-run|--dryrun|-n) opt_dry_run=: ;; --config) func_config ;; --dlopen|-dlopen) opt_dlopen="${opt_dlopen+$opt_dlopen }$1" shift ;; --preserve-dup-deps) opt_preserve_dup_deps=: ;; --features) func_features ;; --finish) set dummy --mode finish ${1+"$@"}; shift ;; --help) opt_help=: ;; --help-all) opt_help=': help-all' ;; --mode) test $# = 0 && func_missing_arg $_G_opt && break opt_mode=$1 case $1 in # Valid mode arguments: clean|compile|execute|finish|install|link|relink|uninstall) ;; # Catch anything else as an error *) func_error "invalid argument for $_G_opt" exit_cmd=exit break ;; esac shift ;; --no-silent|--no-quiet) opt_quiet=false func_append preserve_args " $_G_opt" ;; --no-warnings|--no-warning|--no-warn) opt_warning=false func_append preserve_args " $_G_opt" ;; --no-verbose) opt_verbose=false func_append preserve_args " $_G_opt" ;; --silent|--quiet) opt_quiet=: opt_verbose=false func_append preserve_args " $_G_opt" ;; --tag) test $# = 0 && func_missing_arg $_G_opt && break opt_tag=$1 func_append preserve_args " $_G_opt $1" func_enable_tag "$1" shift ;; --verbose|-v) opt_quiet=false opt_verbose=: func_append preserve_args " $_G_opt" ;; # An option not handled by this hook function: *) set dummy "$_G_opt" ${1+"$@"} ; shift _G_match_lt_parse_options=false break ;; esac $_G_match_lt_parse_options && _G_rc_lt_parse_options=: done if $_G_rc_lt_parse_options; then # save modified positional parameters for caller func_quote_for_eval ${1+"$@"} libtool_parse_options_result=$func_quote_for_eval_result fi $_G_rc_lt_parse_options } func_add_hook func_parse_options libtool_parse_options # libtool_validate_options [ARG]... # --------------------------------- # Perform any sanity checks on option settings and/or unconsumed # arguments. libtool_validate_options () { # save first non-option argument if test 0 -lt $#; then nonopt=$1 shift fi # preserve --debug test : = "$debug_cmd" || func_append preserve_args " --debug" case $host in # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452 # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788 *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*) # 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 test yes != "$build_libtool_libs" \ && test yes != "$build_old_libs" \ && func_fatal_configuration "not configured to build any kind of library" # Darwin sucks eval std_shrext=\"$shrext_cmds\" # Only execute mode is allowed to have -dlopen flags. if test -n "$opt_dlopen" && test execute != "$opt_mode"; 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." } # Pass back the unparsed argument list func_quote_for_eval ${1+"$@"} libtool_validate_options_result=$func_quote_for_eval_result } func_add_hook func_validate_options libtool_validate_options # Process options as early as possible so that --help and --version # can return quickly. func_options ${1+"$@"} eval set dummy "$func_options_result"; shift ## ----------- ## ## Main. ## ## ----------- ## magic='%%%MAGIC variable%%%' magic_exe='%%%MAGIC EXE variable%%%' # Global variables. 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= # A function that is used when there is no print builtin or printf. func_fallback_echo () { eval 'cat <<_LTECHO_EOF $1 _LTECHO_EOF' } # func_generated_by_libtool # True iff stdin has been generated by Libtool. This function is only # a basic sanity check; it will hardly flush out determined imposters. func_generated_by_libtool_p () { $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 } # 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 | func_generated_by_libtool_p } # 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 yes = "$lalib_p" } # 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 () { test -f "$1" && $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p } # 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 () { $debug_cmd save_ifs=$IFS; IFS='~' for cmd in $1; do IFS=$sp$nl eval cmd=\"$cmd\" IFS=$save_ifs 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 () { $debug_cmd 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 () { $debug_cmd 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 yes = "$build_libtool_libs"; then write_lobj=\'$2\' else write_lobj=none fi if test yes = "$build_old_libs"; 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 "$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 () { $debug_cmd # 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 () { $debug_cmd 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 () { $debug_cmd # awkward: cmd appends spaces to result func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null | $SED -e 's/[ ]*$//' -e "$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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd $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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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 () { $debug_cmd 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_dll_def_p FILE # True iff FILE is a Windows DLL '.def' file. # Keep in sync with _LT_DLL_DEF_P in libtool.m4 func_dll_def_p () { $debug_cmd func_dll_def_p_tmp=`$SED -n \ -e 's/^[ ]*//' \ -e '/^\(;.*\)*$/d' \ -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \ -e q \ "$1"` test DEF = "$func_dll_def_p_tmp" } # func_mode_compile arg... func_mode_compile () { $debug_cmd # 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 yes = "$build_libtool_libs" \ || func_fatal_configuration "cannot 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 yes = "$build_old_libs"; 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 no = "$pic_mode" && test pass_all != "$deplibs_check_method"; 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 no = "$compiler_c_o"; 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 yes = "$need_locks"; 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 warn = "$need_locks"; 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 yes = "$build_libtool_libs"; then # Without this assignment, base_compile gets emptied. fbsd_hideous_sh_bug=$base_compile if test no != "$pic_mode"; 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 warn = "$need_locks" && 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 yes = "$suppress_opt"; then suppress_output=' >/dev/null 2>&1' fi fi # Only build a position-dependent object if we build old libraries. if test yes = "$build_old_libs"; then if test yes != "$pic_mode"; then # Don't build PIC code command="$base_compile $qsrcfile$pie_flag" else command="$base_compile $qsrcfile $pic_flag" fi if test yes = "$compiler_c_o"; 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 warn = "$need_locks" && 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 no != "$need_locks"; then removelist=$lockfile $RM "$lockfile" fi } exit $EXIT_SUCCESS } $opt_help || { test compile = "$opt_mode" && 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 -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes) -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 () { $debug_cmd # 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 $opt_dry_run; then # 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 else 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 fi } test execute = "$opt_mode" && func_mode_execute ${1+"$@"} # func_mode_finish arg... func_mode_finish () { $debug_cmd 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_quiet && 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 finish = "$opt_mode" && func_mode_finish ${1+"$@"} # func_mode_install arg... func_mode_install () { $debug_cmd # There may be an optional sh(1) argument at the beginning of # install_prog (especially on Windows NT). if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" || # 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=false 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=: ;; -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-m = "X$prev" && 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=: if $isdir; 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 ;; os2*) 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 yes = "$build_old_libs"; 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=: 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'` if test -n "$libdir" && test ! -f "$libfile"; then func_warning "'$lib' has not been installed in '$libdir'" finalize=false fi done relink_command= func_source "$wrapper" outputname= if test no = "$fast_install" && test -n "$relink_command"; then $opt_dry_run || { if $finalize; 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_quiet || { 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 install = "$opt_mode" && 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 () { $debug_cmd my_outputname=$1 my_originator=$2 my_pic_p=${3-false} my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'` my_dlsyms= if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; 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) $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 can'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 #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) /* External symbol declarations for the compiler. */\ " if test yes = "$dlself"; 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 func_show_eval '$RM "${nlist}I"' if test -n "$global_symbol_to_import"; then eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I' 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[];\ " if test -s "$nlist"I; then echo >> "$output_objdir/$my_dlsyms" "\ static void lt_syminit(void) { LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols; for (; symbol->name; ++symbol) {" $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms" echo >> "$output_objdir/$my_dlsyms" "\ } }" fi echo >> "$output_objdir/$my_dlsyms" "\ LT_DLSYM_CONST lt_dlsymlist lt_${my_prefix}_LTX_preloaded_symbols[] = { {\"$my_originator\", (void *) 0}," if test -s "$nlist"I; then echo >> "$output_objdir/$my_dlsyms" "\ {\"@INIT@\", (void *) <_syminit}," fi 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" ;; *) $my_pic_p && pic_flag_for_symtable=" $pic_flag" ;; 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" "${nlist}I"' # 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_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 () { $debug_cmd 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 () { $debug_cmd 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_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 () { $debug_cmd 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 case $nm_interface in "MS dumpbin") if func_cygming_ms_implib_p "$1" || func_cygming_gnu_implib_p "$1" then win32_nmres=import else win32_nmres= fi ;; *) 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 } }'` ;; esac 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 () { $debug_cmd 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 () { $debug_cmd 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 that possess that section. Heuristic: eliminate # all those that 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_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 () { $debug_cmd 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 () { $debug_cmd f_ex_an_ar_dir=$1; shift f_ex_an_ar_oldlib=$1 if test yes = "$lock_old_archive_extraction"; 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 yes = "$lock_old_archive_extraction"; 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 () { $debug_cmd 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` func_basename "$darwin_archive" darwin_base_archive=$func_basename_result 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 "$sed_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 where 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) $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/ that is used only on # windows platforms, and (c) all begin with the string "--lt-" # (application programs are unlikely to have options that 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) $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 yes = "$fast_install"; 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 yes = "$shlibpath_overrides_runpath" && 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 #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) /* 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_platform || defined ... */ #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 #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 (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]; size_t 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 = (size_t) (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 (STREQ (str, pat)) *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 size_t 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) { size_t orig_value_len = strlen (orig_value); size_t 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 #' */ size_t len = strlen (new_value); while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1])) { new_value[--len] = '\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 () { $debug_cmd case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in *import*) : ;; *) false ;; esac } # func_suncc_cstd_abi # !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!! # Several compiler flags select an ABI that is incompatible with the # Cstd library. Avoid specifying it if any are in CXXFLAGS. func_suncc_cstd_abi () { $debug_cmd case " $compile_command " in *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*) suncc_use_cstd_abi=no ;; *) suncc_use_cstd_abi=yes ;; esac } # func_mode_link arg... func_mode_link () { $debug_cmd 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 # what 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 that 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= os2dllname= non_pic_objects= precious_files_regex= prefer_static_libs=no preload=false 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 yes != "$build_libtool_libs" \ && func_fatal_configuration "cannot build a shared library" build_old_libs=no break ;; -all-static | -static | -static-libtool-libs) case $arg in -all-static) if test yes = "$build_libtool_libs" && 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) $preload || { # Add the symbol object into the linking commands. func_append compile_command " @SYMFILE@" func_append finalize_command " @SYMFILE@" preload=: } case $arg in *.la | *.lo) ;; # We handle these cases below. force) if test no = "$dlself"; then dlself=needless export_dynamic=yes fi prev= continue ;; self) if test dlprefiles = "$prev"; then dlself=yes elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then dlself=yes else dlself=needless export_dynamic=yes fi prev= continue ;; *) if test dlfiles = "$prev"; 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 ;; mllvm) # Clang does not use LLVM to link, so we can simply discard any # '-mllvm $arg' options when doing the link step. 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 none = "$pic_object" && test none = "$non_pic_object"; 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 none != "$pic_object"; then # Prepend the subdirectory the object is found in. pic_object=$xdir$pic_object if test dlfiles = "$prev"; then if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; 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 dlprefiles = "$prev"; 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 none != "$non_pic_object"; 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 none = "$pic_object"; 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 ;; os2dllname) os2dllname=$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 rpath = "$prev"; 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-export-symbols = "X$arg"; 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-lc = "X$arg" || test X-lm = "X$arg"; 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-lc = "X$arg" && continue ;; *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*) # Do not include libc due to us having libc/libc_r. test X-lc = "X$arg" && 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-lc = "X$arg" && continue ;; *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) # Compiler inserts libc in the correct place for threads to work test X-lc = "X$arg" && continue ;; esac elif test X-lc_r = "X$arg"; then case $host in *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*) # Do not include libc_r directly, use -pthread flag. continue ;; esac fi func_append deplibs " $arg" continue ;; -mllvm) prev=mllvm 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 ;; -os2dllname) prev=os2dllname 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 # -fstack-protector* stack protector flags for GCC # @file GCC response files # -tp=* Portland pgcc target processor selection # --sysroot=* for sysroot support # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization # -specs=* GCC specs files # -stdlib=* select c++ std lib with clang # -fsanitize=* Clang/GCC memory and address sanitizer # -fuse-ld=* Linker select flags for GCC # -static-* direct GCC to link specific libraries statically # -fcilkplus Cilk Plus language extension features for C/C++ -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*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \ -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus) 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 ;; -Z*) if test os2 = "`expr $host : '.*\(os2\)'`"; then # OS/2 uses -Zxxx to specify OS/2-specific options compiler_flags="$compiler_flags $arg" func_append compile_command " $arg" func_append finalize_command " $arg" case $arg in -Zlinker | -Zstack) prev=xcompiler ;; esac continue else # Otherwise treat like 'Some other compiler flag' below func_quote_for_eval "$arg" arg=$func_quote_for_eval_result fi ;; # 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 none = "$pic_object" && test none = "$non_pic_object"; then func_fatal_error "cannot find name of object for '$arg'" fi # Extract subdirectory from the argument. func_dirname "$arg" "/" "" xdir=$func_dirname_result test none = "$pic_object" || { # Prepend the subdirectory the object is found in. pic_object=$xdir$pic_object if test dlfiles = "$prev"; then if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; 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 dlprefiles = "$prev"; then # Preload the old-style object. func_append dlprefiles " $pic_object" prev= fi # A PIC object. func_append libobjs " $pic_object" arg=$pic_object } # Non-PIC object. if test none != "$non_pic_object"; 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 none = "$pic_object"; 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 dlfiles = "$prev"; then # This library was specified with -dlopen. func_append dlfiles " $func_resolve_sysroot_result" prev= elif test dlprefiles = "$prev"; 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 yes = "$export_dynamic" && 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\" # Definition is injected by LT_CONFIG during libtool generation. func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH" 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 lib = "$linkmode"; 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=false 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 lib,link = "$linkmode,$pass"; 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 lib,link = "$linkmode,$pass" || test prog,scan = "$linkmode,$pass"; then libs=$deplibs deplibs= fi if test prog = "$linkmode"; 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 lib,dlpreopen = "$linkmode,$pass"; 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 dlopen = "$pass"; then # Collect dlpreopened libraries save_deplibs=$deplibs deplibs= fi for deplib in $libs; do lib= found=false case $deplib in -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else func_append compiler_flags " $deplib" if test lib = "$linkmode"; then case "$new_inherited_linker_flags " in *" $deplib "*) ;; * ) func_append new_inherited_linker_flags " $deplib" ;; esac fi fi continue ;; -l*) if test lib != "$linkmode" && test prog != "$linkmode"; then func_warning "'-l' is ignored for archives/objects" continue fi func_stripname '-l' '' "$deplib" name=$func_stripname_result if test lib = "$linkmode"; 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 .la = "$search_ext"; then found=: else found=false fi break 2 fi done done if $found; then # 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 yes = "$allow_libtool_libs_with_static_runtimes"; 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=false func_dirname "$lib" "" "." ladir=$func_dirname_result lib=$ladir/$old_library if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else deplibs="$deplib $deplibs" test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs" fi continue fi fi ;; *) ;; esac fi else # deplib doesn't seem to be a libtool library if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else deplibs="$deplib $deplibs" test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs" fi continue fi ;; # -l *.ltframework) if test prog,link = "$linkmode,$pass"; then compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" else deplibs="$deplib $deplibs" if test lib = "$linkmode"; 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 conv = "$pass" && 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 conv = "$pass"; then deplibs="$deplib $deplibs" continue fi if test scan = "$pass"; 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 link = "$pass"; 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 conv = "$pass"; 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=false 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=: fi ;; pass_all) valid_a_lib=: ;; esac if $valid_a_lib; then echo $ECHO "*** Warning: Linking the shared library $output against the" $ECHO "*** static library $deplib is not portable!" deplibs="$deplib $deplibs" else 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." fi ;; esac continue ;; prog) if test link != "$pass"; then deplibs="$deplib $deplibs" else compile_deplibs="$deplib $compile_deplibs" finalize_deplibs="$deplib $finalize_deplibs" fi continue ;; esac # linkmode ;; # *.$libext *.lo | *.$objext) if test conv = "$pass"; then deplibs="$deplib $deplibs" elif test prog = "$linkmode"; then if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; 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=: continue ;; esac # case $deplib $found || test -f "$lib" \ || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'" # 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 lib,link = "$linkmode,$pass" || test prog,scan = "$linkmode,$pass" || { test prog != "$linkmode" && test lib != "$linkmode"; }; then test -n "$dlopen" && func_append dlfiles " $dlopen" test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen" fi if test conv = "$pass"; 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 prog != "$linkmode" && test lib != "$linkmode"; 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 yes = "$prefer_static_libs" || test built,no = "$prefer_static_libs,$installed"; }; 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 dlopen = "$pass"; then test -z "$libdir" \ && func_fatal_error "cannot -dlopen a convenience library: '$lib'" if test -z "$dlname" || test yes != "$dlopen_support" || test no = "$build_libtool_libs" 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 yes = "$installed"; 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 yes = "$hardcode_automatic" && 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 dlpreopen = "$pass"; then if test -z "$libdir" && test prog = "$linkmode"; 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 lib = "$linkmode"; then deplibs="$dir/$old_library $deplibs" elif test prog,link = "$linkmode,$pass"; 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 prog = "$linkmode" && test link != "$pass"; then func_append newlib_search_path " $ladir" deplibs="$lib $deplibs" linkalldeplibs=false if test no != "$link_all_deplibs" || test -z "$library_names" || test no = "$build_libtool_libs"; then linkalldeplibs=: 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 $linkalldeplibs; 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 prog,link = "$linkmode,$pass"; then if test -n "$library_names" && { { test no = "$prefer_static_libs" || test built,yes = "$prefer_static_libs,$installed"; } || 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 $alldeplibs && { test pass_all = "$deplibs_check_method" || { test yes = "$build_libtool_libs" && 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 built = "$use_static_libs" && test yes = "$installed"; then use_static_libs=no fi if test -n "$library_names" && { test no = "$use_static_libs" || test -z "$old_library"; }; then case $host in *cygwin* | *mingw* | *cegcc* | *os2*) # No point in relinking DLLs because paths are not encoded func_append notinst_deplibs " $lib" need_relink=no ;; *) if test no = "$installed"; 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 yes = "$shouldnotlink" && test link = "$pass"; then echo if test prog = "$linkmode"; 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 lib = "$linkmode" && test yes = "$hardcode_into_libs"; 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* | *os2*) 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 prog = "$linkmode" || test relink != "$opt_mode"; then add_shlibpath= add_dir= add= lib_linked=yes case $hardcode_action in immediate | unsupported) if test no = "$hardcode_direct"; 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 cannot # 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 no = "$hardcode_minus_L"; then case $host in *-*-sunos*) add_shlibpath=$dir ;; esac add_dir=-L$dir add=-l$name elif test no = "$hardcode_shlibpath_var"; then add_shlibpath=$dir add=-l$name else lib_linked=no fi ;; relink) if test yes = "$hardcode_direct" && test no = "$hardcode_direct_absolute"; then add=$dir/$linklib elif test yes = "$hardcode_minus_L"; 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 yes = "$hardcode_shlibpath_var"; then add_shlibpath=$dir add=-l$name else lib_linked=no fi ;; *) lib_linked=no ;; esac if test yes != "$lib_linked"; 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 prog = "$linkmode"; 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 yes != "$hardcode_direct" && test yes != "$hardcode_minus_L" && test yes = "$hardcode_shlibpath_var"; then case :$finalize_shlibpath: in *":$libdir:"*) ;; *) func_append finalize_shlibpath "$libdir:" ;; esac fi fi fi if test prog = "$linkmode" || test relink = "$opt_mode"; then add_shlibpath= add_dir= add= # Finalize command for both is simple: just hardcode it. if test yes = "$hardcode_direct" && test no = "$hardcode_direct_absolute"; then add=$libdir/$linklib elif test yes = "$hardcode_minus_L"; then add_dir=-L$libdir add=-l$name elif test yes = "$hardcode_shlibpath_var"; then case :$finalize_shlibpath: in *":$libdir:"*) ;; *) func_append finalize_shlibpath "$libdir:" ;; esac add=-l$name elif test yes = "$hardcode_automatic"; 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 prog = "$linkmode"; 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 prog = "$linkmode"; 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 unsupported != "$hardcode_direct"; 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 yes = "$build_libtool_libs"; then # Not a shared library if test pass_all != "$deplibs_check_method"; 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 cannot 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 yes = "$module"; 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 no = "$build_old_libs"; 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 lib = "$linkmode"; then if test -n "$dependency_libs" && { test yes != "$hardcode_into_libs" || test yes = "$build_old_libs" || test yes = "$link_static"; }; 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 no = "$link_static" && 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 no != "$link_all_deplibs"; 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 link = "$pass"; then if test prog = "$linkmode"; 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 dlpreopen = "$pass"; then # Link the dlpreopened libraries before other libraries for deplib in $save_deplibs; do deplibs="$deplib $deplibs" done fi if test dlopen != "$pass"; then test conv = "$pass" || { # 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= } if test prog,link = "$linkmode,$pass"; then vars="compile_deplibs finalize_deplibs" else vars=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 # Add Sun CC postdeps if required: test CXX = "$tagname" && { case $host_os in linux*) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 func_suncc_cstd_abi if test no != "$suncc_use_cstd_abi"; then func_append postdeps ' -library=Cstd -library=Crun' fi ;; esac ;; solaris*) func_cc_basename "$CC" case $func_cc_basename_result in CC* | sunCC*) func_suncc_cstd_abi if test no != "$suncc_use_cstd_abi"; then func_append postdeps ' -library=Cstd -library=Crun' fi ;; esac ;; esac } # 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 prog = "$linkmode"; then dlfiles=$newdlfiles fi if test prog = "$linkmode" || test lib = "$linkmode"; then dlprefiles=$newdlprefiles fi case $linkmode in oldlib) if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; 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 no = "$module" \ && func_fatal_help "libtool library '$output' must begin with 'lib'" if test no != "$need_lib_prefix"; 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 pass_all != "$deplibs_check_method"; 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 no = "$dlself" \ || func_warning "'-dlopen self' is ignored for libtool libraries" set dummy $rpath shift test 1 -lt "$#" \ && func_warning "ignoring multiple '-rpath's for a libtool library" install_libdir=$1 oldlibs= if test -z "$rpath"; then if test yes = "$build_libtool_libs"; 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 # that has an extra 1 added just for fun # case $version_type in # correct linux to gnu/linux during the next big refactor darwin|freebsd-elf|linux|osf|windows|none) func_arith $number_major + $number_minor current=$func_arith_result age=$number_minor revision=$number_revision ;; freebsd-aout|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" # On Darwin other compilers case $CC in nagfor*) verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision" ;; *) verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" ;; esac ;; freebsd-aout) major=.$current versuffix=.$current.$revision ;; freebsd-elf) func_arith $current - $age major=.$func_arith_result versuffix=$major.$age.$revision ;; irix | nonstopux) if test no = "$lt_irix_increment"; 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 0 -ne "$loop"; 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 0 -ne "$loop"; 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 ;; sco) major=.$current versuffix=.$current ;; sunos) major=.$current versuffix=.$current.$revision ;; windows) # Use '-' rather than '.', since we only want one # extension on DOS 8.3 file systems. 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 no = "$need_version"; then versuffix= else versuffix=.0.0 fi fi # Remove version info from name if versioning should be avoided if test yes,no = "$avoid_version,$need_version"; then major= versuffix= verstring= fi # Check to see if the archive will have undefined symbols. if test yes = "$allow_undefined"; then if test unsupported = "$allow_undefined_flag"; then if test yes = "$build_old_libs"; then func_warning "undefined symbols not allowed in $host shared libraries; building static only" build_libtool_libs=no else func_fatal_error "can't build $host shared library unless -no-undefined is specified" fi fi else # Don't allow undefined symbols. allow_undefined_flag=$no_undefined_flag fi fi func_generate_dlsyms "$libname" "$libname" : func_append libobjs " $symfileobj" test " " = "$libobjs" && libobjs= if test relink != "$opt_mode"; 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 -n "$precious_files_regex"; 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 yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; 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 yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; 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 yes = "$build_libtool_libs"; 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 yes = "$build_libtool_need_lc"; 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 yes = "$allow_libtool_libs_with_static_runtimes"; 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 yes = "$allow_libtool_libs_with_static_runtimes"; 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 none = "$deplibs_check_method"; 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 yes = "$droppeddeps"; then if test yes = "$module"; 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 no = "$build_old_libs"; 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 no = "$allow_undefined"; 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 no = "$build_old_libs"; 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 yes = "$build_libtool_libs"; then # Remove $wl instances when linking with ld. # FIXME: should test the right _cmds variable. case $archive_cmds in *\$LD\ *) wl= ;; esac if test yes = "$hardcode_into_libs"; then # Hardcode the library paths hardcode_libdirs= dep_rpath= rpath=$finalize_rpath test relink = "$opt_mode" || 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 relink = "$opt_mode" || 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 func_dll_def_p "$export_symbols" || { # 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 ;; esac # Prepare the list of exported symbols if test -z "$export_symbols"; then if test yes = "$always_export_symbols" || 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 yes = "$try_normal_branch" \ && { 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 : != "$skipped_export"; 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 : != "$skipped_export" && 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 yes = "$compiler_needs_object" && 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 yes = "$thread_safe" && 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 relink = "$opt_mode"; 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 yes = "$module" && 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 : != "$skipped_export" && 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 : != "$skipped_export" && test yes = "$with_gnu_ld"; 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 : != "$skipped_export" && test -n "$file_list_spec"; then output=$output_objdir/$output_la.lnk func_verbose "creating linker input file list: $output" : > $output set x $save_libobjs shift firstobj= if test yes = "$compiler_needs_object"; 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 -z "$objlist" || 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 1 -eq "$k"; 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 ${skipped_export-false} && { 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 } 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_quiet || { 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 relink = "$opt_mode"; 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 ${skipped_export-false} && { 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 } 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 yes = "$module" && 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=$sp$nl eval cmd=\"$cmd\" IFS=$save_ifs $opt_quiet || { 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 relink = "$opt_mode"; 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 relink = "$opt_mode"; 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 yes = "$module" || test yes = "$export_dynamic"; then # On all known operating systems, these are identical. dlname=$soname fi fi ;; obj) if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; 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= # if reload_cmds runs $LD directly, get rid of -Wl from # whole_archive_flag_spec and hope we can get by with turning comma # into space. case $reload_cmds in *\$LD[\ \$]*) wl= ;; esac if test -n "$convenience"; then if test -n "$whole_archive_flag_spec"; then eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags 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 yes = "$build_libtool_libs" || 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 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 test yes = "$build_libtool_libs" || { 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 } if test -n "$pic_flag" || test default != "$pic_mode"; 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" $preload \ && test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \ && 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 CXX = "$tagname"; 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 yes = "$build_old_libs"; 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@" false # template prelinking step if test -n "$prelink_cmds"; then func_execute_cmds "$prelink_cmds" 'exit $?' fi wrappers_required=: case $host in *cegcc* | *mingw32ce*) # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. wrappers_required=false ;; *cygwin* | *mingw* ) test yes = "$build_libtool_libs" || wrappers_required=false ;; *) if test no = "$need_relink" || test yes != "$build_libtool_libs"; then wrappers_required=false fi ;; esac $wrappers_required || { # 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 } 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 yes = "$no_install"; 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 case $hardcode_action,$fast_install in relink,*) # 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" ;; *,yes) link_command=$finalize_var$compile_command$finalize_rpath relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` ;; *,no) link_command=$compile_var$compile_command$compile_rpath relink_command=$finalize_var$finalize_command$finalize_rpath ;; *,needless) link_command=$finalize_var$compile_command$finalize_rpath relink_command= ;; esac # 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 case $build_libtool_libs in convenience) oldobjs="$libobjs_save $symfileobj" addlibs=$convenience build_libtool_libs=no ;; module) oldobjs=$libobjs_save addlibs=$old_convenience build_libtool_libs=no ;; *) oldobjs="$old_deplibs $non_pic_objects" $preload && test -f "$symfileobj" \ && func_append oldobjs " $symfileobj" addlibs=$old_convenience ;; esac 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 yes = "$build_libtool_libs"; 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 -z "$oldobjs"; 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 yes = "$build_old_libs" && 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 yes = "$hardcode_automatic"; then relink_command= fi # Only create the output if not a dry run. $opt_dry_run || { for installed in no yes; do if test yes = "$installed"; 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 -n "$bindir"; 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) $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 cannot 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 no,yes = "$installed,$need_relink"; 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 } if test link = "$opt_mode" || test relink = "$opt_mode"; then func_mode_link ${1+"$@"} fi # func_mode_uninstall arg... func_mode_uninstall () { $debug_cmd RM=$nonopt files= rmforce=false 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=: ;; -*) 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 . = "$dir"; then odir=$objdir else odir=$dir/$objdir fi func_basename "$file" name=$func_basename_result test uninstall = "$opt_mode" && odir=$dir # Remember odir for removal later, being careful to avoid duplicates if test clean = "$opt_mode"; 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 $rmforce; 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" '$rmforce || exit_status=1' fi if test -n "$old_library"; then # Do each command in the old_postuninstall commands. func_execute_cmds "$old_postuninstall_cmds" '$rmforce || 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 none != "$pic_object"; 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 none != "$non_pic_object"; then func_append rmfiles " $dir/$non_pic_object" fi fi ;; *) if test clean = "$opt_mode"; 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 yes = "$fast_install" && 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 } if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then func_mode_uninstall ${1+"$@"} fi 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 # where 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: openfst-1.7.9/m4/000077500000000000000000000000001421600557100135275ustar00rootroot00000000000000openfst-1.7.9/m4/ax_python_devel.m4000066400000000000000000000257121421600557100171700ustar00rootroot00000000000000# =========================================================================== # https://www.gnu.org/software/autoconf-archive/ax_python_devel.html # =========================================================================== # # SYNOPSIS # # AX_PYTHON_DEVEL([version]) # # DESCRIPTION # # Note: Defines as a precious variable "PYTHON_VERSION". Don't override it # in your configure.ac. # # This macro checks for Python and tries to get the include path to # 'Python.h'. It provides the $(PYTHON_CPPFLAGS) and $(PYTHON_LIBS) output # variables. It also exports $(PYTHON_EXTRA_LIBS) and # $(PYTHON_EXTRA_LDFLAGS) for embedding Python in your code. # # You can search for some particular version of Python by passing a # parameter to this macro, for example ">= '2.3.1'", or "== '2.4'". Please # note that you *have* to pass also an operator along with the version to # match, and pay special attention to the single quotes surrounding the # version number. Don't use "PYTHON_VERSION" for this: that environment # variable is declared as precious and thus reserved for the end-user. # # This macro should work for all versions of Python >= 2.1.0. As an end # user, you can disable the check for the python version by setting the # PYTHON_NOVERSIONCHECK environment variable to something else than the # empty string. # # If you need to use this macro for an older Python version, please # contact the authors. We're always open for feedback. # # LICENSE # # Copyright (c) 2009 Sebastian Huber # Copyright (c) 2009 Alan W. Irwin # Copyright (c) 2009 Rafael Laboissiere # Copyright (c) 2009 Andrew Collier # Copyright (c) 2009 Matteo Settenvini # Copyright (c) 2009 Horst Knorr # Copyright (c) 2013 Daniel Mullner # # 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 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, the respective Autoconf Macro's copyright owner # gives unlimited permission to copy, distribute and modify the configure # scripts that are the output of Autoconf when processing the Macro. You # need not follow the terms of the GNU General Public License when using # or distributing such scripts, even though portions of the text of the # Macro appear in them. The GNU General Public License (GPL) does govern # all other use of the material that constitutes the Autoconf Macro. # # This special exception to the GPL applies to versions of the Autoconf # Macro released by the Autoconf Archive. When you make and distribute a # modified version of the Autoconf Macro, you may extend this special # exception to the GPL to apply to your modified version as well. #serial 21 AU_ALIAS([AC_PYTHON_DEVEL], [AX_PYTHON_DEVEL]) AC_DEFUN([AX_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; \ ver = sys.version.split ()[[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_LIBS, 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; \ ver = sys.version.split ()[[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 $? -eq 0; 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 ());"` plat_python_path=`$PYTHON -c "import distutils.sysconfig; \ print (distutils.sysconfig.get_python_inc (plat_specific=1));"` if test -n "${python_path}"; then if test "${plat_python_path}" != "${python_path}"; then python_path="-I$python_path -I$plat_python_path" else python_path="-I$python_path" fi 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_LIBS"; then # (makes two attempts to ensure we've got a version number # from the interpreter) ac_python_version=`cat<]], [[Py_Initialize();]]) ],[pythonexists=yes],[pythonexists=no]) AC_LANG_POP([C]) # turn back to default flags CPPFLAGS="$ac_save_CPPFLAGS" LIBS="$ac_save_LIBS" LDFLAGS="$ac_save_LDFLAGS" AC_MSG_RESULT([$pythonexists]) if test ! "x$pythonexists" = "xyes"; then AC_MSG_FAILURE([ 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 LIBS environment variable. Example: ./configure LIBS="-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 # # all done! # ]) openfst-1.7.9/m4/libtool.m4000066400000000000000000011267631421600557100154550ustar00rootroot00000000000000# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- # # Copyright (C) 1996-2001, 2003-2015 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) 2014 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 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 this program. If not, see . ]) # serial 58 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.62])dnl We use AC_PATH_PROGS_FEATURE_CHECK 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_PREPARE_CC_BASENAME # ----------------------- m4_defun([_LT_PREPARE_CC_BASENAME], [ # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. func_cc_basename () { for cc_temp in @S|@*""; do case $cc_temp in compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; \-*) ;; *) break;; esac done func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` } ])# _LT_PREPARE_CC_BASENAME # _LT_CC_BASENAME(CC) # ------------------- # It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME, # but that macro is also expanded into generated libtool script, which # arranges for $SED and $ECHO to be set by different means. m4_defun([_LT_CC_BASENAME], [m4_require([_LT_PREPARE_CC_BASENAME])dnl AC_REQUIRE([_LT_DECL_SED])dnl AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl func_cc_basename $1 cc_basename=$func_cc_basename_result ]) # _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 m4_require([_LT_CMD_TRUNCATE])dnl _LT_CONFIG_LIBTOOL_INIT([ # See if we are running on zsh, and set the options that 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 set != "${COLLECT_NAMES+set}"; 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\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) 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\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes ;; *) 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 0 = "$lt_write_fail" && 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 yes = "$silent" && 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 that 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 # Generated automatically by $as_me ($PACKAGE) $VERSION # NOTE: Changes made to this file will be lost: look at ltmain.sh. # Provide generalized library-building support services. # Written by Gordon Matzigkeit, 1996 _LT_COPYING _LT_LIBTOOL_TAGS # Configured defaults for sys_lib_dlsearch_path munging. : \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} # ### BEGIN LIBTOOL CONFIG _LT_LIBTOOL_CONFIG_VARS _LT_LIBTOOL_TAG_VARS # ### END LIBTOOL CONFIG _LT_EOF cat <<'_LT_EOF' >> "$cfgfile" # ### BEGIN FUNCTIONS SHARED WITH CONFIGURE _LT_PREPARE_MUNGE_PATH_LIST _LT_PREPARE_CC_BASENAME # ### END FUNCTIONS SHARED WITH CONFIGURE _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 set != "${COLLECT_NAMES+set}"; 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) 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' 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 0 = "$_lt_result"; 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 cr libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD $AR cr 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 0 = "$_lt_result" && $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 yes = "$lt_cv_apple_cc_single_mod"; then _lt_dar_single_mod='$single_module' fi if test yes = "$lt_cv_ld_exported_symbols_list"; 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 no = "$lt_cv_ld_force_load"; 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 yes = "$lt_cv_ld_force_load"; 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*|nagfor*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test yes = "$_lt_dar_can_shared"; 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 yes != "$lt_cv_apple_cc_single_mod"; 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 set = "${lt_cv_aix_libpath+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 that will find a shell with a builtin # printf (that 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], [AS_HELP_STRING([--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 yes = "$GCC"; 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 where 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 no = "$enable_libtool_lock" || 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 what ABI is being produced by ac_compile, and set mode # options accordingly. 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 what ABI is being produced by ac_compile, and set linker # options accordingly. echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then if test yes = "$lt_cv_prog_gnu_ld"; 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* ;; mips64*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then emul=elf case `/usr/bin/file conftest.$ac_objext` in *32-bit*) emul="${emul}32" ;; *64-bit*) emul="${emul}64" ;; esac case `/usr/bin/file conftest.$ac_objext` in *MSB*) emul="${emul}btsmip" ;; *LSB*) emul="${emul}ltsmip" ;; esac case `/usr/bin/file conftest.$ac_objext` in *N32*) emul="${emul}n32" ;; esac LD="${LD-ld} -m $emul" fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. Note that the listed cases only cover the # situations where additional linker options are needed (such as when # doing 32-bit compilation for a host where ld defaults to 64-bit, or # vice versa); the common cases where no linker options are needed do # not appear in the list. 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-*linux*) LD="${LD-ld} -m elf32lppclinux" ;; powerpc64-*linux*) 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-*linux*) LD="${LD-ld} -m elf64lppc" ;; powerpc-*linux*) 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 yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS=$SAVE_CFLAGS fi ;; *-*solaris*) # Find out what ABI is being produced by ac_compile, and set linker # options accordingly. 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*|x86_64-*-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=cr} _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 0 -eq "$ac_status"; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a AC_TRY_EVAL([lt_ar_try]) if test 0 -ne "$ac_status"; then lt_cv_ar_at_file=@ fi fi rm -f conftest.* libconftest.a ]) ]) if test no = "$lt_cv_ar_at_file"; 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 bitrig* | 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" ## exclude from sc_useless_quotes_in_assignment # 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 yes = "[$]$2"; 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 yes = "[$]$2"; 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; ;; bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*) # 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 17 != "$i" # 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 yes = "$cross_compiling"; 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 -fvisibility=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 yes != "$enable_dlopen"; 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 ]) ;; tpf*) # Don't try to run any link tests for TPF. We know it's impossible # because TPF is a cross-compiler, and we know how we open DSOs. lt_cv_dlopen=dlopen lt_cv_dlopen_libs= lt_cv_dlopen_self=no ;; *) 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 no = "$lt_cv_dlopen"; then enable_dlopen=no else enable_dlopen=yes fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS=$CPPFLAGS test yes = "$ac_cv_header_dlfcn_h" && 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 yes = "$lt_cv_dlopen_self"; 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 no = "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" && test no != "$need_locks"; 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 no = "$hard_links"; 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 where 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 yes = "$_LT_TAGVAR(hardcode_automatic, $1)"; then # We can hardcode non-existent directories. if test no != "$_LT_TAGVAR(hardcode_direct, $1)" && # 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 no != "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" && test no != "$_LT_TAGVAR(hardcode_minus_L, $1)"; 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 relink = "$_LT_TAGVAR(hardcode_action, $1)" || test yes = "$_LT_TAGVAR(inherit_rpath, $1)"; then # Fast installation is not supported enable_fast_install=no elif test yes = "$shlibpath_overrides_runpath" || test no = "$enable_shared"; 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_PREPARE_MUNGE_PATH_LIST # --------------------------- # Make sure func_munge_path_list() is defined correctly. m4_defun([_LT_PREPARE_MUNGE_PATH_LIST], [[# func_munge_path_list VARIABLE PATH # ----------------------------------- # VARIABLE is name of variable containing _space_ separated list of # directories to be munged by the contents of PATH, which is string # having a format: # "DIR[:DIR]:" # string "DIR[ DIR]" will be prepended to VARIABLE # ":DIR[:DIR]" # string "DIR[ DIR]" will be appended to VARIABLE # "DIRP[:DIRP]::[DIRA:]DIRA" # string "DIRP[ DIRP]" will be prepended to VARIABLE and string # "DIRA[ DIRA]" will be appended to VARIABLE # "DIR[:DIR]" # VARIABLE will be replaced by "DIR[ DIR]" func_munge_path_list () { case x@S|@2 in x) ;; *:) eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\" ;; x:*) eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\" ;; *::*) eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\" ;; *) eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\" ;; esac } ]])# _LT_PREPARE_PATH_LIST # _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 m4_require([_LT_PREPARE_MUNGE_PATH_LIST])dnl AC_MSG_CHECKING([dynamic linker characteristics]) m4_if([$1], [], [ if test yes = "$GCC"; 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` # ...but if some path component already ends with the multilib dir we assume # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). case "$lt_multi_os_dir; $lt_search_path_spec " in "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) lt_multi_os_dir= ;; esac 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" elif test -n "$lt_multi_os_dir"; then 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 AC_ARG_VAR([LT_SYS_LIBRARY_PATH], [User-defined run-time library search path.]) 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 ia64 = "$host_cpu"; 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 # Using Import Files as archive members, it is possible to support # filename-based versioning of shared library archives on AIX. While # this would work for both with and without runtime linking, it will # prevent static linking of such archives. So we do filename-based # shared library versioning with .so extension only, which is used # when both runtime linking and shared linking is enabled. # Unfortunately, runtime linking may impact performance, so we do # not want this to be the default eventually. Also, we use the # versioned .so libs for executables only if there is the -brtl # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only. # To allow for filename-based versioning support, we need to create # libNAME.so.V as an archive file, containing: # *) an Import File, referring to the versioned filename of the # archive as well as the shared archive member, telling the # bitwidth (32 or 64) of that shared object, and providing the # list of exported symbols of that shared object, eventually # decorated with the 'weak' keyword # *) the shared object with the F_LOADONLY flag set, to really avoid # it being seen by the linker. # At run time we better use the real file rather than another symlink, # but for link time we create the symlink libNAME.so -> libNAME.so.V case $with_aix_soname,$aix_use_runtimelinking in # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. aix,yes) # traditional libtool dynamic_linker='AIX unversionable lib.so' # 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' ;; aix,no) # traditional AIX only dynamic_linker='AIX lib.a[(]lib.so.V[)]' # 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' ;; svr4,*) # full svr4 only dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)]" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,yes) # both, prefer svr4 dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)], lib.a[(]lib.so.V[)]" library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' # unpreferred sharedlib libNAME.a needs extra handling postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' # We do not specify a path in Import Files, so LIBPATH fires. shlibpath_overrides_runpath=yes ;; *,no) # both, prefer aix dynamic_linker="AIX lib.a[(]lib.so.V[)], lib.so.V[(]$shared_archive_member_spec.o[)]" library_names_spec='$libname$release.a $libname.a' soname_spec='$libname$release$shared_ext$major' # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' ;; esac 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%'\''`; $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$major $libname$shared_ext' soname_spec='$libname$release$shared_ext$major' 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=no 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 32 = "$HPUX_IA64_MODE"; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" sys_lib_dlsearch_path_spec=/usr/lib/hpux32 else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" sys_lib_dlsearch_path_spec=/usr/lib/hpux64 fi ;; 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 yes = "$lt_cv_prog_gnu_ld"; 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 ;; linux*android*) version_type=none # Android doesn't support versioned libraries. need_lib_prefix=no need_version=no library_names_spec='$libname$release$shared_ext' soname_spec='$libname$release$shared_ext' finish_cmds= shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # 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 dynamic_linker='Android linker' # Don't embed -rpath directories since the linker doesn't support them. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' ;; # 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 # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, # even though it is searched at run-time. Try to do the best guess by # appending ld.so.conf contents (and includes) 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* | bitrig*) version_type=sunos sys_lib_dlsearch_path_spec=/usr/lib need_lib_prefix=no if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then need_version=no else need_version=yes fi 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 shlibpath_overrides_runpath=yes ;; os2*) libname_spec='$name' version_type=windows shrext_cmds=.dll need_version=no need_lib_prefix=no # OS/2 can only load a DLL with a base name of 8 characters or less. soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; v=$($ECHO $release$versuffix | tr -d .-); n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); $ECHO $n$v`$shared_ext' library_names_spec='${libname}_dll.$libext' dynamic_linker='OS/2 ld.exe' shlibpath_var=BEGINLIBPATH sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec 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' ;; 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 yes = "$with_gnu_ld"; 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=sco 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 yes = "$with_gnu_ld"; 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 no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test yes = "$GCC"; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec fi if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec fi # remember unaugmented sys_lib_dlsearch_path content for libtool script decls... configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec # ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" # to be used as default LT_SYS_LIBRARY_PATH value in generated libtool configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH _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], [configure_time_dlsearch_path], [2], [Detected run-time system search path for libraries]) _LT_DECL([], [configure_time_lt_sys_library_path], [2], [Explicit LT_SYS_LIBRARY_PATH set during ./configure time]) ])# _LT_SYS_DYNAMIC_LINKER # _LT_PATH_TOOL_PREFIX(TOOL) # -------------------------- # find a file program that 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 that 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 no = "$withval" || with_gnu_ld=yes], [with_gnu_ld=no])dnl ac_prog=ld if test yes = "$GCC"; 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 yes = "$with_gnu_ld"; 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 conftest.i cat conftest.i conftest.i >conftest2.i : ${lt_DD:=$DD} AC_PATH_PROGS_FEATURE_CHECK([lt_DD], [dd], [if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: fi]) rm -f conftest.i conftest2.i conftest.out]) ])# _LT_PATH_DD # _LT_CMD_TRUNCATE # ---------------- # find command to truncate a binary pipe m4_defun([_LT_CMD_TRUNCATE], [m4_require([_LT_PATH_DD]) AC_CACHE_CHECK([how to truncate binary pipes], [lt_cv_truncate_bin], [printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i lt_cv_truncate_bin= if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then cmp -s conftest.i conftest.out \ && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" fi rm -f conftest.i conftest2.i conftest.out test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"]) _LT_DECL([lt_truncate_bin], [lt_cv_truncate_bin], [1], [Command to truncate a binary pipe]) ])# _LT_CMD_TRUNCATE # _LT_CHECK_MAGIC_METHOD # ---------------------- # how to check for library dependencies # -- PORTME fill in with the dynamic library characteristics m4_defun([_LT_CHECK_MAGIC_METHOD], [m4_require([_LT_DECL_EGREP]) m4_require([_LT_DECL_OBJDUMP]) AC_CACHE_CHECK([how to recognize dependent libraries], lt_cv_deplibs_check_method, [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 # that 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. if ( 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* | bitrig*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; 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 ;; os2*) 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 # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty case $build_os in mingw*) lt_bad_file=conftest.nm/nofile ;; *) lt_bad_file=/dev/null ;; esac case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in *$lt_bad_file* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break 2 ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break 2 ;; *) 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 no != "$lt_cv_path_NM"; 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 -headers /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols -headers" ;; *) 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 one 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 yes != "$lt_cv_path_mainfest_tool"; then MANIFEST_TOOL=: fi _LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl ])# _LT_PATH_MANIFEST_TOOL # _LT_DLL_DEF_P([FILE]) # --------------------- # True iff FILE is a Windows DLL '.def' file. # Keep in sync with func_dll_def_p in the libtool script AC_DEFUN([_LT_DLL_DEF_P], [dnl test DEF = "`$SED -n dnl -e '\''s/^[[ ]]*//'\'' dnl Strip leading whitespace -e '\''/^\(;.*\)*$/d'\'' dnl Delete empty lines and comments -e '\''s/^\(EXPORTS\|LIBRARY\)\([[ ]].*\)*$/DEF/p'\'' dnl -e q dnl Only consider the first "real" line $1`" dnl ])# _LT_DLL_DEF_P # 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 yes = "$GCC"; 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 ia64 = "$host_cpu"; 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 if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Gets list of data symbols to import. lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* \(.*\)$/\1/p'" # Adjust the below global symbol transforms to fixup imported variables. lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'" lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'" lt_c_name_lib_hook="\ -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\ -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'" else # Disable hooks by default. lt_cv_sys_global_symbol_to_import= lt_cdecl_hook= lt_c_name_hook= lt_c_name_lib_hook= fi # 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"\ $lt_cdecl_hook\ " -e 's/^T .* \(.*\)$/extern int \1();/p'"\ " -e 's/^$symcode$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"\ $lt_c_name_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'" # Transform an extracted symbol line into symbol name with lib prefix and # symbol address. lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\ $lt_c_name_lib_hook\ " -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\ " -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\ " -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/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, # D for any global variable and I for any imported 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};"\ " /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ " /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ " /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ " {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ " s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print f,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 $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&AS_MESSAGE_LOG_FD if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&AS_MESSAGE_LOG_FD && 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 can'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* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$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 yes = "$pipe_works"; 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_import], [lt_cv_sys_global_symbol_to_import], [1], [Transform the output of nm into a list of symbols to manually relocate]) _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_interface], [lt_cv_nm_interface], [1], [The name lister interface]) _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 yes = "$GXX"; 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 ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; 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']) case $host_os in os2*) _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' ;; esac ;; 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 ia64 = "$host_cpu"; 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 ia64 != "$host_cpu"; 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 yes = "$GCC"; 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 ia64 = "$host_cpu"; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; 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']) case $host_os in os2*) _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' ;; esac ;; 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 ia64 = "$host_cpu"; 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 ;; 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' case $cc_basename in 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' ;; esac ;; 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']) case $host_os in os2*) _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' ;; esac ;; 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' ;; # flang / f18. f95 an alias for gfortran or flang on Debian flang* | f18* | f95*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _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' ;; tcc*) # Fabrice Bellard et al's Tiny 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)='-static' ;; 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 that 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. 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) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | 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 yes != "$GCC"; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd* | bitrig*) 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 yes = "$with_gnu_ld"; 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 yes = "$lt_use_gnu_ld_interface"; 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 | $SED -e 's/([^)]\+)\s\+//' 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 ia64 != "$host_cpu"; 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, use it as # is; otherwise, prepend EXPORTS... _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); 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 ;; os2*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported shrext_cmds=.dll _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' _LT_TAGVAR(enable_shared_with_static_runtimes, $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 linux-dietlibc = "$host_os"; 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 no = "$tmp_diet" 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' ;; nagfor*) # NAGFOR 5.3 tmp_sharedflag='-Wl,-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 yes = "$supports_anon_versioning"; 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 tcc*) _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic' ;; 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 yes = "$supports_anon_versioning"; 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 cannot *** 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 no = "$_LT_TAGVAR(ld_shlibs, $1)"; 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 yes = "$GCC" && 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 ia64 = "$host_cpu"; 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 GNU nm, but means don't demangle to AIX nm. # Without the "-l" option, or with the "-B" option, AIX nm treats # weak defined symbols like other global defined symbols, whereas # GNU nm marks them as "W". # While the 'weak' keyword is ignored in the Export File, we need # it in the Import File for the 'aix-soname' feature, so we have # to replace the "-B" option with "-P" for AIX nm. 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) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then aix_use_runtimelinking=yes break fi done if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # traditional, no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no ;; esac if test yes = "$GCC"; 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 yes = "$aix_use_runtimelinking"; then shared_flag="$shared_flag "'$wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' 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,yes = "$with_aix_soname,$aix_use_runtimelinking"; 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 -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; 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 yes = "$with_gnu_ld"; 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 _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared libraries. _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' 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,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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 yes = "$GCC"; 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 "x$output_objdir/$soname" = "x$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 "x$output_objdir/$soname" = "x$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 yes,no = "$GCC,$with_gnu_ld"; 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 no = "$with_gnu_ld"; 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 yes,no = "$GCC,$with_gnu_ld"; 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 no = "$with_gnu_ld"; 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 yes = "$GCC"; 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 yes = "$lt_cv_irix_exported_symbol"; 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 _LT_TAGVAR(link_all_deplibs, $1)=no 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 ;; linux*) case $cc_basename in tcc*) # Fabrice Bellard et al's Tiny C Compiler _LT_TAGVAR(ld_shlibs, $1)=yes _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; 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* | bitrig*) 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__`"; 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 _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' 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 shrext_cmds=.dll _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; osf3*) if test yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 yes = "$GCC"; 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 sequent = "$host_vendor"; 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 yes = "$GCC"; 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 CANNOT 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 yes = "$GCC"; 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 sni = "$host_vendor"; 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 no = "$_LT_TAGVAR(ld_shlibs, $1)" && 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 yes,yes = "$GCC,$enable_shared"; 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 what 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 no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac 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 yes = "$enable_shared" || 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 no != "$CXX" && ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) || (test g++ != "$CXX"))); 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 yes != "$_lt_caught_CXX_error"; 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 yes = "$GXX"; 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 yes = "$GXX"; 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 yes = "$with_gnu_ld"; 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 ia64 = "$host_cpu"; 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 # have runtime linking enabled, and use it for executables. # For shared libraries, we enable/disable runtime linking # depending on the kind of the shared library created - # when "with_aix_soname,aix_use_runtimelinking" is: # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables # "aix,yes" lib.so shared, rtl:yes, for executables # lib.a static archive # "both,no" lib.so.V(shr.o) shared, rtl:yes # lib.a(lib.so.V) shared, rtl:no, for executables # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a(lib.so.V) shared, rtl:no # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables # lib.a static archive 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 if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then # With aix-soname=svr4, we create the lib.so.V shared archives only, # so we don't have lib.a shared libs to link our executables. # We have to force runtime linking in this case. aix_use_runtimelinking=yes LDFLAGS="$LDFLAGS -Wl,-brtl" fi ;; 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,' case $with_aix_soname,$aix_use_runtimelinking in aix,*) ;; # no import file svr4,* | *,yes) # use import file # The Import File defines what to hardcode. _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no ;; esac if test yes = "$GXX"; 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 yes = "$aix_use_runtimelinking"; then shared_flag=$shared_flag' $wl-G' fi # Need to ensure runtime linking is disabled for the traditional # shared library, or the linker may eventually find shared libraries # /with/ Import File - we do not want to mix them. shared_flag_aix='-shared' shared_flag_svr4='-shared $wl-G' else # not using gcc if test ia64 = "$host_cpu"; 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 yes = "$aix_use_runtimelinking"; then shared_flag='$wl-G' else shared_flag='$wl-bM:SRE' fi shared_flag_aix='$wl-bM:SRE' shared_flag_svr4='$wl-G' 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,yes = "$with_aix_soname,$aix_use_runtimelinking"; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. # The "-G" linker flag allows undefined symbols. _LT_TAGVAR(no_undefined_flag, $1)='-bernotok' # 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 -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag else if test ia64 = "$host_cpu"; 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 yes = "$with_gnu_ld"; 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 _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' # -brtl affects multiple linker settings, -berok does not and is overridden later compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' if test svr4 != "$with_aix_soname"; then # This is similar to how AIX traditionally builds its shared # libraries. Need -bnortl late, we may have -brtl in LDFLAGS. _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' fi if test aix != "$with_aix_soname"; then _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' else # used by -dlpreopen to get the symbols _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' fi _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' 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,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then cp "$export_symbols" "$output_objdir/$soname.def"; echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp"; else $SED -e '\''s/^/-link -EXPORT:/'\'' < $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, use it as # is; otherwise, prepend EXPORTS... _LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); 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) ;; os2*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported shrext_cmds=.dll _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ $ECHO EXPORTS >> $output_objdir/$libname.def~ prefix_cmds="$SED"~ if test EXPORTS = "`$SED 1q $export_symbols`"; then prefix_cmds="$prefix_cmds -e 1d"; fi~ prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ emximp -o $lib $output_objdir/$libname.def' _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; 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 "x$output_objdir/$soname" = "x$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 yes = "$GXX"; 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 "x$output_objdir/$soname" = "x$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 no = "$with_gnu_ld"; 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 yes = "$GXX"; then if test no = "$with_gnu_ld"; 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 yes = "$GXX"; then if test no = "$with_gnu_ld"; 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 yes = "$supports_anon_versioning"; 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 ;; openbsd* | bitrig*) 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__`"; 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 yes,no = "$GXX,$with_gnu_ld"; 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 yes,no = "$GXX,$with_gnu_ld"; 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 $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 $wl-h $wl$soname -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 $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 $wl-h $wl$soname -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 CANNOT 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 no = "$_LT_TAGVAR(ld_shlibs, $1)" && 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 yes != "$_lt_caught_CXX_error" 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 @S|@2 in .*) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%\\\\@S|@2\$%%"`;; *) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%@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 x-L = "$p" || test x-R = "$p"; 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 no = "$pre_test_object_deps_done"; 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 no = "$pre_test_object_deps_done"; 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)= ;; 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 no = "$F77"; 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 yes != "$_lt_disable_F77"; 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 no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac 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 yes = "$enable_shared" || 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 yes != "$_lt_disable_F77" 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 no = "$FC"; 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 yes != "$_lt_disable_FC"; 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 no = "$can_build_shared" && 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 yes = "$enable_shared" && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test ia64 != "$host_cpu"; then case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in yes,aix,yes) ;; # shared object as lib.so file only yes,svr4,*) ;; # shared object as lib.so archive member only yes,*) enable_static=no ;; # shared object in lib.a archive as well esac 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 yes = "$enable_shared" || 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 yes != "$_lt_disable_FC" 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 set = "${GCJFLAGS+set}" || 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 10 -lt "$lt_ac_count" && 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], [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_PATH_CONVERSION_FUNCTIONS # ----------------------------- # Determine what 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 openfst-1.7.9/m4/ltoptions.m4000066400000000000000000000342621421600557100160330ustar00rootroot00000000000000# Helper functions for option handling. -*- Autoconf -*- # # Copyright (C) 2004-2005, 2007-2009, 2011-2015 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 8 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_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4], [_LT_WITH_AIX_SONAME([aix])]) ]) ])# _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_AIX_SONAME([DEFAULT]) # ---------------------------------- # implement the --with-aix-soname flag, and support the `aix-soname=aix' # and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT # is either `aix', `both' or `svr4'. If omitted, it defaults to `aix'. m4_define([_LT_WITH_AIX_SONAME], [m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl shared_archive_member_spec= case $host,$enable_shared in power*-*-aix[[5-9]]*,yes) AC_MSG_CHECKING([which variant of shared library versioning to provide]) AC_ARG_WITH([aix-soname], [AS_HELP_STRING([--with-aix-soname=aix|svr4|both], [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])], [case $withval in aix|svr4|both) ;; *) AC_MSG_ERROR([Unknown argument to --with-aix-soname]) ;; esac lt_cv_with_aix_soname=$with_aix_soname], [AC_CACHE_VAL([lt_cv_with_aix_soname], [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT) with_aix_soname=$lt_cv_with_aix_soname]) AC_MSG_RESULT([$with_aix_soname]) if test aix != "$with_aix_soname"; then # For the AIX way of multilib, we name the shared archive member # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, # the AIX toolchain works better with OBJECT_MODE set (default 32). if test 64 = "${OBJECT_MODE-32}"; then shared_archive_member_spec=shr_64 else shared_archive_member_spec=shr fi fi ;; *) with_aix_soname=aix ;; esac _LT_DECL([], [shared_archive_member_spec], [0], [Shared archive member basename, for filename based shared library versioning on AIX])dnl ])# _LT_WITH_AIX_SONAME LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])]) LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])]) LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])]) # _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=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])]) openfst-1.7.9/m4/ltsugar.m4000066400000000000000000000104401421600557100154510ustar00rootroot00000000000000# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- # # Copyright (C) 2004-2005, 2007-2008, 2011-2015 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 ]) openfst-1.7.9/m4/ltversion.m4000066400000000000000000000012731421600557100160210ustar00rootroot00000000000000# ltversion.m4 -- version numbers -*- Autoconf -*- # # Copyright (C) 2004, 2011-2015 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 4179 ltversion.m4 # This file is part of GNU Libtool m4_define([LT_PACKAGE_VERSION], [2.4.6]) m4_define([LT_PACKAGE_REVISION], [2.4.6]) AC_DEFUN([LTVERSION_VERSION], [macro_version='2.4.6' macro_revision='2.4.6' _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) _LT_DECL(, macro_revision, 0) ]) openfst-1.7.9/m4/lt~obsolete.m4000066400000000000000000000137741421600557100163570ustar00rootroot00000000000000# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- # # Copyright (C) 2004-2005, 2007, 2009, 2011-2015 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])]) openfst-1.7.9/missing000077500000000000000000000153361421600557100146160ustar00rootroot00000000000000#! /bin/sh # Common wrapper for a few potentially missing GNU programs. scriptversion=2018-03-07.03; # UTC # Copyright (C) 1996-2018 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=https://www.perl.org/ flex_URL=https://github.com/westes/flex gnu_software_URL=https://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 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: openfst-1.7.9/src/000077500000000000000000000000001421600557100137765ustar00rootroot00000000000000openfst-1.7.9/src/Makefile.am000066400000000000000000000000611421600557100160270ustar00rootroot00000000000000SUBDIRS = include lib script bin test extensions openfst-1.7.9/src/Makefile.in000066400000000000000000000452531421600557100160540ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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 distdir-am 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) am__DIST_COMMON = $(srcdir)/Makefile.in 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/bin/000077500000000000000000000000001421600557100145465ustar00rootroot00000000000000openfst-1.7.9/src/bin/Makefile.am000066400000000000000000000052361421600557100166100ustar00rootroot00000000000000AM_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 openfst-1.7.9/src/bin/Makefile.in000066400000000000000000001701051421600557100166170ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/fstarcsort-main.Po \ ./$(DEPDIR)/fstarcsort.Po ./$(DEPDIR)/fstclosure-main.Po \ ./$(DEPDIR)/fstclosure.Po ./$(DEPDIR)/fstcompile-main.Po \ ./$(DEPDIR)/fstcompile.Po ./$(DEPDIR)/fstcompose-main.Po \ ./$(DEPDIR)/fstcompose.Po ./$(DEPDIR)/fstconcat-main.Po \ ./$(DEPDIR)/fstconcat.Po ./$(DEPDIR)/fstconnect-main.Po \ ./$(DEPDIR)/fstconnect.Po ./$(DEPDIR)/fstconvert-main.Po \ ./$(DEPDIR)/fstconvert.Po ./$(DEPDIR)/fstdeterminize-main.Po \ ./$(DEPDIR)/fstdeterminize.Po \ ./$(DEPDIR)/fstdifference-main.Po ./$(DEPDIR)/fstdifference.Po \ ./$(DEPDIR)/fstdisambiguate-main.Po \ ./$(DEPDIR)/fstdisambiguate.Po ./$(DEPDIR)/fstdraw-main.Po \ ./$(DEPDIR)/fstdraw.Po ./$(DEPDIR)/fstencode-main.Po \ ./$(DEPDIR)/fstencode.Po ./$(DEPDIR)/fstepsnormalize-main.Po \ ./$(DEPDIR)/fstepsnormalize.Po ./$(DEPDIR)/fstequal-main.Po \ ./$(DEPDIR)/fstequal.Po ./$(DEPDIR)/fstequivalent-main.Po \ ./$(DEPDIR)/fstequivalent.Po ./$(DEPDIR)/fstinfo-main.Po \ ./$(DEPDIR)/fstinfo.Po ./$(DEPDIR)/fstintersect-main.Po \ ./$(DEPDIR)/fstintersect.Po ./$(DEPDIR)/fstinvert-main.Po \ ./$(DEPDIR)/fstinvert.Po ./$(DEPDIR)/fstisomorphic-main.Po \ ./$(DEPDIR)/fstisomorphic.Po ./$(DEPDIR)/fstmap-main.Po \ ./$(DEPDIR)/fstmap.Po ./$(DEPDIR)/fstminimize-main.Po \ ./$(DEPDIR)/fstminimize.Po ./$(DEPDIR)/fstprint-main.Po \ ./$(DEPDIR)/fstprint.Po ./$(DEPDIR)/fstproject-main.Po \ ./$(DEPDIR)/fstproject.Po ./$(DEPDIR)/fstprune-main.Po \ ./$(DEPDIR)/fstprune.Po ./$(DEPDIR)/fstpush-main.Po \ ./$(DEPDIR)/fstpush.Po ./$(DEPDIR)/fstrandgen-main.Po \ ./$(DEPDIR)/fstrandgen.Po ./$(DEPDIR)/fstrelabel-main.Po \ ./$(DEPDIR)/fstrelabel.Po ./$(DEPDIR)/fstreplace-main.Po \ ./$(DEPDIR)/fstreplace.Po ./$(DEPDIR)/fstreverse-main.Po \ ./$(DEPDIR)/fstreverse.Po ./$(DEPDIR)/fstreweight-main.Po \ ./$(DEPDIR)/fstreweight.Po ./$(DEPDIR)/fstrmepsilon-main.Po \ ./$(DEPDIR)/fstrmepsilon.Po \ ./$(DEPDIR)/fstshortestdistance-main.Po \ ./$(DEPDIR)/fstshortestdistance.Po \ ./$(DEPDIR)/fstshortestpath-main.Po \ ./$(DEPDIR)/fstshortestpath.Po ./$(DEPDIR)/fstsymbols-main.Po \ ./$(DEPDIR)/fstsymbols.Po ./$(DEPDIR)/fstsynchronize-main.Po \ ./$(DEPDIR)/fstsynchronize.Po ./$(DEPDIR)/fsttopsort-main.Po \ ./$(DEPDIR)/fsttopsort.Po ./$(DEPDIR)/fstunion-main.Po \ ./$(DEPDIR)/fstunion.Po 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstarcsort.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstclosure-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstclosure.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompile-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompile.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompose-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompose.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconcat-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconcat.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconnect-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconnect.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconvert-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconvert.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdeterminize-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdeterminize.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdifference-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdifference.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdisambiguate-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdisambiguate.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdraw-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdraw.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstencode-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstencode.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstepsnormalize-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstepsnormalize.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequal-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequal.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequivalent-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequivalent.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinfo-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinfo.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstintersect-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstintersect.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinvert-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinvert.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstisomorphic-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstisomorphic.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstmap-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstmap.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstminimize-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstminimize.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprint-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprint.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstproject-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstproject.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprune-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprune.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstpush-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstpush.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrandgen-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrandgen.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrelabel-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrelabel.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreplace-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreplace.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreverse-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreverse.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreweight-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreweight.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrmepsilon-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrmepsilon.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestdistance-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestdistance.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestpath-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestpath.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsymbols-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsymbols.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsynchronize-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsynchronize.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fsttopsort-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fsttopsort.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstunion-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstunion.Po@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/fstarcsort-main.Po -rm -f ./$(DEPDIR)/fstarcsort.Po -rm -f ./$(DEPDIR)/fstclosure-main.Po -rm -f ./$(DEPDIR)/fstclosure.Po -rm -f ./$(DEPDIR)/fstcompile-main.Po -rm -f ./$(DEPDIR)/fstcompile.Po -rm -f ./$(DEPDIR)/fstcompose-main.Po -rm -f ./$(DEPDIR)/fstcompose.Po -rm -f ./$(DEPDIR)/fstconcat-main.Po -rm -f ./$(DEPDIR)/fstconcat.Po -rm -f ./$(DEPDIR)/fstconnect-main.Po -rm -f ./$(DEPDIR)/fstconnect.Po -rm -f ./$(DEPDIR)/fstconvert-main.Po -rm -f ./$(DEPDIR)/fstconvert.Po -rm -f ./$(DEPDIR)/fstdeterminize-main.Po -rm -f ./$(DEPDIR)/fstdeterminize.Po -rm -f ./$(DEPDIR)/fstdifference-main.Po -rm -f ./$(DEPDIR)/fstdifference.Po -rm -f ./$(DEPDIR)/fstdisambiguate-main.Po -rm -f ./$(DEPDIR)/fstdisambiguate.Po -rm -f ./$(DEPDIR)/fstdraw-main.Po -rm -f ./$(DEPDIR)/fstdraw.Po -rm -f ./$(DEPDIR)/fstencode-main.Po -rm -f ./$(DEPDIR)/fstencode.Po -rm -f ./$(DEPDIR)/fstepsnormalize-main.Po -rm -f ./$(DEPDIR)/fstepsnormalize.Po -rm -f ./$(DEPDIR)/fstequal-main.Po -rm -f ./$(DEPDIR)/fstequal.Po -rm -f ./$(DEPDIR)/fstequivalent-main.Po -rm -f ./$(DEPDIR)/fstequivalent.Po -rm -f ./$(DEPDIR)/fstinfo-main.Po -rm -f ./$(DEPDIR)/fstinfo.Po -rm -f ./$(DEPDIR)/fstintersect-main.Po -rm -f ./$(DEPDIR)/fstintersect.Po -rm -f ./$(DEPDIR)/fstinvert-main.Po -rm -f ./$(DEPDIR)/fstinvert.Po -rm -f ./$(DEPDIR)/fstisomorphic-main.Po -rm -f ./$(DEPDIR)/fstisomorphic.Po -rm -f ./$(DEPDIR)/fstmap-main.Po -rm -f ./$(DEPDIR)/fstmap.Po -rm -f ./$(DEPDIR)/fstminimize-main.Po -rm -f ./$(DEPDIR)/fstminimize.Po -rm -f ./$(DEPDIR)/fstprint-main.Po -rm -f ./$(DEPDIR)/fstprint.Po -rm -f ./$(DEPDIR)/fstproject-main.Po -rm -f ./$(DEPDIR)/fstproject.Po -rm -f ./$(DEPDIR)/fstprune-main.Po -rm -f ./$(DEPDIR)/fstprune.Po -rm -f ./$(DEPDIR)/fstpush-main.Po -rm -f ./$(DEPDIR)/fstpush.Po -rm -f ./$(DEPDIR)/fstrandgen-main.Po -rm -f ./$(DEPDIR)/fstrandgen.Po -rm -f ./$(DEPDIR)/fstrelabel-main.Po -rm -f ./$(DEPDIR)/fstrelabel.Po -rm -f ./$(DEPDIR)/fstreplace-main.Po -rm -f ./$(DEPDIR)/fstreplace.Po -rm -f ./$(DEPDIR)/fstreverse-main.Po -rm -f ./$(DEPDIR)/fstreverse.Po -rm -f ./$(DEPDIR)/fstreweight-main.Po -rm -f ./$(DEPDIR)/fstreweight.Po -rm -f ./$(DEPDIR)/fstrmepsilon-main.Po -rm -f ./$(DEPDIR)/fstrmepsilon.Po -rm -f ./$(DEPDIR)/fstshortestdistance-main.Po -rm -f ./$(DEPDIR)/fstshortestdistance.Po -rm -f ./$(DEPDIR)/fstshortestpath-main.Po -rm -f ./$(DEPDIR)/fstshortestpath.Po -rm -f ./$(DEPDIR)/fstsymbols-main.Po -rm -f ./$(DEPDIR)/fstsymbols.Po -rm -f ./$(DEPDIR)/fstsynchronize-main.Po -rm -f ./$(DEPDIR)/fstsynchronize.Po -rm -f ./$(DEPDIR)/fsttopsort-main.Po -rm -f ./$(DEPDIR)/fsttopsort.Po -rm -f ./$(DEPDIR)/fstunion-main.Po -rm -f ./$(DEPDIR)/fstunion.Po -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 -f ./$(DEPDIR)/fstarcsort-main.Po -rm -f ./$(DEPDIR)/fstarcsort.Po -rm -f ./$(DEPDIR)/fstclosure-main.Po -rm -f ./$(DEPDIR)/fstclosure.Po -rm -f ./$(DEPDIR)/fstcompile-main.Po -rm -f ./$(DEPDIR)/fstcompile.Po -rm -f ./$(DEPDIR)/fstcompose-main.Po -rm -f ./$(DEPDIR)/fstcompose.Po -rm -f ./$(DEPDIR)/fstconcat-main.Po -rm -f ./$(DEPDIR)/fstconcat.Po -rm -f ./$(DEPDIR)/fstconnect-main.Po -rm -f ./$(DEPDIR)/fstconnect.Po -rm -f ./$(DEPDIR)/fstconvert-main.Po -rm -f ./$(DEPDIR)/fstconvert.Po -rm -f ./$(DEPDIR)/fstdeterminize-main.Po -rm -f ./$(DEPDIR)/fstdeterminize.Po -rm -f ./$(DEPDIR)/fstdifference-main.Po -rm -f ./$(DEPDIR)/fstdifference.Po -rm -f ./$(DEPDIR)/fstdisambiguate-main.Po -rm -f ./$(DEPDIR)/fstdisambiguate.Po -rm -f ./$(DEPDIR)/fstdraw-main.Po -rm -f ./$(DEPDIR)/fstdraw.Po -rm -f ./$(DEPDIR)/fstencode-main.Po -rm -f ./$(DEPDIR)/fstencode.Po -rm -f ./$(DEPDIR)/fstepsnormalize-main.Po -rm -f ./$(DEPDIR)/fstepsnormalize.Po -rm -f ./$(DEPDIR)/fstequal-main.Po -rm -f ./$(DEPDIR)/fstequal.Po -rm -f ./$(DEPDIR)/fstequivalent-main.Po -rm -f ./$(DEPDIR)/fstequivalent.Po -rm -f ./$(DEPDIR)/fstinfo-main.Po -rm -f ./$(DEPDIR)/fstinfo.Po -rm -f ./$(DEPDIR)/fstintersect-main.Po -rm -f ./$(DEPDIR)/fstintersect.Po -rm -f ./$(DEPDIR)/fstinvert-main.Po -rm -f ./$(DEPDIR)/fstinvert.Po -rm -f ./$(DEPDIR)/fstisomorphic-main.Po -rm -f ./$(DEPDIR)/fstisomorphic.Po -rm -f ./$(DEPDIR)/fstmap-main.Po -rm -f ./$(DEPDIR)/fstmap.Po -rm -f ./$(DEPDIR)/fstminimize-main.Po -rm -f ./$(DEPDIR)/fstminimize.Po -rm -f ./$(DEPDIR)/fstprint-main.Po -rm -f ./$(DEPDIR)/fstprint.Po -rm -f ./$(DEPDIR)/fstproject-main.Po -rm -f ./$(DEPDIR)/fstproject.Po -rm -f ./$(DEPDIR)/fstprune-main.Po -rm -f ./$(DEPDIR)/fstprune.Po -rm -f ./$(DEPDIR)/fstpush-main.Po -rm -f ./$(DEPDIR)/fstpush.Po -rm -f ./$(DEPDIR)/fstrandgen-main.Po -rm -f ./$(DEPDIR)/fstrandgen.Po -rm -f ./$(DEPDIR)/fstrelabel-main.Po -rm -f ./$(DEPDIR)/fstrelabel.Po -rm -f ./$(DEPDIR)/fstreplace-main.Po -rm -f ./$(DEPDIR)/fstreplace.Po -rm -f ./$(DEPDIR)/fstreverse-main.Po -rm -f ./$(DEPDIR)/fstreverse.Po -rm -f ./$(DEPDIR)/fstreweight-main.Po -rm -f ./$(DEPDIR)/fstreweight.Po -rm -f ./$(DEPDIR)/fstrmepsilon-main.Po -rm -f ./$(DEPDIR)/fstrmepsilon.Po -rm -f ./$(DEPDIR)/fstshortestdistance-main.Po -rm -f ./$(DEPDIR)/fstshortestdistance.Po -rm -f ./$(DEPDIR)/fstshortestpath-main.Po -rm -f ./$(DEPDIR)/fstshortestpath.Po -rm -f ./$(DEPDIR)/fstsymbols-main.Po -rm -f ./$(DEPDIR)/fstsymbols.Po -rm -f ./$(DEPDIR)/fstsynchronize-main.Po -rm -f ./$(DEPDIR)/fstsynchronize.Po -rm -f ./$(DEPDIR)/fsttopsort-main.Po -rm -f ./$(DEPDIR)/fsttopsort.Po -rm -f ./$(DEPDIR)/fstunion-main.Po -rm -f ./$(DEPDIR)/fstunion.Po -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/bin/fstarcsort-main.cc000066400000000000000000000023661421600557100202000ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; const std::string out_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? 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); } openfst-1.7.9/src/bin/fstarcsort.cc000066400000000000000000000005651421600557100172550ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstclosure-main.cc000066400000000000000000000021121421600557100201640ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstclosure.cc000066400000000000000000000005261421600557100172510ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstcompile-main.cc000066400000000000000000000044321421600557100201470ustar00rootroot00000000000000// 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; std::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; } std::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 std::string dest = argc > 2 && strcmp(argv[2], "-") != 0 ? 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; } openfst-1.7.9/src/bin/fstcompile.cc000066400000000000000000000016511421600557100172250ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstcompose-main.cc000066400000000000000000000036531421600557100201700ustar00rootroot00000000000000// 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; std::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 std::string in1_name = strcmp(argv[1], "-") != 0 ? argv[1] : ""; const std::string in2_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? argv[2] : ""; const std::string out_name = (argc > 3 && (strcmp(argv[3], "-") != 0)) ? 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); } openfst-1.7.9/src/bin/fstcompose.cc000066400000000000000000000007371421600557100172460ustar00rootroot00000000000000// 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\", \"no_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); } openfst-1.7.9/src/bin/fstconcat-main.cc000066400000000000000000000024561421600557100177720ustar00rootroot00000000000000// 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; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; const std::string out_name = argc > 3 && strcmp(argv[3], "-") != 0 ? 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); } openfst-1.7.9/src/bin/fstconcat.cc000066400000000000000000000003341421600557100170410ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstconnect-main.cc000066400000000000000000000020771421600557100201530ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? argv[2] : ""; std::unique_ptr fst(MutableFstClass::Read(in_name, true)); if (!fst) return 1; s::Connect(fst.get()); return !fst->Write(out_name); } openfst-1.7.9/src/bin/fstconnect.cc000066400000000000000000000003361421600557100172250ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstconvert-main.cc000066400000000000000000000022041421600557100201720ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } } openfst-1.7.9/src/bin/fstconvert.cc000066400000000000000000000004551421600557100172560ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstdeterminize-main.cc000066400000000000000000000036151421600557100210400ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstdeterminize.cc000066400000000000000000000017221421600557100201130ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstdifference-main.cc000066400000000000000000000035021421600557100206060ustar00rootroot00000000000000// 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; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; const std::string out_name = argc > 3 && strcmp(argv[3], "-") != 0 ? 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); } openfst-1.7.9/src/bin/fstdifference.cc000066400000000000000000000007271421600557100176720ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstdisambiguate-main.cc000066400000000000000000000027421421600557100211570ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstdisambiguate.cc000066400000000000000000000012141421600557100202260ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstdraw-main.cc000066400000000000000000000057371421600557100174650ustar00rootroot00000000000000// 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::SymbolTable; using fst::SymbolTableTextOptions; using fst::script::FstClass; std::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 std::string in_name = argc > 1 && strcmp(argv[1], "-") != 0 ? argv[1] : ""; std::unique_ptr fst(FstClass::Read(in_name)); if (!fst) return 1; const std::string out_name = argc > 2 && strcmp(argv[2], "-") != 0 ? argv[2] : ""; std::ofstream fstrm; if (!out_name.empty()) { fstrm.open(out_name); if (!fstrm) { LOG(ERROR) << argv[0] << ": Open failed, file = " << out_name; return 1; } } 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()); } // "dest" is only used for the name of the file in error messages. const std::string dest = out_name.empty() ? "stdout" : out_name; s::Draw(*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; } openfst-1.7.9/src/bin/fstdraw.cc000066400000000000000000000026631421600557100165360ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstencode-main.cc000066400000000000000000000034631421600557100177570ustar00rootroot00000000000000// 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 #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::EncodeMapperClass; using fst::script::MutableFstClass; std::string usage = "Encodes transducer labels and/or weights.\n\n Usage: "; usage += argv[0]; usage += " in.fst mapper [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 std::string in_name = (strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string mapper_name = argv[2]; const std::string out_name = argc > 3 && strcmp(argv[3], "-") != 0 ? argv[3] : ""; std::unique_ptr fst(MutableFstClass::Read(in_name, true)); if (!fst) return 1; if (FLAGS_decode) { std::unique_ptr mapper( EncodeMapperClass::Read(mapper_name)); s::Decode(fst.get(), *mapper); } else if (FLAGS_encode_reuse) { std::unique_ptr mapper( EncodeMapperClass::Read(mapper_name)); if (!mapper) return 1; s::Encode(fst.get(), mapper.get()); } else { const auto flags = s::GetEncodeFlags(FLAGS_encode_labels, FLAGS_encode_weights); EncodeMapperClass mapper(fst->ArcType(), flags); s::Encode(fst.get(), &mapper); if (!mapper.Write(mapper_name)) return 1; } return !fst->Write(out_name); } openfst-1.7.9/src/bin/fstencode.cc000066400000000000000000000007361421600557100170350ustar00rootroot00000000000000// 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 mapper"); 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); } openfst-1.7.9/src/bin/fstepsnormalize-main.cc000066400000000000000000000022061421600557100212240ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstepsnormalize.cc000066400000000000000000000005031421600557100203000ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstequal-main.cc000066400000000000000000000024301421600557100176220ustar00rootroot00000000000000// 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; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::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; } openfst-1.7.9/src/bin/fstequal.cc000066400000000000000000000005171421600557100167040ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstequivalent-main.cc000066400000000000000000000040671421600557100207000ustar00rootroot00000000000000// 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_uint64(seed); DECLARE_string(select); int fstequivalent_main(int argc, char **argv) { namespace s = fst::script; using fst::RandGenOptions; using fst::script::FstClass; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::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, opts, FLAGS_delta, FLAGS_seed); if (!result) VLOG(1) << "FSTs are not equivalent"; return result ? 0 : 2; } } openfst-1.7.9/src/bin/fstequivalent.cc000066400000000000000000000014231421600557100177470ustar00rootroot00000000000000#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, std::numeric_limits::max(), "Maximum path length"); DEFINE_int32(npath, 1, "Number of paths to generate"); DEFINE_uint64(seed, std::random_device()(), "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); } openfst-1.7.9/src/bin/fstinfo-main.cc000066400000000000000000000021401421600557100174440ustar00rootroot00000000000000// 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(test_properties); DECLARE_bool(fst_verify); int fstinfo_main(int argc, char **argv) { namespace s = fst::script; using fst::script::FstClass; std::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 std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; std::unique_ptr ifst(FstClass::Read(in_name)); if (!ifst) return 1; s::Info(*ifst, FLAGS_test_properties, FLAGS_arc_filter, FLAGS_info_type, FLAGS_fst_verify); return 0; } openfst-1.7.9/src/bin/fstinfo.cc000066400000000000000000000014011421600557100165210ustar00rootroot00000000000000// 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(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); } openfst-1.7.9/src/bin/fstintersect-main.cc000066400000000000000000000034651421600557100205240ustar00rootroot00000000000000// 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::IntersectOptions; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; const std::string out_name = argc > 3 && strcmp(argv[3], "-") != 0 ? 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 IntersectOptions opts(FLAGS_connect, compose_filter); s::Intersect(*ifst1, *ifst2, &ofst, opts); return !ofst.Write(out_name); } openfst-1.7.9/src/bin/fstintersect.cc000066400000000000000000000007251421600557100175760ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstinvert-main.cc000066400000000000000000000017071421600557100200300ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? argv[2] : ""; std::unique_ptr fst(MutableFstClass::Read(in_name, true)); if (!fst) return 1; s::Invert(fst.get()); return !fst->Write(out_name); } openfst-1.7.9/src/bin/fstinvert.cc000066400000000000000000000003341421600557100171010ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstisomorphic-main.cc000066400000000000000000000026441421600557100206760ustar00rootroot00000000000000// 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; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::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; } openfst-1.7.9/src/bin/fstisomorphic.cc000066400000000000000000000005311421600557100177450ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstmap-main.cc000066400000000000000000000032641421600557100172760ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstmap.cc000066400000000000000000000014041421600557100163460ustar00rootroot00000000000000// 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\", " "\"identity\", \"input_epsilon\", \"invert\", \"output_epsilon\", " "\"plus (--weight)\", \"power (--power)\", \"quantize (--delta)\", " "\"rmweight\", \"superfinal\", \"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); } openfst-1.7.9/src/bin/fstminimize-main.cc000066400000000000000000000031431421600557100203360ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out1_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? argv[2] : ""; const std::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); } openfst-1.7.9/src/bin/fstminimize.cc000066400000000000000000000007051421600557100174150ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstprint-main.cc000066400000000000000000000055241421600557100176560ustar00rootroot00000000000000// 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::SymbolTable; using fst::SymbolTableTextOptions; using fst::script::FstClass; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? argv[2] : ""; std::unique_ptr fst(FstClass::Read(in_name)); if (!fst) return 1; std::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::Print(*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; } openfst-1.7.9/src/bin/fstprint.cc000066400000000000000000000017641421600557100167360ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstproject-main.cc000066400000000000000000000025411421600557100201640ustar00rootroot00000000000000// 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_string(project_type); int fstproject_main(int argc, char **argv) { namespace s = fst::script; using fst::ProjectType; using fst::script::MutableFstClass; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? argv[2] : ""; std::unique_ptr fst(MutableFstClass::Read(in_name, true)); if (!fst) return 1; ProjectType project_type; if (!s::GetProjectType(FLAGS_project_type, &project_type)) { LOG(ERROR) << argv[0] << ": Unknown or unsupported project type: " << FLAGS_project_type; return 1; } s::Project(fst.get(), project_type); return !fst->Write(out_name); } openfst-1.7.9/src/bin/fstproject.cc000066400000000000000000000005421421600557100172410ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include DEFINE_string(project_type, "input", "Side to project from, one of: \"input\", \"output\""); int fstproject_main(int argc, char **argv); int main(int argc, char **argv) { return fstproject_main(argc, argv); } openfst-1.7.9/src/bin/fstprune-main.cc000066400000000000000000000024741421600557100176540ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstprune.cc000066400000000000000000000007241421600557100167260ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstpush-main.cc000066400000000000000000000030031421600557100174670ustar00rootroot00000000000000// 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 #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; std::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; } const std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstpush.cc000066400000000000000000000013171421600557100165530ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstrandgen-main.cc000066400000000000000000000034051421600557100201340ustar00rootroot00000000000000// 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_uint64(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::RandGenOptions; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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, RandGenOptions(ras, FLAGS_max_length, FLAGS_npath, FLAGS_weighted, FLAGS_remove_total_weight), FLAGS_seed); return !ofst.Write(out_name); } openfst-1.7.9/src/bin/fstrandgen.cc000066400000000000000000000014151421600557100172110ustar00rootroot00000000000000#include #include #include DEFINE_int32(max_length, std::numeric_limits::max(), "Maximum path length"); DEFINE_int32(npath, 1, "Number of paths to generate"); DEFINE_uint64(seed, std::random_device()(), "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); } openfst-1.7.9/src/bin/fstrelabel-main.cc000066400000000000000000000071411421600557100201250ustar00rootroot00000000000000// 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 #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::ReadLabelPairs; using fst::SymbolTable; using fst::SymbolTableTextOptions; using fst::script::MutableFstClass; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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; if (!FLAGS_relabel_ipairs.empty()) { if (!ReadLabelPairs(FLAGS_relabel_ipairs, &ipairs, FLAGS_allow_negative_labels)) return 1; } std::vector> opairs; if (!FLAGS_relabel_opairs.empty()) { if (!ReadLabelPairs(FLAGS_relabel_opairs, &opairs, FLAGS_allow_negative_labels)) return 1; } s::Relabel(fst.get(), ipairs, opairs); } return !fst->Write(out_name); } openfst-1.7.9/src/bin/fstrelabel.cc000066400000000000000000000017351421600557100172060ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstreplace-main.cc000066400000000000000000000056121421600557100201330ustar00rootroot00000000000000// 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 #include #include DECLARE_string(call_arc_labeling); DECLARE_string(return_arc_labeling); DECLARE_int64(return_label); DECLARE_bool(epsilon_on_replace); namespace fst { namespace script { namespace { void Cleanup(std::vector> *pairs) { for (const auto &pair : *pairs) delete pair.second; pairs->clear(); } } // namespace } // namespace script } // namespace fst int fstreplace_main(int argc, char **argv) { namespace s = fst::script; using fst::ReplaceLabelType; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in_name = argv[1]; const std::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) { s::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); s::Cleanup(&pairs); return !ofst.Write(out_name); } openfst-1.7.9/src/bin/fstreplace.cc000066400000000000000000000014041421600557100172040ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstreverse-main.cc000066400000000000000000000021611421600557100201670ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstreverse.cc000066400000000000000000000005061421600557100172460ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstreweight-main.cc000066400000000000000000000023571421600557100203410ustar00rootroot00000000000000// 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; std::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 std::string in_name = argv[1]; const std::string potentials_name = argv[2]; const std::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); } openfst-1.7.9/src/bin/fstreweight.cc000066400000000000000000000005111421600557100174050ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstrmepsilon-main.cc000066400000000000000000000033221421600557100205240ustar00rootroot00000000000000// 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::QueueType; using fst::script::MutableFstClass; using fst::script::WeightClass; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); 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); } openfst-1.7.9/src/bin/fstrmepsilon.cc000066400000000000000000000013111421600557100175760ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstshortestdistance-main.cc000066400000000000000000000036501421600557100221060ustar00rootroot00000000000000// 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::AUTO_QUEUE; using fst::QueueType; using fst::script::FstClass; using fst::script::WeightClass; std::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; } const std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstshortestdistance.cc000066400000000000000000000012761421600557100211660ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstshortestpath-main.cc000066400000000000000000000035461421600557100212540ustar00rootroot00000000000000// 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::QueueType; using fst::script::FstClass; using fst::script::VectorFstClass; using fst::script::WeightClass; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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()); 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); } openfst-1.7.9/src/bin/fstshortestpath.cc000066400000000000000000000014201421600557100203170ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstsymbols-main.cc000066400000000000000000000065131421600557100202110ustar00rootroot00000000000000// 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 #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::ReadLabelPairs; using fst::SymbolTable; using fst::SymbolTableTextOptions; using fst::script::MutableFstClass; std::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 std::string in_name = argc > 1 && strcmp(argv[1], "-") != 0 ? argv[1] : ""; const std::string out_name = argc > 2 && strcmp(argv[2], "-") != 0 ? 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); } openfst-1.7.9/src/bin/fstsymbols.cc000066400000000000000000000017201421600557100172620ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstsynchronize-main.cc000066400000000000000000000020101421600557100210600ustar00rootroot00000000000000// 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; std::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 std::string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : ""; const std::string out_name = (argc > 2 && strcmp(argv[2], "-") != 0) ? 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); } openfst-1.7.9/src/bin/fstsynchronize.cc000066400000000000000000000003461421600557100201500ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fsttopsort-main.cc000066400000000000000000000020671421600557100202330ustar00rootroot00000000000000// 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; std::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 std::string in_name = argc > 1 && strcmp(argv[1], "-") != 0 ? argv[1] : ""; const std::string out_name = argc > 2 && strcmp(argv[2], "-") != 0 ? argv[2] : ""; std::unique_ptr fst(MutableFstClass::Read(in_name, true)); if (!fst) return 1; bool acyclic = s::TopSort(fst.get()); if (!acyclic) LOG(WARNING) << argv[0] << ": Input FST is cyclic"; return !fst->Write(out_name); } openfst-1.7.9/src/bin/fsttopsort.cc000066400000000000000000000003361421600557100173060ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/bin/fstunion-main.cc000066400000000000000000000024731421600557100176520ustar00rootroot00000000000000// 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; std::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 std::string in1_name = strcmp(argv[1], "-") != 0 ? argv[1] : ""; const std::string in2_name = strcmp(argv[2], "-") != 0 ? argv[2] : ""; const std::string out_name = argc > 3 && strcmp(argv[3], "-") != 0 ? 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::Union(fst1.get(), *fst2); return !fst1->Write(out_name); } openfst-1.7.9/src/bin/fstunion.cc000066400000000000000000000003321421600557100167200ustar00rootroot00000000000000// 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); } openfst-1.7.9/src/extensions/000077500000000000000000000000001421600557100161755ustar00rootroot00000000000000openfst-1.7.9/src/extensions/Makefile.am000066400000000000000000000014741421600557100202370ustar00rootroot00000000000000if 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_FSTS compactdir = compact constdir = const lineardir = linear lookaheaddir = lookahead ngramdir = ngram 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) openfst-1.7.9/src/extensions/Makefile.in000066400000000000000000000471461421600557100202560ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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 distdir-am 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 am__DIST_COMMON = $(srcdir)/Makefile.in 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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_FSTS_TRUE@compactdir = compact @HAVE_COMPRESS_TRUE@compressdir = compress @HAVE_CONST_TRUE@constdir = const @HAVE_FSTS_TRUE@constdir = const @HAVE_FAR_TRUE@fardir = far @HAVE_GRM_TRUE@fardir = far @HAVE_PYTHON_TRUE@fardir = far @HAVE_FSTS_TRUE@lineardir = linear @HAVE_LINEAR_TRUE@lineardir = linear @HAVE_FSTS_TRUE@lookaheaddir = lookahead @HAVE_LOOKAHEAD_TRUE@lookaheaddir = lookahead @HAVE_FSTS_TRUE@ngramdir = ngram @HAVE_NGRAM_TRUE@ngramdir = ngram @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_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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/compact/000077500000000000000000000000001421600557100176235ustar00rootroot00000000000000openfst-1.7.9/src/extensions/compact/Makefile.am000066400000000000000000000060471421600557100216660ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) LIBS = ../../lib/libfst.la -lm $(DL_LIBS) 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 22:0:0 compact8_acceptor_fst_la_SOURCES = compact8_acceptor-fst.cc compact8_acceptor_fst_la_LDFLAGS = -avoid-version -module compact8_string_fst_la_SOURCES = compact8_string-fst.cc compact8_string_fst_la_LDFLAGS = -avoid-version -module compact8_unweighted_fst_la_SOURCES = compact8_unweighted-fst.cc compact8_unweighted_fst_la_LDFLAGS = -avoid-version -module compact8_unweighted_acceptor_fst_la_SOURCES = compact8_unweighted_acceptor-fst.cc compact8_unweighted_acceptor_fst_la_LDFLAGS = -avoid-version -module compact8_weighted_string_fst_la_SOURCES = compact8_weighted_string-fst.cc compact8_weighted_string_fst_la_LDFLAGS = -avoid-version -module compact16_acceptor_fst_la_SOURCES = compact16_acceptor-fst.cc compact16_acceptor_fst_la_LDFLAGS = -avoid-version -module compact16_string_fst_la_SOURCES = compact16_string-fst.cc compact16_string_fst_la_LDFLAGS = -avoid-version -module compact16_unweighted_fst_la_SOURCES = compact16_unweighted-fst.cc compact16_unweighted_fst_la_LDFLAGS = -avoid-version -module compact16_unweighted_acceptor_fst_la_SOURCES = compact16_unweighted_acceptor-fst.cc compact16_unweighted_acceptor_fst_la_LDFLAGS = -avoid-version -module compact16_weighted_string_fst_la_SOURCES = compact16_weighted_string-fst.cc compact16_weighted_string_fst_la_LDFLAGS = -avoid-version -module compact64_acceptor_fst_la_SOURCES = compact64_acceptor-fst.cc compact64_acceptor_fst_la_LDFLAGS = -avoid-version -module compact64_string_fst_la_SOURCES = compact64_string-fst.cc compact64_string_fst_la_LDFLAGS = -avoid-version -module compact64_unweighted_fst_la_SOURCES = compact64_unweighted-fst.cc compact64_unweighted_fst_la_LDFLAGS = -avoid-version -module compact64_unweighted_acceptor_fst_la_SOURCES = compact64_unweighted_acceptor-fst.cc compact64_unweighted_acceptor_fst_la_LDFLAGS = -avoid-version -module compact64_weighted_string_fst_la_SOURCES = compact64_weighted_string-fst.cc compact64_weighted_string_fst_la_LDFLAGS = -avoid-version -module openfst-1.7.9/src/extensions/compact/Makefile.in000066400000000000000000001231231421600557100216720ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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 $@ libfstcompact_la_LIBADD = 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/compact16_acceptor-fst.Plo \ ./$(DEPDIR)/compact16_string-fst.Plo \ ./$(DEPDIR)/compact16_unweighted-fst.Plo \ ./$(DEPDIR)/compact16_unweighted_acceptor-fst.Plo \ ./$(DEPDIR)/compact16_weighted_string-fst.Plo \ ./$(DEPDIR)/compact64_acceptor-fst.Plo \ ./$(DEPDIR)/compact64_string-fst.Plo \ ./$(DEPDIR)/compact64_unweighted-fst.Plo \ ./$(DEPDIR)/compact64_unweighted_acceptor-fst.Plo \ ./$(DEPDIR)/compact64_weighted_string-fst.Plo \ ./$(DEPDIR)/compact8_acceptor-fst.Plo \ ./$(DEPDIR)/compact8_string-fst.Plo \ ./$(DEPDIR)/compact8_unweighted-fst.Plo \ ./$(DEPDIR)/compact8_unweighted_acceptor-fst.Plo \ ./$(DEPDIR)/compact8_weighted_string-fst.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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 = ../../lib/libfst.la -lm $(DL_LIBS) LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 22:0:0 compact8_acceptor_fst_la_SOURCES = compact8_acceptor-fst.cc compact8_acceptor_fst_la_LDFLAGS = -avoid-version -module compact8_string_fst_la_SOURCES = compact8_string-fst.cc compact8_string_fst_la_LDFLAGS = -avoid-version -module compact8_unweighted_fst_la_SOURCES = compact8_unweighted-fst.cc compact8_unweighted_fst_la_LDFLAGS = -avoid-version -module compact8_unweighted_acceptor_fst_la_SOURCES = compact8_unweighted_acceptor-fst.cc compact8_unweighted_acceptor_fst_la_LDFLAGS = -avoid-version -module compact8_weighted_string_fst_la_SOURCES = compact8_weighted_string-fst.cc compact8_weighted_string_fst_la_LDFLAGS = -avoid-version -module compact16_acceptor_fst_la_SOURCES = compact16_acceptor-fst.cc compact16_acceptor_fst_la_LDFLAGS = -avoid-version -module compact16_string_fst_la_SOURCES = compact16_string-fst.cc compact16_string_fst_la_LDFLAGS = -avoid-version -module compact16_unweighted_fst_la_SOURCES = compact16_unweighted-fst.cc compact16_unweighted_fst_la_LDFLAGS = -avoid-version -module compact16_unweighted_acceptor_fst_la_SOURCES = compact16_unweighted_acceptor-fst.cc compact16_unweighted_acceptor_fst_la_LDFLAGS = -avoid-version -module compact16_weighted_string_fst_la_SOURCES = compact16_weighted_string-fst.cc compact16_weighted_string_fst_la_LDFLAGS = -avoid-version -module compact64_acceptor_fst_la_SOURCES = compact64_acceptor-fst.cc compact64_acceptor_fst_la_LDFLAGS = -avoid-version -module compact64_string_fst_la_SOURCES = compact64_string-fst.cc compact64_string_fst_la_LDFLAGS = -avoid-version -module compact64_unweighted_fst_la_SOURCES = compact64_unweighted-fst.cc compact64_unweighted_fst_la_LDFLAGS = -avoid-version -module compact64_unweighted_acceptor_fst_la_SOURCES = compact64_unweighted_acceptor-fst.cc compact64_unweighted_acceptor_fst_la_LDFLAGS = -avoid-version -module compact64_weighted_string_fst_la_SOURCES = compact64_weighted_string-fst.cc compact64_weighted_string_fst_la_LDFLAGS = -avoid-version -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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_string-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_unweighted-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_unweighted_acceptor-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_weighted_string-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_acceptor-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_string-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_unweighted-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_unweighted_acceptor-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_weighted_string-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_acceptor-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_string-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_unweighted-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_unweighted_acceptor-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_weighted_string-fst.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/compact16_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact16_string-fst.Plo -rm -f ./$(DEPDIR)/compact16_unweighted-fst.Plo -rm -f ./$(DEPDIR)/compact16_unweighted_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact16_weighted_string-fst.Plo -rm -f ./$(DEPDIR)/compact64_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact64_string-fst.Plo -rm -f ./$(DEPDIR)/compact64_unweighted-fst.Plo -rm -f ./$(DEPDIR)/compact64_unweighted_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact64_weighted_string-fst.Plo -rm -f ./$(DEPDIR)/compact8_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact8_string-fst.Plo -rm -f ./$(DEPDIR)/compact8_unweighted-fst.Plo -rm -f ./$(DEPDIR)/compact8_unweighted_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact8_weighted_string-fst.Plo -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 -f ./$(DEPDIR)/compact16_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact16_string-fst.Plo -rm -f ./$(DEPDIR)/compact16_unweighted-fst.Plo -rm -f ./$(DEPDIR)/compact16_unweighted_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact16_weighted_string-fst.Plo -rm -f ./$(DEPDIR)/compact64_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact64_string-fst.Plo -rm -f ./$(DEPDIR)/compact64_unweighted-fst.Plo -rm -f ./$(DEPDIR)/compact64_unweighted_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact64_weighted_string-fst.Plo -rm -f ./$(DEPDIR)/compact8_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact8_string-fst.Plo -rm -f ./$(DEPDIR)/compact8_unweighted-fst.Plo -rm -f ./$(DEPDIR)/compact8_unweighted_acceptor-fst.Plo -rm -f ./$(DEPDIR)/compact8_weighted_string-fst.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/compact/compact16_acceptor-fst.cc000066400000000000000000000010061421600557100243760ustar00rootroot00000000000000// 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; static FstRegisterer> CompactAcceptorFst_Log64Arc_uint16_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact16_string-fst.cc000066400000000000000000000007721421600557100241150ustar00rootroot00000000000000// 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; static FstRegisterer> CompactStringFst_Log64Arc_uint16_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact16_unweighted-fst.cc000066400000000000000000000010221421600557100247370ustar00rootroot00000000000000// 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; static FstRegisterer> CompactUnweightedFst_Log64Arc_uint16_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact16_unweighted_acceptor-fst.cc000066400000000000000000000011021421600557100266160ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { static FstRegisterer> CompactUnweightedAcceptorFst_StdArc_uint16_registerer; static FstRegisterer> CompactUnweightedAcceptorFst_LogArc_uint16_registerer; static FstRegisterer> CompactUnweightedAcceptorFst_Log64Arc_uint16_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact16_weighted_string-fst.cc000066400000000000000000000010521421600557100257650ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { static FstRegisterer> CompactWeightedStringFst_StdArc_uint16_registerer; static FstRegisterer> CompactWeightedStringFst_LogArc_uint16_registerer; static FstRegisterer> CompactWeightedStringFst_Log64Arc_uint16_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact64_acceptor-fst.cc000066400000000000000000000010061421600557100244010ustar00rootroot00000000000000// 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; static FstRegisterer> CompactAcceptorFst_Log64Arc_uint64_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact64_string-fst.cc000066400000000000000000000007721421600557100241200ustar00rootroot00000000000000// 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; static FstRegisterer> CompactStringFst_Log64Arc_uint64_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact64_unweighted-fst.cc000066400000000000000000000010221421600557100247420ustar00rootroot00000000000000// 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; static FstRegisterer> CompactUnweightedFst_Log64Arc_uint64_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact64_unweighted_acceptor-fst.cc000066400000000000000000000011021421600557100266210ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { static FstRegisterer> CompactUnweightedAcceptorFst_StdArc_uint64_registerer; static FstRegisterer> CompactUnweightedAcceptorFst_LogArc_uint64_registerer; static FstRegisterer> CompactUnweightedAcceptorFst_Log64Arc_uint64_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact64_weighted_string-fst.cc000066400000000000000000000010521421600557100257700ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { static FstRegisterer> CompactWeightedStringFst_StdArc_uint64_registerer; static FstRegisterer> CompactWeightedStringFst_LogArc_uint64_registerer; static FstRegisterer> CompactWeightedStringFst_Log64Arc_uint64_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact8_acceptor-fst.cc000066400000000000000000000010001421600557100243110ustar00rootroot00000000000000// 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; static FstRegisterer> CompactAcceptorFst_Log64Arc_uint8_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact8_string-fst.cc000066400000000000000000000007641421600557100240370ustar00rootroot00000000000000// 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; static FstRegisterer> CompactStringFst_Log64Arc_uint8_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact8_unweighted-fst.cc000066400000000000000000000010141421600557100246610ustar00rootroot00000000000000// 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; static FstRegisterer> CompactUnweightedFst_Log64Arc_uint8_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact8_unweighted_acceptor-fst.cc000066400000000000000000000010741421600557100265470ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { static FstRegisterer> CompactUnweightedAcceptorFst_StdArc_uint8_registerer; static FstRegisterer> CompactUnweightedAcceptorFst_LogArc_uint8_registerer; static FstRegisterer> CompactUnweightedAcceptorFst_Log64Arc_uint8_registerer; } // namespace fst openfst-1.7.9/src/extensions/compact/compact8_weighted_string-fst.cc000066400000000000000000000010441421600557100257070ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { static FstRegisterer> CompactWeightedStringFst_StdArc_uint8_registerer; static FstRegisterer> CompactWeightedStringFst_LogArc_uint8_registerer; static FstRegisterer> CompactWeightedStringFst_Log64Arc_uint8_registerer; } // namespace fst openfst-1.7.9/src/extensions/compress/000077500000000000000000000000001421600557100200305ustar00rootroot00000000000000openfst-1.7.9/src/extensions/compress/Makefile.am000066400000000000000000000012071421600557100220640ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) if HAVE_BIN bin_PROGRAMS = fstcompress LDADD = libfstcompressscript.la \ ../../script/libfstscript.la \ ../../lib/libfst.la \ -lm $(DL_LIBS) fstcompress_SOURCES = fstcompress.cc fstcompress-main.cc endif if HAVE_SCRIPT libfstcompressscript_la_SOURCES = compressscript.cc libfstcompressscript_la_LDFLAGS = -version-info 22:0:0 libfstcompressscript_la_LIBADD = ../../script/libfstscript.la \ ../../lib/libfst.la \ -lm $(DL_LIBS) endif if HAVE_SCRIPT lib_LTLIBRARIES = libfstcompressscript.la endif openfst-1.7.9/src/extensions/compress/Makefile.in000066400000000000000000000625341421600557100221070ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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) subdir = src/extensions/compress ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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)" "$(DESTDIR)$(libdir)" PROGRAMS = $(bin_PROGRAMS) 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; }; \ } 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 = compressscript.cc @HAVE_SCRIPT_TRUE@am_libfstcompressscript_la_OBJECTS = \ @HAVE_SCRIPT_TRUE@ compressscript.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) am__fstcompress_SOURCES_DIST = fstcompress.cc fstcompress-main.cc @HAVE_BIN_TRUE@am_fstcompress_OBJECTS = fstcompress.$(OBJEXT) \ @HAVE_BIN_TRUE@ fstcompress-main.$(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_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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/compressscript.Plo \ ./$(DEPDIR)/fstcompress-main.Po ./$(DEPDIR)/fstcompress.Po 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) DIST_SOURCES = $(am__libfstcompressscript_la_SOURCES_DIST) \ $(am__fstcompress_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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 fstcompress-main.cc @HAVE_SCRIPT_TRUE@libfstcompressscript_la_SOURCES = compressscript.cc @HAVE_SCRIPT_TRUE@libfstcompressscript_la_LDFLAGS = -version-info 22:0:0 @HAVE_SCRIPT_TRUE@libfstcompressscript_la_LIBADD = ../../script/libfstscript.la \ @HAVE_SCRIPT_TRUE@ ../../lib/libfst.la \ @HAVE_SCRIPT_TRUE@ -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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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 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) fstcompress$(EXEEXT): $(fstcompress_OBJECTS) $(fstcompress_DEPENDENCIES) $(EXTRA_fstcompress_DEPENDENCIES) @rm -f fstcompress$(EXEEXT) $(AM_V_CXXLD)$(CXXLINK) $(fstcompress_OBJECTS) $(fstcompress_LDADD) $(LIBS) mostlyclean-compile: -rm -f *.$(OBJEXT) distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compressscript.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompress-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompress.Po@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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) $(LTLIBRARIES) install-binPROGRAMS: install-libLTLIBRARIES installdirs: for dir in "$(DESTDIR)$(bindir)" "$(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-binPROGRAMS clean-generic clean-libLTLIBRARIES \ clean-libtool mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/compressscript.Plo -rm -f ./$(DEPDIR)/fstcompress-main.Po -rm -f ./$(DEPDIR)/fstcompress.Po -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 -f ./$(DEPDIR)/compressscript.Plo -rm -f ./$(DEPDIR)/fstcompress-main.Po -rm -f ./$(DEPDIR)/fstcompress.Po -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/compress/compressscript.cc000066400000000000000000000015531421600557100234230ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #include namespace fst { namespace script { bool Compress(const FstClass &fst, const std::string &source) { CompressInnerArgs iargs(fst, source); CompressArgs args(iargs); Apply>("Compress", fst.ArcType(), &args); return args.retval; } REGISTER_FST_OPERATION_3ARCS(Compress, CompressArgs); bool Decompress(const std::string &source, MutableFstClass *fst) { DecompressInnerArgs iargs(source, fst); DecompressArgs args(iargs); Apply>("Decompress", fst->ArcType(), &args); return args.retval; } REGISTER_FST_OPERATION_3ARCS(Decompress, DecompressArgs); } // namespace script } // namespace fst openfst-1.7.9/src/extensions/compress/fstcompress-main.cc000066400000000000000000000027211421600557100236330ustar00rootroot00000000000000// 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 #include DECLARE_string(arc_type); DECLARE_bool(decode); int fstcompress_main(int argc, char **argv) { namespace s = fst::script; using fst::script::FstClass; using fst::script::VectorFstClass; std::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; } const std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; const std::string out_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? argv[2] : ""; if (FLAGS_decode) { VectorFstClass fst(FLAGS_arc_type); if (!s::Decompress(in_name, &fst)) { FSTERROR() << "Decompression failed"; return 1; } return !fst.Write(out_name); } else { std::unique_ptr ifst(FstClass::Read(in_name)); if (!ifst) return 1; if (!s::Compress(*ifst, out_name)) { FSTERROR() << "Compression failed"; return 1; } return 0; } } openfst-1.7.9/src/extensions/compress/fstcompress.cc000066400000000000000000000005271421600557100227130ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include DEFINE_string(arc_type, "standard", "Output arc type"); DEFINE_bool(decode, false, "Decode"); int fstcompress_main(int argc, char **argv); int main(int argc, char **argv) { return fstcompress_main(argc, argv); } openfst-1.7.9/src/extensions/const/000077500000000000000000000000001421600557100173235ustar00rootroot00000000000000openfst-1.7.9/src/extensions/const/Makefile.am000066400000000000000000000011321421600557100213540ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) LIBS = ../../lib/libfst.la -lm $(DL_LIBS) 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 22:0:0 const8_fst_la_SOURCES = const8-fst.cc const8_fst_la_LDFLAGS = -avoid-version -module const16_fst_la_SOURCES = const16-fst.cc const16_fst_la_LDFLAGS = -avoid-version -module const64_fst_la_SOURCES = const64-fst.cc const64_fst_la_LDFLAGS = -avoid-version -module openfst-1.7.9/src/extensions/const/Makefile.in000066400000000000000000000621071421600557100213760ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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 $@ libfstconst_la_LIBADD = 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/const16-fst.Plo \ ./$(DEPDIR)/const64-fst.Plo ./$(DEPDIR)/const8-fst.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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 = ../../lib/libfst.la -lm $(DL_LIBS) LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 22:0:0 const8_fst_la_SOURCES = const8-fst.cc const8_fst_la_LDFLAGS = -avoid-version -module const16_fst_la_SOURCES = const16-fst.cc const16_fst_la_LDFLAGS = -avoid-version -module const64_fst_la_SOURCES = const64-fst.cc const64_fst_la_LDFLAGS = -avoid-version -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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const64-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const8-fst.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/const16-fst.Plo -rm -f ./$(DEPDIR)/const64-fst.Plo -rm -f ./$(DEPDIR)/const8-fst.Plo -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 -f ./$(DEPDIR)/const16-fst.Plo -rm -f ./$(DEPDIR)/const64-fst.Plo -rm -f ./$(DEPDIR)/const8-fst.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/const/const16-fst.cc000066400000000000000000000007061421600557100217240ustar00rootroot00000000000000// 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 openfst-1.7.9/src/extensions/const/const64-fst.cc000066400000000000000000000007061421600557100217270ustar00rootroot00000000000000// 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 openfst-1.7.9/src/extensions/const/const8-fst.cc000066400000000000000000000006701421600557100216450ustar00rootroot00000000000000// 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 openfst-1.7.9/src/extensions/far/000077500000000000000000000000001421600557100167455ustar00rootroot00000000000000openfst-1.7.9/src/extensions/far/Makefile.am000066400000000000000000000024071421600557100210040ustar00rootroot00000000000000AM_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 22: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 sttable.cc stlist.cc libfstfarscript_la_LDFLAGS = -version-info 22: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 farcompilestrings-main.cc farcreate_SOURCES = farcreate.cc farcreate-main.cc farequal_SOURCES = farequal.cc farequal-main.cc farextract_SOURCES = farextract.cc farextract-main.cc farinfo_SOURCES = farinfo.cc farinfo-main.cc farisomorphic_SOURCES = farisomorphic.cc farisomorphic-main.cc farprintstrings_SOURCES = farprintstrings.cc farprintstrings-main.cc endif openfst-1.7.9/src/extensions/far/Makefile.in000066400000000000000000001050311421600557100210120ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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)" "$(DESTDIR)$(libdir)" PROGRAMS = $(bin_PROGRAMS) 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; }; \ } 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 sttable.cc stlist.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 sttable.lo stlist.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) am__farcompilestrings_SOURCES_DIST = farcompilestrings.cc \ farcompilestrings-main.cc @HAVE_BIN_TRUE@am_farcompilestrings_OBJECTS = \ @HAVE_BIN_TRUE@ farcompilestrings.$(OBJEXT) \ @HAVE_BIN_TRUE@ farcompilestrings-main.$(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 farcreate-main.cc @HAVE_BIN_TRUE@am_farcreate_OBJECTS = farcreate.$(OBJEXT) \ @HAVE_BIN_TRUE@ farcreate-main.$(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 farequal-main.cc @HAVE_BIN_TRUE@am_farequal_OBJECTS = farequal.$(OBJEXT) \ @HAVE_BIN_TRUE@ farequal-main.$(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 farextract-main.cc @HAVE_BIN_TRUE@am_farextract_OBJECTS = farextract.$(OBJEXT) \ @HAVE_BIN_TRUE@ farextract-main.$(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 farinfo-main.cc @HAVE_BIN_TRUE@am_farinfo_OBJECTS = farinfo.$(OBJEXT) \ @HAVE_BIN_TRUE@ farinfo-main.$(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 \ farisomorphic-main.cc @HAVE_BIN_TRUE@am_farisomorphic_OBJECTS = farisomorphic.$(OBJEXT) \ @HAVE_BIN_TRUE@ farisomorphic-main.$(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 \ farprintstrings-main.cc @HAVE_BIN_TRUE@am_farprintstrings_OBJECTS = farprintstrings.$(OBJEXT) \ @HAVE_BIN_TRUE@ farprintstrings-main.$(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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/far-class.Plo \ ./$(DEPDIR)/farcompilestrings-main.Po \ ./$(DEPDIR)/farcompilestrings.Po ./$(DEPDIR)/farcreate-main.Po \ ./$(DEPDIR)/farcreate.Po ./$(DEPDIR)/farequal-main.Po \ ./$(DEPDIR)/farequal.Po ./$(DEPDIR)/farextract-main.Po \ ./$(DEPDIR)/farextract.Po ./$(DEPDIR)/farinfo-main.Po \ ./$(DEPDIR)/farinfo.Po ./$(DEPDIR)/farisomorphic-main.Po \ ./$(DEPDIR)/farisomorphic.Po \ ./$(DEPDIR)/farprintstrings-main.Po \ ./$(DEPDIR)/farprintstrings.Po ./$(DEPDIR)/farscript.Plo \ ./$(DEPDIR)/getters.Plo ./$(DEPDIR)/script-impl.Plo \ ./$(DEPDIR)/stlist.Plo ./$(DEPDIR)/strings.Plo \ ./$(DEPDIR)/sttable.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 22: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 sttable.cc stlist.cc @HAVE_SCRIPT_TRUE@libfstfarscript_la_LDFLAGS = -version-info 22: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 farcompilestrings-main.cc @HAVE_BIN_TRUE@farcreate_SOURCES = farcreate.cc farcreate-main.cc @HAVE_BIN_TRUE@farequal_SOURCES = farequal.cc farequal-main.cc @HAVE_BIN_TRUE@farextract_SOURCES = farextract.cc farextract-main.cc @HAVE_BIN_TRUE@farinfo_SOURCES = farinfo.cc farinfo-main.cc @HAVE_BIN_TRUE@farisomorphic_SOURCES = farisomorphic.cc farisomorphic-main.cc @HAVE_BIN_TRUE@farprintstrings_SOURCES = farprintstrings.cc farprintstrings-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/extensions/far/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign src/extensions/far/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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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 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) 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcompilestrings-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcompilestrings.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcreate-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcreate.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farequal-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farequal.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farextract-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farextract.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farinfo-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farinfo.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farisomorphic-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farisomorphic.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farprintstrings-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farprintstrings.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farscript.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/script-impl.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stlist.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/strings.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sttable.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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) $(LTLIBRARIES) install-binPROGRAMS: install-libLTLIBRARIES installdirs: for dir in "$(DESTDIR)$(bindir)" "$(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-binPROGRAMS clean-generic clean-libLTLIBRARIES \ clean-libtool mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/far-class.Plo -rm -f ./$(DEPDIR)/farcompilestrings-main.Po -rm -f ./$(DEPDIR)/farcompilestrings.Po -rm -f ./$(DEPDIR)/farcreate-main.Po -rm -f ./$(DEPDIR)/farcreate.Po -rm -f ./$(DEPDIR)/farequal-main.Po -rm -f ./$(DEPDIR)/farequal.Po -rm -f ./$(DEPDIR)/farextract-main.Po -rm -f ./$(DEPDIR)/farextract.Po -rm -f ./$(DEPDIR)/farinfo-main.Po -rm -f ./$(DEPDIR)/farinfo.Po -rm -f ./$(DEPDIR)/farisomorphic-main.Po -rm -f ./$(DEPDIR)/farisomorphic.Po -rm -f ./$(DEPDIR)/farprintstrings-main.Po -rm -f ./$(DEPDIR)/farprintstrings.Po -rm -f ./$(DEPDIR)/farscript.Plo -rm -f ./$(DEPDIR)/getters.Plo -rm -f ./$(DEPDIR)/script-impl.Plo -rm -f ./$(DEPDIR)/stlist.Plo -rm -f ./$(DEPDIR)/strings.Plo -rm -f ./$(DEPDIR)/sttable.Plo -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 -f ./$(DEPDIR)/far-class.Plo -rm -f ./$(DEPDIR)/farcompilestrings-main.Po -rm -f ./$(DEPDIR)/farcompilestrings.Po -rm -f ./$(DEPDIR)/farcreate-main.Po -rm -f ./$(DEPDIR)/farcreate.Po -rm -f ./$(DEPDIR)/farequal-main.Po -rm -f ./$(DEPDIR)/farequal.Po -rm -f ./$(DEPDIR)/farextract-main.Po -rm -f ./$(DEPDIR)/farextract.Po -rm -f ./$(DEPDIR)/farinfo-main.Po -rm -f ./$(DEPDIR)/farinfo.Po -rm -f ./$(DEPDIR)/farisomorphic-main.Po -rm -f ./$(DEPDIR)/farisomorphic.Po -rm -f ./$(DEPDIR)/farprintstrings-main.Po -rm -f ./$(DEPDIR)/farprintstrings.Po -rm -f ./$(DEPDIR)/farscript.Plo -rm -f ./$(DEPDIR)/getters.Plo -rm -f ./$(DEPDIR)/script-impl.Plo -rm -f ./$(DEPDIR)/stlist.Plo -rm -f ./$(DEPDIR)/strings.Plo -rm -f ./$(DEPDIR)/sttable.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/far/far-class.cc000066400000000000000000000036701421600557100211350ustar00rootroot00000000000000// 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 std::string &source) { const std::vector sources{source}; return FarReaderClass::Open(sources); } FarReaderClass *FarReaderClass::Open(const std::vector &sources) { if (sources.empty()) { LOG(ERROR) << "FarReaderClass::Open: No files specified"; return nullptr; } const auto arc_type = LoadArcTypeFromFar(sources.front()); if (arc_type.empty()) return nullptr; OpenFarReaderClassArgs args(sources); args.retval = nullptr; Apply>("OpenFarReaderClass", arc_type, &args); return args.retval; } REGISTER_FST_OPERATION(OpenFarReaderClass, StdArc, OpenFarReaderClassArgs); REGISTER_FST_OPERATION(OpenFarReaderClass, LogArc, OpenFarReaderClassArgs); REGISTER_FST_OPERATION(OpenFarReaderClass, Log64Arc, OpenFarReaderClassArgs); // FarWriterClass. FarWriterClass *FarWriterClass::Create(const std::string &source, const std::string &arc_type, FarType type) { CreateFarWriterClassInnerArgs iargs(source, 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 openfst-1.7.9/src/extensions/far/farcompilestrings-main.cc000066400000000000000000000056441421600557100237420ustar00rootroot00000000000000// 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 DECLARE_string(key_prefix); DECLARE_string(key_suffix); DECLARE_int32(generate_keys); DECLARE_string(far_type); DECLARE_bool(allow_negative_labels); DECLARE_string(arc_type); DECLARE_string(entry_type); DECLARE_string(fst_type); DECLARE_string(token_type); DECLARE_string(symbols); DECLARE_string(unknown_symbol); DECLARE_bool(file_list_input); DECLARE_bool(keep_symbols); DECLARE_bool(initial_symbols); int farcompilestrings_main(int argc, char **argv) { namespace s = fst::script; std::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_sources; if (FLAGS_file_list_input) { for (int i = 1; i < argc - 1; ++i) { std::ifstream istrm(argv[i]); std::string str; while (std::getline(istrm, str)) in_sources.push_back(str); } } else { for (int i = 1; i < argc - 1; ++i) in_sources.push_back(strcmp(argv[i], "-") != 0 ? argv[i] : ""); } if (in_sources.empty()) { // argc == 1 || argc == 2. This cleverly handles both the no-file case // and the one (input) file case together. // TODO(jrosenstock): This probably shouldn't happen for the // --file_list_input case. in_sources.push_back(argc == 2 && strcmp(argv[1], "-") != 0 ? argv[1] : ""); } // argc <= 2 means the file (if any) is an input file, so write to stdout. const std::string out_source = 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::TokenType token_type; if (!s::GetTokenType(FLAGS_token_type, &token_type)) { LOG(ERROR) << "Unknown or unsupported FAR token type: " << FLAGS_token_type; return 1; } fst::FarType far_type; if (!s::GetFarType(FLAGS_far_type, &far_type)) { LOG(ERROR) << "Unknown or unsupported FAR type: " << FLAGS_far_type; return 1; } s::FarCompileStrings(in_sources, out_source, 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; } openfst-1.7.9/src/extensions/far/farcompilestrings.cc000066400000000000000000000027231421600557100230130ustar00rootroot00000000000000#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. Only applies to \"symbol\" tokens."); 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 farcompilestrings_main(int argc, char **argv); int main(int argc, char **argv) { return farcompilestrings_main(argc, argv); } openfst-1.7.9/src/extensions/far/farcreate-main.cc000066400000000000000000000041231421600557100221320ustar00rootroot00000000000000// 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 DECLARE_string(key_prefix); DECLARE_string(key_suffix); DECLARE_int32(generate_keys); DECLARE_string(far_type); DECLARE_bool(file_list_input); int farcreate_main(int argc, char **argv) { namespace s = fst::script; std::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_sources; if (FLAGS_file_list_input) { for (int i = 1; i < argc - 1; ++i) { std::ifstream istrm(argv[i]); std::string str; while (std::getline(istrm, str)) in_sources.push_back(str); } } else { for (int i = 1; i < argc - 1; ++i) in_sources.push_back(strcmp(argv[i], "-") != 0 ? argv[i] : ""); } if (in_sources.empty()) { // argc == 1 || argc == 2. This cleverly handles both the no-file case // and the one (input) file case together. // TODO(jrosenstock): This probably shouldn't happen for the // --file_list_input case. in_sources.push_back(argc == 2 && strcmp(argv[1], "-") != 0 ? argv[1] : ""); } // argc <= 2 means the file (if any) is an input file, so write to stdout. const std::string out_source = argc > 2 && strcmp(argv[argc - 1], "-") != 0 ? argv[argc - 1] : ""; const auto arc_type = s::LoadArcTypeFromFst(in_sources[0]); if (arc_type.empty()) return 1; fst::FarType far_type; if (!s::GetFarType(FLAGS_far_type, &far_type)) { LOG(ERROR) << "Unknown or unsupported FAR type: " << FLAGS_far_type; return 1; } s::FarCreate(in_sources, out_source, arc_type, FLAGS_generate_keys, far_type, FLAGS_key_prefix, FLAGS_key_suffix); return 0; } openfst-1.7.9/src/extensions/far/farcreate.cc000066400000000000000000000011401421600557100212040ustar00rootroot00000000000000#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 farcreate_main(int argc, char **argv); int main(int argc, char **argv) { return farcreate_main(argc, argv); } openfst-1.7.9/src/extensions/far/farequal-main.cc000066400000000000000000000020761421600557100220030ustar00rootroot00000000000000// 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 DECLARE_string(begin_key); DECLARE_string(end_key); DECLARE_double(delta); int farequal_main(int argc, char **argv) { namespace s = fst::script; std::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; } openfst-1.7.9/src/extensions/far/farequal.cc000066400000000000000000000006241421600557100210560ustar00rootroot00000000000000#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 farequal_main(int argc, char **argv); int main(int argc, char **argv) { return farequal_main(argc, argv); } openfst-1.7.9/src/extensions/far/farextract-main.cc000066400000000000000000000024361421600557100223460ustar00rootroot00000000000000// 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 DECLARE_string(filename_prefix); DECLARE_string(filename_suffix); DECLARE_int32(generate_filenames); DECLARE_string(keys); DECLARE_string(key_separator); DECLARE_string(range_delimiter); int farextract_main(int argc, char **argv) { namespace s = fst::script; std::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_sources; for (int i = 1; i < argc; ++i) in_sources.push_back(argv[i]); if (in_sources.empty()) in_sources.push_back(""); const auto arc_type = s::LoadArcTypeFromFar(in_sources[0]); if (arc_type.empty()) return 1; s::FarExtract(in_sources, arc_type, FLAGS_generate_filenames, FLAGS_keys, FLAGS_key_separator, FLAGS_range_delimiter, FLAGS_filename_prefix, FLAGS_filename_suffix); return 0; } openfst-1.7.9/src/extensions/far/farextract.cc000066400000000000000000000012421421600557100214160ustar00rootroot00000000000000#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 farextract_main(int argc, char **argv); int main(int argc, char **argv) { return farextract_main(argc, argv); } openfst-1.7.9/src/extensions/far/farinfo-main.cc000066400000000000000000000022521421600557100216230ustar00rootroot00000000000000// 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 DECLARE_string(begin_key); DECLARE_string(end_key); DECLARE_bool(list_fsts); int farinfo_main(int argc, char **argv) { namespace s = fst::script; std::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_sources; for (int i = 1; i < argc; ++i) in_sources.push_back(argv[i]); if (in_sources.empty()) in_sources.push_back(""); const auto arc_type = s::LoadArcTypeFromFar(in_sources[0]); if (arc_type.empty()) return 1; s::FarInfo(in_sources, arc_type, FLAGS_begin_key, FLAGS_end_key, FLAGS_list_fsts); return 0; } openfst-1.7.9/src/extensions/far/farinfo.cc000066400000000000000000000006241421600557100207020ustar00rootroot00000000000000#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 farinfo_main(int argc, char **argv); int main(int argc, char **argv) { return farinfo_main(argc, argv); } openfst-1.7.9/src/extensions/far/farisomorphic-main.cc000066400000000000000000000022031421600557100230400ustar00rootroot00000000000000// 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 DECLARE_string(begin_key); DECLARE_string(end_key); DECLARE_double(delta); int farisomorphic_main(int argc, char **argv) { namespace s = fst::script; std::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; } openfst-1.7.9/src/extensions/far/farisomorphic.cc000066400000000000000000000006361421600557100221260ustar00rootroot00000000000000#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 farisomorphic_main(int argc, char **argv); int main(int argc, char **argv) { return farisomorphic_main(argc, argv); } openfst-1.7.9/src/extensions/far/farprintstrings-main.cc000066400000000000000000000036721421600557100234450ustar00rootroot00000000000000// 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 DECLARE_string(filename_prefix); DECLARE_string(filename_suffix); DECLARE_int32(generate_filenames); DECLARE_string(begin_key); DECLARE_string(end_key); DECLARE_bool(print_key); DECLARE_bool(print_weight); DECLARE_string(entry_type); DECLARE_string(token_type); DECLARE_string(symbols); DECLARE_bool(initial_symbols); int farprintstrings_main(int argc, char **argv) { namespace s = fst::script; std::string usage = "Print as std::string the std::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_sources; for (int i = 1; i < argc; ++i) in_sources.push_back(argv[i]); if (in_sources.empty()) in_sources.push_back(""); const auto arc_type = s::LoadArcTypeFromFar(in_sources[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::TokenType token_type; if (!s::GetTokenType(FLAGS_token_type, &token_type)) { LOG(ERROR) << "Unknown or unsupported FAR token type: " << FLAGS_token_type; return 1; } s::FarPrintStrings(in_sources, 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; } openfst-1.7.9/src/extensions/far/farprintstrings.cc000066400000000000000000000022531421600557100225150ustar00rootroot00000000000000#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 std::string by its key"); DEFINE_bool(print_weight, false, "Suffix each std::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 farprintstrings_main(int argc, char **argv); int main(int argc, char **argv) { return farprintstrings_main(argc, argv); } openfst-1.7.9/src/extensions/far/farscript.cc000066400000000000000000000125101421600557100212500ustar00rootroot00000000000000// 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_sources, const std::string &out_source, const std::string &arc_type, const std::string &fst_type, const FarType &far_type, int32 generate_keys, FarEntryType fet, TokenType tt, const std::string &symbols_source, const std::string &unknown_symbol, bool keep_symbols, bool initial_symbols, bool allow_negative_labels, const std::string &key_prefix, const std::string &key_suffix) { FarCompileStringsArgs args(in_sources, out_source, fst_type, far_type, generate_keys, fet, tt, symbols_source, unknown_symbol, keep_symbols, initial_symbols, allow_negative_labels, key_prefix, key_suffix); Apply>("FarCompileStrings", arc_type, &args); } REGISTER_FST_OPERATION_3ARCS(FarCompileStrings, FarCompileStringsArgs); void FarCreate(const std::vector &in_sources, const std::string &out_source, const std::string &arc_type, const int32 generate_keys, const FarType &far_type, const std::string &key_prefix, const std::string &key_suffix) { FarCreateArgs args(in_sources, out_source, generate_keys, far_type, key_prefix, key_suffix); Apply>("FarCreate", arc_type, &args); } REGISTER_FST_OPERATION_3ARCS(FarCreate, FarCreateArgs); bool FarEqual(const std::string &source1, const std::string &source2, const std::string &arc_type, float delta, const std::string &begin_key, const std::string &end_key) { FarEqualInnerArgs args(source1, source2, delta, begin_key, end_key); FarEqualArgs args_with_retval(args); Apply>("FarEqual", arc_type, &args_with_retval); return args_with_retval.retval; } REGISTER_FST_OPERATION_3ARCS(FarEqual, FarEqualArgs); void FarExtract(const std::vector &isources, const std::string &arc_type, int32 generate_sources, const std::string &keys, const std::string &key_separator, const std::string &range_delimiter, const std::string &source_prefix, const std::string &source_suffix) { FarExtractArgs args(isources, generate_sources, keys, key_separator, range_delimiter, source_prefix, source_suffix); Apply>("FarExtract", arc_type, &args); } REGISTER_FST_OPERATION_3ARCS(FarExtract, FarExtractArgs); void FarInfo(const std::vector &sources, const std::string &arc_type, const std::string &begin_key, const std::string &end_key, bool list_fsts) { FarInfoArgs args(sources, begin_key, end_key, list_fsts); Apply>("FarInfo", arc_type, &args); } REGISTER_FST_OPERATION_3ARCS(FarInfo, FarInfoArgs); void GetFarInfo(const std::vector &sources, const std::string &arc_type, const std::string &begin_key, const std::string &end_key, bool list_fsts, FarInfoData *data) { GetFarInfoArgs args(sources, begin_key, end_key, list_fsts, data); Apply>("GetFarInfo", arc_type, &args); } REGISTER_FST_OPERATION_3ARCS(GetFarInfo, GetFarInfoArgs); bool FarIsomorphic(const std::string &source1, const std::string &source2, const std::string &arc_type, float delta, const std::string &begin_key, const std::string &end_key) { FarIsomorphicInnerArgs args(source1, source2, delta, begin_key, end_key); FarIsomorphicArgs args_with_retval(args); Apply>("FarIsomorphic", arc_type, &args_with_retval); return args_with_retval.retval; } REGISTER_FST_OPERATION_3ARCS(FarIsomorphic, FarIsomorphicArgs); void FarPrintStrings(const std::vector &isources, const std::string &arc_type, const FarEntryType entry_type, const TokenType token_type, const std::string &begin_key, const std::string &end_key, bool print_key, bool print_weight, const std::string &symbols_source, bool initial_symbols, const int32 generate_sources, const std::string &source_prefix, const std::string &source_suffix) { FarPrintStringsArgs args(isources, entry_type, token_type, begin_key, end_key, print_key, print_weight, symbols_source, initial_symbols, generate_sources, source_prefix, source_suffix); Apply>("FarPrintStrings", arc_type, &args); } REGISTER_FST_OPERATION_3ARCS(FarPrintStrings, FarPrintStringsArgs); } // namespace script } // namespace fst openfst-1.7.9/src/extensions/far/getters.cc000066400000000000000000000026021421600557100207310ustar00rootroot00000000000000// 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 { bool GetFarType(const std::string &str, FarType *far_type) { if (str == "fst") { *far_type = FarType::FST; } else if (str == "stlist") { *far_type = FarType::STLIST; } else if (str == "sttable") { *far_type = FarType::STTABLE; } else if (str == "default") { *far_type = FarType::DEFAULT; } else { return false; } return true; } bool GetFarEntryType(const std::string &str, FarEntryType *entry_type) { if (str == "line") { *entry_type = FarEntryType::LINE; } else if (str == "file") { *entry_type = FarEntryType::FILE; } else { return false; } return true; } void ExpandArgs(int argc, char **argv, int *argcp, char ***argvp) { } } // namespace script std::string GetFarTypeString(FarType far_type) { switch (far_type) { case FarType::FST: return "fst"; case FarType::STLIST: return "stlist"; case FarType::STTABLE: return "sttable"; case FarType::DEFAULT: return "default"; default: return ""; } } } // namespace fst openfst-1.7.9/src/extensions/far/script-impl.cc000066400000000000000000000020511421600557100215150ustar00rootroot00000000000000// 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 { std::string LoadArcTypeFromFar(const std::string &far_source) { FarHeader hdr; if (!hdr.Read(far_source)) { LOG(ERROR) << "Error reading FAR: " << far_source; return ""; } std::string atype = hdr.ArcType(); if (atype == "unknown") { LOG(ERROR) << "Empty FST archive: " << far_source; return ""; } return atype; } std::string LoadArcTypeFromFst(const std::string &fst_source) { FstHeader hdr; std::ifstream in(fst_source, std::ios_base::in | std::ios_base::binary); if (!hdr.Read(in, fst_source)) { LOG(ERROR) << "Error reading FST: " << fst_source; return ""; } return hdr.ArcType(); } } // namespace script } // namespace fst openfst-1.7.9/src/extensions/far/stlist.cc000066400000000000000000000007241421600557100206010ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #include namespace fst { bool IsSTList(const std::string &source) { std::ifstream strm(source, 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 openfst-1.7.9/src/extensions/far/strings.cc000066400000000000000000000024251421600557100207500ustar00rootroot00000000000000// 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, or zero if the number of lines could not be determined because the // file was not seekable. int KeySize(const char *source) { std::ifstream istrm(source); istrm.seekg(0); // TODO(jrosenstock): Change this to is_regular_file when is // no longer banned. // Stream not seekable. This is really a hack to approximate is_regular_file. // What we really want is that opening and reading the file twice gives the // same result, which is only true for regular files. There may be devices // that don't return an error on seek. At least we are able to catch the // common cases of /dev/stdin and fifos. if (istrm.rdstate() & std::ios_base::failbit) { return 0; } std::string s; int nline = 0; while (std::getline(istrm, s)) ++nline; return nline ? ceil(log10(nline + 1)) : 1; } } // namespace fst openfst-1.7.9/src/extensions/far/sttable.cc000066400000000000000000000006441421600557100207160ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { bool IsSTTable(const std::string &source) { std::ifstream strm(source); if (!strm.good()) return false; int32 magic_number = 0; ReadType(strm, &magic_number); return magic_number == kSTTableMagicNumber; } } // namespace fst openfst-1.7.9/src/extensions/linear/000077500000000000000000000000001421600557100174475ustar00rootroot00000000000000openfst-1.7.9/src/extensions/linear/Makefile.am000066400000000000000000000017211421600557100215040ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) LIBS = ../../lib/libfst.la -lm $(DL_LIBS) if HAVE_BIN bin_PROGRAMS = fstlinear fstloglinearapply fstlinear_SOURCES = fstlinear.cc fstlinear-main.cc fstlinear_LDADD = libfstlinearscript.la ../../script/libfstscript.la fstloglinearapply_SOURCES = fstloglinearapply.cc fstloglinearapply-main.cc fstloglinearapply_LDADD = libfstlinearscript.la ../../script/libfstscript.la endif if HAVE_SCRIPT lib_LTLIBRARIES = libfstlinearscript.la libfstlinearscript_la_SOURCES = linearscript.cc libfstlinearscript_la_LDFLAGS = -version-info 22:0:0 libfstlinearscript_la_LIBADD = ../../script/libfstscript.la endif libfst_LTLIBRARIES = linear_tagger-fst.la linear_classifier-fst.la libfstdir = @libfstdir@ linear_tagger_fst_la_SOURCES = linear-tagger-fst.cc linear_tagger_fst_la_LDFLAGS = -avoid-version -module linear_classifier_fst_la_SOURCES = linear-classifier-fst.cc linear_classifier_fst_la_LDFLAGS = -avoid-version -module openfst-1.7.9/src/extensions/linear/Makefile.in000066400000000000000000000736571421600557100215360ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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)" "$(DESTDIR)$(libdir)" \ "$(DESTDIR)$(libfstdir)" PROGRAMS = $(bin_PROGRAMS) 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; }; \ } LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) @HAVE_SCRIPT_TRUE@libfstlinearscript_la_DEPENDENCIES = \ @HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la 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 $@ 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 $@ am__fstlinear_SOURCES_DIST = fstlinear.cc fstlinear-main.cc @HAVE_BIN_TRUE@am_fstlinear_OBJECTS = fstlinear.$(OBJEXT) \ @HAVE_BIN_TRUE@ fstlinear-main.$(OBJEXT) fstlinear_OBJECTS = $(am_fstlinear_OBJECTS) @HAVE_BIN_TRUE@fstlinear_DEPENDENCIES = libfstlinearscript.la \ @HAVE_BIN_TRUE@ ../../script/libfstscript.la am__fstloglinearapply_SOURCES_DIST = fstloglinearapply.cc \ fstloglinearapply-main.cc @HAVE_BIN_TRUE@am_fstloglinearapply_OBJECTS = \ @HAVE_BIN_TRUE@ fstloglinearapply.$(OBJEXT) \ @HAVE_BIN_TRUE@ fstloglinearapply-main.$(OBJEXT) fstloglinearapply_OBJECTS = $(am_fstloglinearapply_OBJECTS) @HAVE_BIN_TRUE@fstloglinearapply_DEPENDENCIES = libfstlinearscript.la \ @HAVE_BIN_TRUE@ ../../script/libfstscript.la 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/fstlinear-main.Po \ ./$(DEPDIR)/fstlinear.Po ./$(DEPDIR)/fstloglinearapply-main.Po \ ./$(DEPDIR)/fstloglinearapply.Po \ ./$(DEPDIR)/linear-classifier-fst.Plo \ ./$(DEPDIR)/linear-tagger-fst.Plo ./$(DEPDIR)/linearscript.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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 = ../../lib/libfst.la -lm $(DL_LIBS) LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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@fstlinear_SOURCES = fstlinear.cc fstlinear-main.cc @HAVE_BIN_TRUE@fstlinear_LDADD = libfstlinearscript.la ../../script/libfstscript.la @HAVE_BIN_TRUE@fstloglinearapply_SOURCES = fstloglinearapply.cc fstloglinearapply-main.cc @HAVE_BIN_TRUE@fstloglinearapply_LDADD = libfstlinearscript.la ../../script/libfstscript.la @HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstlinearscript.la @HAVE_SCRIPT_TRUE@libfstlinearscript_la_SOURCES = linearscript.cc @HAVE_SCRIPT_TRUE@libfstlinearscript_la_LDFLAGS = -version-info 22:0:0 @HAVE_SCRIPT_TRUE@libfstlinearscript_la_LIBADD = ../../script/libfstscript.la libfst_LTLIBRARIES = linear_tagger-fst.la linear_classifier-fst.la linear_tagger_fst_la_SOURCES = linear-tagger-fst.cc linear_tagger_fst_la_LDFLAGS = -avoid-version -module linear_classifier_fst_la_SOURCES = linear-classifier-fst.cc linear_classifier_fst_la_LDFLAGS = -avoid-version -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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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 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) -rpath $(libfstdir) $(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) -rpath $(libfstdir) $(linear_tagger_fst_la_OBJECTS) $(linear_tagger_fst_la_LIBADD) $(LIBS) 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-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstlinear.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstloglinearapply-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstloglinearapply.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linear-classifier-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linear-tagger-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linearscript.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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) $(LTLIBRARIES) install-binPROGRAMS: install-libLTLIBRARIES installdirs: for dir in "$(DESTDIR)$(bindir)" "$(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-binPROGRAMS clean-generic clean-libLTLIBRARIES \ clean-libfstLTLIBRARIES clean-libtool mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/fstlinear-main.Po -rm -f ./$(DEPDIR)/fstlinear.Po -rm -f ./$(DEPDIR)/fstloglinearapply-main.Po -rm -f ./$(DEPDIR)/fstloglinearapply.Po -rm -f ./$(DEPDIR)/linear-classifier-fst.Plo -rm -f ./$(DEPDIR)/linear-tagger-fst.Plo -rm -f ./$(DEPDIR)/linearscript.Plo -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 -f ./$(DEPDIR)/fstlinear-main.Po -rm -f ./$(DEPDIR)/fstlinear.Po -rm -f ./$(DEPDIR)/fstloglinearapply-main.Po -rm -f ./$(DEPDIR)/fstloglinearapply.Po -rm -f ./$(DEPDIR)/linear-classifier-fst.Plo -rm -f ./$(DEPDIR)/linear-tagger-fst.Plo -rm -f ./$(DEPDIR)/linearscript.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/linear/fstlinear-main.cc000066400000000000000000000017631421600557100226760ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include DECLARE_string(arc_type); DECLARE_string(epsilon_symbol); DECLARE_string(unknown_symbol); DECLARE_string(vocab); DECLARE_string(out); DECLARE_string(save_isymbols); DECLARE_string(save_fsymbols); DECLARE_string(save_osymbols); int fstlinear_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); return 0; } openfst-1.7.9/src/extensions/linear/fstlinear.cc000066400000000000000000000013461421600557100217510ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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 fstlinear_main(int argc, char **argv); int main(int argc, char **argv) { return fstlinear_main(argc, argv); } openfst-1.7.9/src/extensions/linear/fstloglinearapply-main.cc000066400000000000000000000025511421600557100244420ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #include #include #include DECLARE_bool(normalize); int fstloglinearapply_main(int argc, char **argv) { std::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; } std::string in_name = strcmp(argv[1], "-") != 0 ? argv[1] : ""; std::string linear_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? argv[2] : ""; std::string out_name = (argc > 3 && (strcmp(argv[3], "-") != 0)) ? 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; fst::LogLinearApply(*ifst1, *ifst2, &ofst, FLAGS_normalize); return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/linear/fstloglinearapply.cc000066400000000000000000000005311421600557100235140ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include DEFINE_bool(normalize, true, "Normalize to get posterior"); int fstloglinearapply_main(int argc, char **argv); int main(int argc, char **argv) { return fstloglinearapply_main(argc, argv); } openfst-1.7.9/src/extensions/linear/linear-classifier-fst.cc000066400000000000000000000005171421600557100241470ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include using fst::LinearClassifierFst; using fst::LogArc; using fst::StdArc; REGISTER_FST(LinearClassifierFst, StdArc); REGISTER_FST(LinearClassifierFst, LogArc); openfst-1.7.9/src/extensions/linear/linear-tagger-fst.cc000066400000000000000000000005031421600557100232670ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include using fst::LinearTaggerFst; using fst::LogArc; using fst::StdArc; REGISTER_FST(LinearTaggerFst, StdArc); REGISTER_FST(LinearTaggerFst, LogArc); openfst-1.7.9/src/extensions/linear/linearscript.cc000066400000000000000000000054041421600557100224600ustar00rootroot00000000000000// 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() { return FLAGS_delimiter.size() == 1 && !std::isspace(FLAGS_delimiter[0]); } 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 std::string &arc_type, const std::string &epsilon_symbol, const std::string &unknown_symbol, const std::string &vocab, char **models, int models_len, const std::string &out, const std::string &save_isymbols, const std::string &save_fsymbols, const std::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); } REGISTER_FST_OPERATION_3ARCS(LinearCompileTpl, LinearCompileArgs); void SplitByWhitespace(const std::string &str, std::vector *out) { out->clear(); std::istringstream strm(str); std::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]; std::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 openfst-1.7.9/src/extensions/lookahead/000077500000000000000000000000001421600557100201245ustar00rootroot00000000000000openfst-1.7.9/src/extensions/lookahead/Makefile.am000066400000000000000000000014041421600557100221570ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) LIBS = ../../lib/libfst.la -lm $(DL_LIBS) 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 22:0:0 arc_lookahead_fst_la_SOURCES = arc_lookahead-fst.cc arc_lookahead_fst_la_LDFLAGS = -avoid-version -module ilabel_lookahead_fst_la_SOURCES = ilabel_lookahead-fst.cc ilabel_lookahead_fst_la_LDFLAGS = -avoid-version -module olabel_lookahead_fst_la_SOURCES = olabel_lookahead-fst.cc olabel_lookahead_fst_la_LDFLAGS = -avoid-version -module openfst-1.7.9/src/extensions/lookahead/Makefile.in000066400000000000000000000635371421600557100222070ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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 $@ libfstlookahead_la_LIBADD = 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/arc_lookahead-fst.Plo \ ./$(DEPDIR)/ilabel_lookahead-fst.Plo \ ./$(DEPDIR)/olabel_lookahead-fst.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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 = ../../lib/libfst.la -lm $(DL_LIBS) LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 22:0:0 arc_lookahead_fst_la_SOURCES = arc_lookahead-fst.cc arc_lookahead_fst_la_LDFLAGS = -avoid-version -module ilabel_lookahead_fst_la_SOURCES = ilabel_lookahead-fst.cc ilabel_lookahead_fst_la_LDFLAGS = -avoid-version -module olabel_lookahead_fst_la_SOURCES = olabel_lookahead-fst.cc olabel_lookahead_fst_la_LDFLAGS = -avoid-version -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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ilabel_lookahead-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/olabel_lookahead-fst.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/arc_lookahead-fst.Plo -rm -f ./$(DEPDIR)/ilabel_lookahead-fst.Plo -rm -f ./$(DEPDIR)/olabel_lookahead-fst.Plo -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 -f ./$(DEPDIR)/arc_lookahead-fst.Plo -rm -f ./$(DEPDIR)/ilabel_lookahead-fst.Plo -rm -f ./$(DEPDIR)/olabel_lookahead-fst.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/lookahead/arc_lookahead-fst.cc000066400000000000000000000011661421600557100240050ustar00rootroot00000000000000// 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 openfst-1.7.9/src/extensions/lookahead/ilabel_lookahead-fst.cc000066400000000000000000000015721421600557100244710ustar00rootroot00000000000000// 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 openfst-1.7.9/src/extensions/lookahead/olabel_lookahead-fst.cc000066400000000000000000000015721421600557100244770ustar00rootroot00000000000000// 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 openfst-1.7.9/src/extensions/mpdt/000077500000000000000000000000001421600557100171415ustar00rootroot00000000000000openfst-1.7.9/src/extensions/mpdt/Makefile.am000066400000000000000000000014121421600557100211730ustar00rootroot00000000000000AM_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 mpdtcompose-main.cc mpdtexpand_SOURCES = mpdtexpand.cc mpdtexpand-main.cc mpdtinfo_SOURCES = mpdtinfo.cc mpdtinfo-main.cc mpdtreverse_SOURCES = mpdtreverse.cc mpdtreverse-main.cc endif if HAVE_SCRIPT lib_LTLIBRARIES = libfstmpdtscript.la libfstmpdtscript_la_SOURCES = mpdtscript.cc libfstmpdtscript_la_LDFLAGS = -version-info 22:0:0 libfstmpdtscript_la_LIBADD = ../../script/libfstscript.la \ ../../lib/libfst.la -lm $(DL_LIBS) endif openfst-1.7.9/src/extensions/mpdt/Makefile.in000066400000000000000000000713331421600557100212150ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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)" "$(DESTDIR)$(libdir)" PROGRAMS = $(bin_PROGRAMS) 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; }; \ } 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) am__mpdtcompose_SOURCES_DIST = mpdtcompose.cc mpdtcompose-main.cc @HAVE_BIN_TRUE@am_mpdtcompose_OBJECTS = mpdtcompose.$(OBJEXT) \ @HAVE_BIN_TRUE@ mpdtcompose-main.$(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 mpdtexpand-main.cc @HAVE_BIN_TRUE@am_mpdtexpand_OBJECTS = mpdtexpand.$(OBJEXT) \ @HAVE_BIN_TRUE@ mpdtexpand-main.$(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 mpdtinfo-main.cc @HAVE_BIN_TRUE@am_mpdtinfo_OBJECTS = mpdtinfo.$(OBJEXT) \ @HAVE_BIN_TRUE@ mpdtinfo-main.$(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 mpdtreverse-main.cc @HAVE_BIN_TRUE@am_mpdtreverse_OBJECTS = mpdtreverse.$(OBJEXT) \ @HAVE_BIN_TRUE@ mpdtreverse-main.$(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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/mpdtcompose-main.Po \ ./$(DEPDIR)/mpdtcompose.Po ./$(DEPDIR)/mpdtexpand-main.Po \ ./$(DEPDIR)/mpdtexpand.Po ./$(DEPDIR)/mpdtinfo-main.Po \ ./$(DEPDIR)/mpdtinfo.Po ./$(DEPDIR)/mpdtreverse-main.Po \ ./$(DEPDIR)/mpdtreverse.Po ./$(DEPDIR)/mpdtscript.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 mpdtcompose-main.cc @HAVE_BIN_TRUE@mpdtexpand_SOURCES = mpdtexpand.cc mpdtexpand-main.cc @HAVE_BIN_TRUE@mpdtinfo_SOURCES = mpdtinfo.cc mpdtinfo-main.cc @HAVE_BIN_TRUE@mpdtreverse_SOURCES = mpdtreverse.cc mpdtreverse-main.cc @HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstmpdtscript.la @HAVE_SCRIPT_TRUE@libfstmpdtscript_la_SOURCES = mpdtscript.cc @HAVE_SCRIPT_TRUE@libfstmpdtscript_la_LDFLAGS = -version-info 22: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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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 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) 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-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtcompose.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtexpand-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtexpand.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtinfo-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtinfo.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtreverse-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtreverse.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtscript.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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) $(LTLIBRARIES) install-binPROGRAMS: install-libLTLIBRARIES installdirs: for dir in "$(DESTDIR)$(bindir)" "$(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-binPROGRAMS clean-generic clean-libLTLIBRARIES \ clean-libtool mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/mpdtcompose-main.Po -rm -f ./$(DEPDIR)/mpdtcompose.Po -rm -f ./$(DEPDIR)/mpdtexpand-main.Po -rm -f ./$(DEPDIR)/mpdtexpand.Po -rm -f ./$(DEPDIR)/mpdtinfo-main.Po -rm -f ./$(DEPDIR)/mpdtinfo.Po -rm -f ./$(DEPDIR)/mpdtreverse-main.Po -rm -f ./$(DEPDIR)/mpdtreverse.Po -rm -f ./$(DEPDIR)/mpdtscript.Plo -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 -f ./$(DEPDIR)/mpdtcompose-main.Po -rm -f ./$(DEPDIR)/mpdtcompose.Po -rm -f ./$(DEPDIR)/mpdtexpand-main.Po -rm -f ./$(DEPDIR)/mpdtexpand.Po -rm -f ./$(DEPDIR)/mpdtinfo-main.Po -rm -f ./$(DEPDIR)/mpdtinfo.Po -rm -f ./$(DEPDIR)/mpdtreverse-main.Po -rm -f ./$(DEPDIR)/mpdtreverse.Po -rm -f ./$(DEPDIR)/mpdtscript.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/mpdt/mpdtcompose-main.cc000066400000000000000000000046751421600557100227400ustar00rootroot00000000000000// 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 #include #include DECLARE_string(mpdt_parentheses); DECLARE_bool(left_mpdt); DECLARE_bool(connect); DECLARE_string(compose_filter); int mpdtcompose_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; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; const std::string out_name = argc > 3 && strcmp(argv[3], "-") != 0 ? 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); return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/mpdt/mpdtcompose.cc000066400000000000000000000011731421600557100220040ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Composes an MPDT and an FST. #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 mpdtcompose_main(int argc, char **argv); int main(int argc, char **argv) { return mpdtcompose_main(argc, argv); } openfst-1.7.9/src/extensions/mpdt/mpdtexpand-main.cc000066400000000000000000000034061421600557100225410ustar00rootroot00000000000000// 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 #include #include DECLARE_string(mpdt_parentheses); DECLARE_bool(connect); DECLARE_bool(keep_parentheses); int mpdtexpand_main(int argc, char **argv) { namespace s = fst::script; using fst::MPdtExpandOptions; using fst::ReadLabelTriples; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; const std::string out_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? 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); return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/mpdt/mpdtexpand.cc000066400000000000000000000010001421600557100216030ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Expands a (bounded-stack) MPDT as an FST. #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 mpdtexpand_main(int argc, char **argv); int main(int argc, char **argv) { return mpdtexpand_main(argc, argv); } openfst-1.7.9/src/extensions/mpdt/mpdtinfo-main.cc000066400000000000000000000027041421600557100222150ustar00rootroot00000000000000// 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 #include #include DECLARE_string(mpdt_parentheses); int mpdtinfo_main(int argc, char **argv) { namespace s = fst::script; using fst::ReadLabelTriples; using fst::script::FstClass; std::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 std::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; } openfst-1.7.9/src/extensions/mpdt/mpdtinfo.cc000066400000000000000000000006761421600557100213010ustar00rootroot00000000000000// 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 DEFINE_string(mpdt_parentheses, "", "MPDT parenthesis label pairs with assignments"); int mpdtinfo_main(int argc, char **argv); int main(int argc, char **argv) { return mpdtinfo_main(argc, argv); } openfst-1.7.9/src/extensions/mpdt/mpdtreverse-main.cc000066400000000000000000000035401421600557100227340ustar00rootroot00000000000000// 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 #include #include DECLARE_string(mpdt_parentheses); DECLARE_string(mpdt_new_parentheses); int mpdtreverse_main(int argc, char **argv) { namespace s = fst::script; using fst::ReadLabelTriples; using fst::WriteLabelTriples; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; const std::string out_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? 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); if (!ofst.Write(out_name)) return 1; return !WriteLabelTriples(FLAGS_mpdt_new_parentheses, parens, assignments); } openfst-1.7.9/src/extensions/mpdt/mpdtreverse.cc000066400000000000000000000007351421600557100220150ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Reverses an MPDT. #include DEFINE_string(mpdt_parentheses, "", "MPDT parenthesis label pairs with assignments."); DEFINE_string(mpdt_new_parentheses, "", "Output for reassigned parentheses and stacks"); int mpdtreverse_main(int argc, char **argv); int main(int argc, char **argv) { return mpdtreverse_main(argc, argv); } openfst-1.7.9/src/extensions/mpdt/mpdtscript.cc000066400000000000000000000054611421600557100216470ustar00rootroot00000000000000// 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 #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); } REGISTER_FST_OPERATION_3ARCS(MPdtCompose, MPdtComposeArgs); 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); } REGISTER_FST_OPERATION_3ARCS(MPdtExpand, MPdtExpandArgs); 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); } REGISTER_FST_OPERATION_3ARCS(MPdtReverse, MPdtReverseArgs); void PrintMPdtInfo(const FstClass &ifst, const std::vector> &parens, const std::vector &assignments) { PrintMPdtInfoArgs args(ifst, parens, assignments); Apply>("PrintMPdtInfo", ifst.ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(PrintMPdtInfo, PrintMPdtInfoArgs); } // namespace script } // namespace fst openfst-1.7.9/src/extensions/ngram/000077500000000000000000000000001421600557100173015ustar00rootroot00000000000000openfst-1.7.9/src/extensions/ngram/Makefile.am000066400000000000000000000006331421600557100213370ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS) LIBS = ../../lib/libfst.la -lm $(DL_LIBS) 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 = -avoid-version -module libfstngram_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc libfstngram_la_LDFLAGS = -version-info 22:0:0 openfst-1.7.9/src/extensions/ngram/Makefile.in000066400000000000000000000573231421600557100213600ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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) libfstngram_la_LIBADD = 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/bitmap-index.Plo \ ./$(DEPDIR)/ngram-fst.Plo ./$(DEPDIR)/nthbit.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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 = ../../lib/libfst.la -lm $(DL_LIBS) LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 = -avoid-version -module libfstngram_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc libfstngram_la_LDFLAGS = -version-info 22: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/extensions/ngram/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign src/extensions/ngram/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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ngram-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nthbit.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/bitmap-index.Plo -rm -f ./$(DEPDIR)/ngram-fst.Plo -rm -f ./$(DEPDIR)/nthbit.Plo -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 -f ./$(DEPDIR)/bitmap-index.Plo -rm -f ./$(DEPDIR)/ngram-fst.Plo -rm -f ./$(DEPDIR)/nthbit.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/ngram/bitmap-index.cc000066400000000000000000000443041421600557100221760ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #include #include #include #include namespace fst { static_assert(sizeof(long long) >= sizeof(uint64), // NOLINT "__builtin_...ll is used on uint64 values."); size_t BitmapIndex::Rank1(size_t end) const { DCHECK_LE(end, Bits()); // TODO(jrosenstock): Remove nullptr support and this special case. if (end == 0) return 0; // Without this special case, we'd go past the end. It's questionable // whether we should support end == Bits(). if (end >= num_bits_) return GetOnesCount(); const uint32 end_word = end / kStorageBitSize; const uint32 sum = GetIndexOnesCount(end_word); const int bit_index = end % kStorageBitSize; // TODO(jrosenstock): better with or without special case, and does // this depend on whether there's a popcnt instruction? if (bit_index == 0) return sum; // Entire answer is in the index. const uint64 mask = (uint64{1} << bit_index) - 1; return sum + __builtin_popcountll(bits_[end_word] & mask); } size_t BitmapIndex::Select1(size_t bit_index) const { if (bit_index >= GetOnesCount()) return Bits(); const RankIndexEntry& entry = FindRankIndexEntry(bit_index); const uint32 block_index = &entry - rank_index_.data(); // TODO(jrosenstock): Look at whether word or bit indices are faster. static_assert(kUnitsPerRankIndexEntry == 8); uint32 word_index = block_index * kUnitsPerRankIndexEntry; // Find position within this block. uint32 rembits = bit_index - entry.absolute_ones_count(); if (rembits < entry.relative_ones_count_4()) { if (rembits < entry.relative_ones_count_2()) { if (rembits < entry.relative_ones_count_1()) { // First word, nothing to do. } else { word_index += 1; rembits -= entry.relative_ones_count_1(); } } else if (rembits < entry.relative_ones_count_3()) { word_index += 2; rembits -= entry.relative_ones_count_2(); } else { word_index += 3; rembits -= entry.relative_ones_count_3(); } } else if (rembits < entry.relative_ones_count_6()) { if (rembits < entry.relative_ones_count_5()) { word_index += 4; rembits -= entry.relative_ones_count_4(); } else { word_index += 5; rembits -= entry.relative_ones_count_5(); } } else if (rembits < entry.relative_ones_count_7()) { word_index += 6; rembits -= entry.relative_ones_count_6(); } else { word_index += 7; rembits -= entry.relative_ones_count_7(); } const int nth = nth_bit(bits_[word_index], rembits); return kStorageBitSize * word_index + nth; } size_t BitmapIndex::Select0(size_t bit_index) const { const uint32 zeros_count = Bits() - GetOnesCount(); if (bit_index >= zeros_count) return Bits(); const RankIndexEntry& entry = FindInvertedRankIndexEntry(bit_index); const uint32 block_index = &entry - rank_index_.data(); static_assert(kUnitsPerRankIndexEntry == 8); uint32 word_index = block_index * kUnitsPerRankIndexEntry; // Find position within this block. uint32 entry_zeros_count = kStorageBitSize * word_index - entry.absolute_ones_count(); uint32 remzeros = bit_index - entry_zeros_count; if (remzeros < 4 * kStorageBitSize - entry.relative_ones_count_4()) { if (remzeros < 2 * kStorageBitSize - entry.relative_ones_count_2()) { if (remzeros < kStorageBitSize - entry.relative_ones_count_1()) { // Nothing to do. } else { word_index += 1; remzeros -= kStorageBitSize - entry.relative_ones_count_1(); } } else if (remzeros < 3 * kStorageBitSize - entry.relative_ones_count_3()) { word_index += 2; remzeros -= 2 * kStorageBitSize - entry.relative_ones_count_2(); } else { word_index += 3; remzeros -= 3 * kStorageBitSize - entry.relative_ones_count_3(); } } else if (remzeros < 6 * kStorageBitSize - entry.relative_ones_count_6()) { if (remzeros < 5 * kStorageBitSize - entry.relative_ones_count_5()) { word_index += 4; remzeros -= 4 * kStorageBitSize - entry.relative_ones_count_4(); } else { word_index += 5; remzeros -= 5 * kStorageBitSize - entry.relative_ones_count_5(); } } else if (remzeros < 7 * kStorageBitSize - entry.relative_ones_count_7()) { word_index += 6; remzeros -= 6 * kStorageBitSize - entry.relative_ones_count_6(); } else { word_index += 7; remzeros -= 7 * kStorageBitSize - entry.relative_ones_count_7(); } const int nth = nth_bit(~bits_[word_index], remzeros); return kStorageBitSize * word_index + nth; } std::pair BitmapIndex::Select0s(size_t bit_index) const { const uint32 zeros_count = Bits() - GetOnesCount(); if (bit_index >= zeros_count) return {Bits(), Bits()}; if (bit_index + 1 >= zeros_count) return {Select0(bit_index), Bits()}; const RankIndexEntry& entry = FindInvertedRankIndexEntry(bit_index); const uint32 block_index = &entry - rank_index_.data(); uint32 word_index = block_index * kUnitsPerRankIndexEntry; // Find position within this block. uint32 entry_zeros_count = kStorageBitSize * word_index - entry.absolute_ones_count(); uint32 remzeros = bit_index - entry_zeros_count; if (remzeros < 4 * kStorageBitSize - entry.relative_ones_count_4()) { if (remzeros < 2 * kStorageBitSize - entry.relative_ones_count_2()) { if (remzeros < kStorageBitSize - entry.relative_ones_count_1()) { // Nothing to do. } else { word_index += 1; remzeros -= kStorageBitSize - entry.relative_ones_count_1(); } } else if (remzeros < 3 * kStorageBitSize - entry.relative_ones_count_3()) { word_index += 2; remzeros -= 2 * kStorageBitSize - entry.relative_ones_count_2(); } else { word_index += 3; remzeros -= 3 * kStorageBitSize - entry.relative_ones_count_3(); } } else if (remzeros < 6 * kStorageBitSize - entry.relative_ones_count_6()) { if (remzeros < 5 * kStorageBitSize - entry.relative_ones_count_5()) { word_index += 4; remzeros -= 4 * kStorageBitSize - entry.relative_ones_count_4(); } else { word_index += 5; remzeros -= 5 * kStorageBitSize - entry.relative_ones_count_5(); } } else if (remzeros < 7 * kStorageBitSize - entry.relative_ones_count_7()) { word_index += 6; remzeros -= 6 * kStorageBitSize - entry.relative_ones_count_6(); } else { word_index += 7; remzeros -= 7 * kStorageBitSize - entry.relative_ones_count_7(); } // Find the position of the bit_index-th zero. const uint64 inv_word = ~bits_[word_index]; const int nth = nth_bit(inv_word, remzeros); // Then, we want to "1-out" everything below that position, and count trailing // ones on the result. This gives us the position of the next zero. // There is no count trailing ones builtin, so we invert and use count // trailing zeros. // This mask has 1s in the nth+1 low order bits; it is equivalent to // (1 << (nth + 1)) - 1, but doesn't need a special case when nth == 63. // We want ~0 in this case anyway. We want nth+1 because if the bit_index-th // zero is in position nth, we need to skip nth+1 positions. const uint64 mask = -(uint64{0x2} << nth); // == ~((2 << nth) - 1) const uint64 masked_inv_word = inv_word & mask; // If this is 0, then the next zero is not in the same word. if (masked_inv_word != 0) { // We can't ctz on 0, but we already checked that. const int next_nth = __builtin_ctzll(masked_inv_word); return {kStorageBitSize * word_index + nth, kStorageBitSize * word_index + next_nth}; } else { // TODO(jrosenstock): Try other words in the block. // This should not be massively important. With a bit density of 1/2, // 31/32 zeros in a word have the next zero in the same word. return {kStorageBitSize * word_index + nth, Select0(bit_index + 1)}; } } uint32 BitmapIndex::GetIndexOnesCount(size_t array_index) const { const auto& rank_index_entry = rank_index_[array_index / kUnitsPerRankIndexEntry]; uint32 ones_count = rank_index_entry.absolute_ones_count(); static_assert(kUnitsPerRankIndexEntry == 8); switch (array_index % kUnitsPerRankIndexEntry) { case 1: ones_count += rank_index_entry.relative_ones_count_1(); break; case 2: ones_count += rank_index_entry.relative_ones_count_2(); break; case 3: ones_count += rank_index_entry.relative_ones_count_3(); break; case 4: ones_count += rank_index_entry.relative_ones_count_4(); break; case 5: ones_count += rank_index_entry.relative_ones_count_5(); break; case 6: ones_count += rank_index_entry.relative_ones_count_6(); break; case 7: ones_count += rank_index_entry.relative_ones_count_7(); break; } return ones_count; } void BitmapIndex::BuildIndex(const uint64* bits, size_t num_bits, bool enable_select_0_index, bool enable_select_1_index) { // Absolute counts are uint32s, so this is the most *set* bits we support // for now. Just check the number of *input* bits is less than this // to keep things simple. DCHECK_LT(num_bits, uint64{1} << 32); bits_ = bits; num_bits_ = num_bits; rank_index_.resize(rank_index_size()); select_0_index_.clear(); if (enable_select_0_index) { // Reserve approximately enough for density = 1/2. select_0_index_.reserve(num_bits / (2 * kBitsPerSelect0Block) + 1); } select_1_index_.clear(); if (enable_select_1_index) { select_1_index_.reserve(num_bits / (2 * kBitsPerSelect1Block) + 1); } uint32 ones_count = 0; uint32 zeros_count = 0; // Only updated if enable_select_0_index. for (uint32 word_index = 0; word_index < ArraySize(); ++word_index) { auto& rank_index_entry = rank_index_[word_index / kUnitsPerRankIndexEntry]; static_assert(kUnitsPerRankIndexEntry == 8); switch (word_index % kUnitsPerRankIndexEntry) { case 0: rank_index_entry.set_absolute_ones_count(ones_count); break; case 1: rank_index_entry.set_relative_ones_count_1( ones_count - rank_index_entry.absolute_ones_count()); break; case 2: rank_index_entry.set_relative_ones_count_2( ones_count - rank_index_entry.absolute_ones_count()); break; case 3: rank_index_entry.set_relative_ones_count_3( ones_count - rank_index_entry.absolute_ones_count()); break; case 4: rank_index_entry.set_relative_ones_count_4( ones_count - rank_index_entry.absolute_ones_count()); break; case 5: rank_index_entry.set_relative_ones_count_5( ones_count - rank_index_entry.absolute_ones_count()); break; case 6: rank_index_entry.set_relative_ones_count_6( ones_count - rank_index_entry.absolute_ones_count()); break; case 7: rank_index_entry.set_relative_ones_count_7( ones_count - rank_index_entry.absolute_ones_count()); break; } // We can assume that the last word has zeros in the high bits. const uint64 word = bits[word_index]; const int word_ones_count = __builtin_popcountll(word); const uint32 bit_offset = kStorageBitSize * word_index; if (enable_select_0_index) { // Zeros count is somewhat move involved to compute, so only do it // if we need it. The last word has zeros in the high bits, so // that needs to be accounted for when computing the zeros count // from the ones count. const uint32 bits_remaining = num_bits - bit_offset; const int word_zeros_count = std::min(bits_remaining, kStorageBitSize) - word_ones_count; // We record a 0 every kBitsPerSelect0Block bits. So, if zeros_count // is 0 mod kBitsPerSelect0Block, we record the next zero. If // zeros_count is 1 mod kBitsPerSelect0Block, we need to skip // kBitsPerSelect0Block - 1 zeros, then record a zero. And so on. // What function is this? It's -zeros_count % kBitsPerSelect0Block. const uint32 zeros_to_skip = -zeros_count % kBitsPerSelect0Block; if (word_zeros_count > zeros_to_skip) { const int nth = nth_bit(~word, zeros_to_skip); select_0_index_.push_back(bit_offset + nth); } zeros_count += word_zeros_count; } if (enable_select_1_index) { const uint32 ones_to_skip = -ones_count % kBitsPerSelect1Block; if (word_ones_count > ones_to_skip) { const int nth = nth_bit(word, ones_to_skip); select_1_index_.push_back(bit_offset + nth); } } ones_count += word_ones_count; } // Do we have any extra bits that need to be recorded? // We already recorded all the lower relative positions, // so we need to do the higher ones. // This is only necessary if num_bits % kBitsPerRankIndexEntry != 0, // but if it is 0, we end up in case 7 and do nothing. This also // holds for num_bits == 0. If we do have an if statement guarding // this, mutants complains that it can be changed to if (true). // Therefore, we complicate the understanding of the code to please the // tools. auto& rank_index_entry = rank_index_[(num_bits - 1) / kBitsPerRankIndexEntry]; switch (((num_bits - 1) / kStorageBitSize) % kUnitsPerRankIndexEntry) { case 0: rank_index_entry.set_relative_ones_count_1( ones_count - rank_index_entry.absolute_ones_count()); case 1: rank_index_entry.set_relative_ones_count_2( ones_count - rank_index_entry.absolute_ones_count()); case 2: rank_index_entry.set_relative_ones_count_3( ones_count - rank_index_entry.absolute_ones_count()); case 3: rank_index_entry.set_relative_ones_count_4( ones_count - rank_index_entry.absolute_ones_count()); case 4: rank_index_entry.set_relative_ones_count_5( ones_count - rank_index_entry.absolute_ones_count()); case 5: rank_index_entry.set_relative_ones_count_6( ones_count - rank_index_entry.absolute_ones_count()); case 6: rank_index_entry.set_relative_ones_count_7( ones_count - rank_index_entry.absolute_ones_count()); case 7: // Nothing to do, this count will be included in the final // absolute count. break; } // Add the extra entry with the total number of bits. rank_index_.back().set_absolute_ones_count(ones_count); if (enable_select_0_index) { // Add extra entry with num_bits_. select_0_index_.push_back(num_bits_); select_0_index_.shrink_to_fit(); } if (enable_select_1_index) { select_1_index_.push_back(num_bits_); select_1_index_.shrink_to_fit(); } } const BitmapIndex::RankIndexEntry& BitmapIndex::FindRankIndexEntry( size_t bit_index) const { DCHECK_GE(bit_index, 0); DCHECK_LT(bit_index, rank_index_.back().absolute_ones_count()); const RankIndexEntry* begin = nullptr; const RankIndexEntry* end = nullptr; if (select_1_index_.empty()) { begin = &rank_index_[0]; end = begin + rank_index_.size(); } else { const uint32 select_index = bit_index / kBitsPerSelect1Block; DCHECK_LT(select_index + 1, select_1_index_.size()); // TODO(jrosenstock): It would be nice to handle the exact hit // bit_index % kBitsPerSelect1Block == 0 case so we could // return the value, but that requiries some refactoring: // either inlining this into Select1, or returning a pair // or out param, etc. // The bit is between these indices. const uint32 lo_bit_index = select_1_index_[select_index]; const uint32 hi_bit_index = select_1_index_[select_index + 1]; begin = &rank_index_[lo_bit_index / kBitsPerSelect1Block]; end = &rank_index_[(hi_bit_index + kBitsPerSelect1Block - 1) / kBitsPerSelect1Block]; } // Linear search if the range is small. const RankIndexEntry* entry = nullptr; if (end - begin <= kMaxLinearSearchBlocks) { for (entry = begin; entry != end; ++entry) { if (entry->absolute_ones_count() > bit_index) break; } } else { RankIndexEntry search_entry; search_entry.set_absolute_ones_count(bit_index); // TODO(jrosenstock): benchmark upper vs custom bsearch. entry = &*std::upper_bound( begin, end, search_entry, [](const RankIndexEntry& e1, const RankIndexEntry& e2) { return e1.absolute_ones_count() < e2.absolute_ones_count(); }); } const auto& e = *(entry - 1); DCHECK_LE(e.absolute_ones_count(), bit_index); DCHECK_GT(entry->absolute_ones_count(), bit_index); return e; } const BitmapIndex::RankIndexEntry& BitmapIndex::FindInvertedRankIndexEntry( size_t bit_index) const { DCHECK_GE(bit_index, 0); DCHECK_LT(bit_index, num_bits_ - rank_index_.back().absolute_ones_count()); uint32 lo = 0, hi = 0; if (select_0_index_.empty()) { lo = 0; hi = (num_bits_ + kBitsPerRankIndexEntry - 1) / kBitsPerRankIndexEntry; } else { const uint32 select_index = bit_index / kBitsPerSelect0Block; DCHECK_LT(select_index + 1, select_0_index_.size()); // TODO(jrosenstock): Same special case for exact hit. lo = select_0_index_[select_index] / kBitsPerSelect0Block; hi = (select_0_index_[select_index + 1] + kBitsPerSelect0Block - 1) / kBitsPerSelect0Block; } DCHECK_LT(hi, rank_index_.size()); // Linear search never showed an advantage when benchmarking. This may be // because the linear search is more complex with the zeros_count computation, // or because the ranges are larger, so linear search is triggered less often, // and the difference is harder to measure. while (lo + 1 < hi) { const uint32 mid = lo + (hi - lo) / 2; if (bit_index < kBitsPerRankIndexEntry * mid - rank_index_[mid].absolute_ones_count()) { hi = mid; } else { lo = mid; } } DCHECK_LE(lo * kBitsPerRankIndexEntry - rank_index_[lo].absolute_ones_count(), bit_index); if ((lo + 1) * kBitsPerRankIndexEntry <= num_bits_) { DCHECK_GT((lo + 1) * kBitsPerRankIndexEntry - rank_index_[lo + 1].absolute_ones_count(), bit_index); } else { DCHECK_GT(num_bits_ - rank_index_[lo + 1].absolute_ones_count(), bit_index); } return rank_index_[lo]; } } // end namespace fst openfst-1.7.9/src/extensions/ngram/ngram-fst.cc000066400000000000000000000005321421600557100215060ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #include #include using fst::LogArc; using fst::NGramFst; using fst::StdArc; REGISTER_FST(NGramFst, StdArc); REGISTER_FST(NGramFst, LogArc); openfst-1.7.9/src/extensions/ngram/nthbit.cc000066400000000000000000000551441421600557100211110ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { #if !defined(__BMI2__) // BMI2 has everything in the header #if SIZE_MAX == UINT32_MAX // 32-bit platforms will be slow when using 64-bit operations; use this // table-based version instead. This only contains constant shifts, which // have been benchmarked to be fast. // These tables were generated using: // // uint32 nth_bit_scan(uint64 v, uint32 r) { // for (int i = 0; i < 64; ++i) { // if ((r -= v & 1) == 0) return i; // v >>= 1; // } // return -1; // } // // printf("static const uint8 nth_bit_bit_count[256] = {\n"); // for (size_t i = 0; i < 256; ++i) { // printf("%d, ", __builtin_popcount(i)); // if (i % 16 == 15) printf("\n"); // } // printf("};\n"); // // printf("static const uint8 nth_bit_bit_pos[8][256] = {{\n"); // for (size_t j = 0; j < 8; ++j) { // for (size_t i = 0; i < 256; ++i) { // uint8 pos = nth_bit_scan(i, j); // printf("%d, ", pos); // if (i % 16 == 15) printf("\n"); // } // if (j != 7) printf("}, {\n"); // } // printf("}};\n"); // // This table contains the popcount of 1-byte values: // nth_bit_bit_count[v] == __builtin_popcount(v). static const uint8 nth_bit_bit_count[256] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, }; // This table contains the bit position of the r-th set bit in v, for 1-byte v, // (or 255 if there are fewer than r bits set, but those values are never used): // nth_bit_bit_pos[r][v] == nth_bit_scan(v, r). static const uint8 nth_bit_bit_pos[8][256] = { { 255, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, }, { 255, 255, 255, 1, 255, 2, 2, 1, 255, 3, 3, 1, 3, 2, 2, 1, 255, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 255, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 255, 6, 6, 1, 6, 2, 2, 1, 6, 3, 3, 1, 3, 2, 2, 1, 6, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 6, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 255, 7, 7, 1, 7, 2, 2, 1, 7, 3, 3, 1, 3, 2, 2, 1, 7, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 7, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 7, 6, 6, 1, 6, 2, 2, 1, 6, 3, 3, 1, 3, 2, 2, 1, 6, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 6, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, }, { 255, 255, 255, 255, 255, 255, 255, 2, 255, 255, 255, 3, 255, 3, 3, 2, 255, 255, 255, 4, 255, 4, 4, 2, 255, 4, 4, 3, 4, 3, 3, 2, 255, 255, 255, 5, 255, 5, 5, 2, 255, 5, 5, 3, 5, 3, 3, 2, 255, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 255, 255, 255, 6, 255, 6, 6, 2, 255, 6, 6, 3, 6, 3, 3, 2, 255, 6, 6, 4, 6, 4, 4, 2, 6, 4, 4, 3, 4, 3, 3, 2, 255, 6, 6, 5, 6, 5, 5, 2, 6, 5, 5, 3, 5, 3, 3, 2, 6, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 255, 255, 255, 7, 255, 7, 7, 2, 255, 7, 7, 3, 7, 3, 3, 2, 255, 7, 7, 4, 7, 4, 4, 2, 7, 4, 4, 3, 4, 3, 3, 2, 255, 7, 7, 5, 7, 5, 5, 2, 7, 5, 5, 3, 5, 3, 3, 2, 7, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 255, 7, 7, 6, 7, 6, 6, 2, 7, 6, 6, 3, 6, 3, 3, 2, 7, 6, 6, 4, 6, 4, 4, 2, 6, 4, 4, 3, 4, 3, 3, 2, 7, 6, 6, 5, 6, 5, 5, 2, 6, 5, 5, 3, 5, 3, 3, 2, 6, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, }, { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 3, 255, 255, 255, 255, 255, 255, 255, 4, 255, 255, 255, 4, 255, 4, 4, 3, 255, 255, 255, 255, 255, 255, 255, 5, 255, 255, 255, 5, 255, 5, 5, 3, 255, 255, 255, 5, 255, 5, 5, 4, 255, 5, 5, 4, 5, 4, 4, 3, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 6, 255, 6, 6, 3, 255, 255, 255, 6, 255, 6, 6, 4, 255, 6, 6, 4, 6, 4, 4, 3, 255, 255, 255, 6, 255, 6, 6, 5, 255, 6, 6, 5, 6, 5, 5, 3, 255, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 3, 255, 255, 255, 7, 255, 7, 7, 4, 255, 7, 7, 4, 7, 4, 4, 3, 255, 255, 255, 7, 255, 7, 7, 5, 255, 7, 7, 5, 7, 5, 5, 3, 255, 7, 7, 5, 7, 5, 5, 4, 7, 5, 5, 4, 5, 4, 4, 3, 255, 255, 255, 7, 255, 7, 7, 6, 255, 7, 7, 6, 7, 6, 6, 3, 255, 7, 7, 6, 7, 6, 6, 4, 7, 6, 6, 4, 6, 4, 4, 3, 255, 7, 7, 6, 7, 6, 6, 5, 7, 6, 6, 5, 6, 5, 5, 3, 7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, }, { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 4, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 5, 255, 255, 255, 255, 255, 255, 255, 5, 255, 255, 255, 5, 255, 5, 5, 4, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 6, 255, 6, 6, 4, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 6, 255, 6, 6, 5, 255, 255, 255, 6, 255, 6, 6, 5, 255, 6, 6, 5, 6, 5, 5, 4, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 4, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 5, 255, 255, 255, 7, 255, 7, 7, 5, 255, 7, 7, 5, 7, 5, 5, 4, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 6, 255, 255, 255, 7, 255, 7, 7, 6, 255, 7, 7, 6, 7, 6, 6, 4, 255, 255, 255, 7, 255, 7, 7, 6, 255, 7, 7, 6, 7, 6, 6, 5, 255, 7, 7, 6, 7, 6, 6, 5, 7, 6, 6, 5, 6, 5, 5, 4, }, { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 5, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 6, 255, 6, 6, 5, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 5, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 6, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 6, 255, 255, 255, 7, 255, 7, 7, 6, 255, 7, 7, 6, 7, 6, 6, 5, }, { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 6, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 255, 255, 255, 255, 7, 255, 255, 255, 7, 255, 7, 7, 6, }, { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, }}; uint32 nth_bit(const uint64 v, uint32 r) { DCHECK_NE(v, 0); DCHECK_LE(0, r); DCHECK_LT(r, __builtin_popcountll(v)); uint32 next_byte = v & 255; uint32 byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return nth_bit_bit_pos[r][next_byte]; r -= byte_popcount; next_byte = (v >> 8) & 255; byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return 8 + nth_bit_bit_pos[r][next_byte]; r -= byte_popcount; next_byte = (v >> 16) & 255; byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return 16 + nth_bit_bit_pos[r][next_byte]; r -= byte_popcount; next_byte = (v >> 24) & 255; byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return 24 + nth_bit_bit_pos[r][next_byte]; r -= byte_popcount; next_byte = (v >> 32) & 255; byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return 32 + nth_bit_bit_pos[r][next_byte]; r -= byte_popcount; next_byte = (v >> 40) & 255; byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return 40 + nth_bit_bit_pos[r][next_byte]; r -= byte_popcount; next_byte = (v >> 48) & 255; byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return 48 + nth_bit_bit_pos[r][next_byte]; r -= byte_popcount; next_byte = (v >> 56) & 255; byte_popcount = nth_bit_bit_count[next_byte]; if (r < byte_popcount) return 56 + nth_bit_bit_pos[r][next_byte]; return -1; } #elif SIZE_MAX == UINT64_MAX // 64-bit, non-BMI2 // These tables are generated using: // // constexpr uint64 kOnesStep8 = 0x0101010101010101; // printf("const uint64 kPrefixSumOverflow[64] = {\n"); // for (int k = 0; k < 64; ++k) { // printf(" 0x%" FST_LL_FORMAT "x,\n", (0x7F - k) * kOnesStep8); // } // printf("};\n"); // // printf("const uint8 kSelectInByte[8 * 256] = {\n"); // for (int j = 0; j < 8; ++j) { // for (int i = 0; i < 256; ++i) { // if (i > 0) printf(" "); // if (i % 16 == 0) printf("\n "); // const int k = findbitn(i, j); // printf("%d,", k == -1 ? 0 : k); // } // printf("\n"); // } // printf("};\n"); // namespace internal { // clang-format off const uint64 kPrefixSumOverflow[64] = { 0x7f7f7f7f7f7f7f7f, 0x7e7e7e7e7e7e7e7e, 0x7d7d7d7d7d7d7d7d, 0x7c7c7c7c7c7c7c7c, 0x7b7b7b7b7b7b7b7b, 0x7a7a7a7a7a7a7a7a, 0x7979797979797979, 0x7878787878787878, 0x7777777777777777, 0x7676767676767676, 0x7575757575757575, 0x7474747474747474, 0x7373737373737373, 0x7272727272727272, 0x7171717171717171, 0x7070707070707070, 0x6f6f6f6f6f6f6f6f, 0x6e6e6e6e6e6e6e6e, 0x6d6d6d6d6d6d6d6d, 0x6c6c6c6c6c6c6c6c, 0x6b6b6b6b6b6b6b6b, 0x6a6a6a6a6a6a6a6a, 0x6969696969696969, 0x6868686868686868, 0x6767676767676767, 0x6666666666666666, 0x6565656565656565, 0x6464646464646464, 0x6363636363636363, 0x6262626262626262, 0x6161616161616161, 0x6060606060606060, 0x5f5f5f5f5f5f5f5f, 0x5e5e5e5e5e5e5e5e, 0x5d5d5d5d5d5d5d5d, 0x5c5c5c5c5c5c5c5c, 0x5b5b5b5b5b5b5b5b, 0x5a5a5a5a5a5a5a5a, 0x5959595959595959, 0x5858585858585858, 0x5757575757575757, 0x5656565656565656, 0x5555555555555555, 0x5454545454545454, 0x5353535353535353, 0x5252525252525252, 0x5151515151515151, 0x5050505050505050, 0x4f4f4f4f4f4f4f4f, 0x4e4e4e4e4e4e4e4e, 0x4d4d4d4d4d4d4d4d, 0x4c4c4c4c4c4c4c4c, 0x4b4b4b4b4b4b4b4b, 0x4a4a4a4a4a4a4a4a, 0x4949494949494949, 0x4848484848484848, 0x4747474747474747, 0x4646464646464646, 0x4545454545454545, 0x4444444444444444, 0x4343434343434343, 0x4242424242424242, 0x4141414141414141, 0x4040404040404040 }; const uint8 kSelectInByte[8 * 256] = { 0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 0, 0, 0, 1, 0, 2, 2, 1, 0, 3, 3, 1, 3, 2, 2, 1, 0, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 0, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 0, 6, 6, 1, 6, 2, 2, 1, 6, 3, 3, 1, 3, 2, 2, 1, 6, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 6, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 0, 7, 7, 1, 7, 2, 2, 1, 7, 3, 3, 1, 3, 2, 2, 1, 7, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 7, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 7, 6, 6, 1, 6, 2, 2, 1, 6, 3, 3, 1, 3, 2, 2, 1, 6, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 6, 5, 5, 1, 5, 2, 2, 1, 5, 3, 3, 1, 3, 2, 2, 1, 5, 4, 4, 1, 4, 2, 2, 1, 4, 3, 3, 1, 3, 2, 2, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 3, 3, 2, 0, 0, 0, 4, 0, 4, 4, 2, 0, 4, 4, 3, 4, 3, 3, 2, 0, 0, 0, 5, 0, 5, 5, 2, 0, 5, 5, 3, 5, 3, 3, 2, 0, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 0, 0, 0, 6, 0, 6, 6, 2, 0, 6, 6, 3, 6, 3, 3, 2, 0, 6, 6, 4, 6, 4, 4, 2, 6, 4, 4, 3, 4, 3, 3, 2, 0, 6, 6, 5, 6, 5, 5, 2, 6, 5, 5, 3, 5, 3, 3, 2, 6, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 0, 0, 0, 7, 0, 7, 7, 2, 0, 7, 7, 3, 7, 3, 3, 2, 0, 7, 7, 4, 7, 4, 4, 2, 7, 4, 4, 3, 4, 3, 3, 2, 0, 7, 7, 5, 7, 5, 5, 2, 7, 5, 5, 3, 5, 3, 3, 2, 7, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 0, 7, 7, 6, 7, 6, 6, 2, 7, 6, 6, 3, 6, 3, 3, 2, 7, 6, 6, 4, 6, 4, 4, 2, 6, 4, 4, 3, 4, 3, 3, 2, 7, 6, 6, 5, 6, 5, 5, 2, 6, 5, 5, 3, 5, 3, 3, 2, 6, 5, 5, 4, 5, 4, 4, 2, 5, 4, 4, 3, 4, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 4, 4, 3, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 5, 5, 3, 0, 0, 0, 5, 0, 5, 5, 4, 0, 5, 5, 4, 5, 4, 4, 3, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 6, 6, 3, 0, 0, 0, 6, 0, 6, 6, 4, 0, 6, 6, 4, 6, 4, 4, 3, 0, 0, 0, 6, 0, 6, 6, 5, 0, 6, 6, 5, 6, 5, 5, 3, 0, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 3, 0, 0, 0, 7, 0, 7, 7, 4, 0, 7, 7, 4, 7, 4, 4, 3, 0, 0, 0, 7, 0, 7, 7, 5, 0, 7, 7, 5, 7, 5, 5, 3, 0, 7, 7, 5, 7, 5, 5, 4, 7, 5, 5, 4, 5, 4, 4, 3, 0, 0, 0, 7, 0, 7, 7, 6, 0, 7, 7, 6, 7, 6, 6, 3, 0, 7, 7, 6, 7, 6, 6, 4, 7, 6, 6, 4, 6, 4, 4, 3, 0, 7, 7, 6, 7, 6, 6, 5, 7, 6, 6, 5, 6, 5, 5, 3, 7, 6, 6, 5, 6, 5, 5, 4, 6, 5, 5, 4, 5, 4, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 6, 6, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 6, 6, 5, 0, 0, 0, 6, 0, 6, 6, 5, 0, 6, 6, 5, 6, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 4, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 5, 0, 0, 0, 7, 0, 7, 7, 5, 0, 7, 7, 5, 7, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 6, 0, 0, 0, 7, 0, 7, 7, 6, 0, 7, 7, 6, 7, 6, 6, 4, 0, 0, 0, 7, 0, 7, 7, 6, 0, 7, 7, 6, 7, 6, 6, 5, 0, 7, 7, 6, 7, 6, 6, 5, 7, 6, 6, 5, 6, 5, 5, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 6, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 6, 0, 0, 0, 7, 0, 7, 7, 6, 0, 7, 7, 6, 7, 6, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 7, 7, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7 }; // clang-format on } // namespace internal #endif // 64-bit, non-BMI2 #endif // !defined(__BMI2__) } // namespace fst openfst-1.7.9/src/extensions/pdt/000077500000000000000000000000001421600557100167645ustar00rootroot00000000000000openfst-1.7.9/src/extensions/pdt/Makefile.am000066400000000000000000000016071421600557100210240ustar00rootroot00000000000000AM_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 pdtcompose-main.cc pdtexpand_SOURCES = pdtexpand.cc pdtexpand-main.cc pdtinfo_SOURCES = pdtinfo.cc pdtinfo-main.cc pdtreplace_SOURCES = pdtreplace.cc pdtreplace-main.cc pdtreverse_SOURCES = pdtreverse.cc pdtreverse-main.cc pdtshortestpath_SOURCES = pdtshortestpath.cc pdtshortestpath-main.cc endif if HAVE_SCRIPT lib_LTLIBRARIES = libfstpdtscript.la libfstpdtscript_la_SOURCES = getters.cc pdtscript.cc libfstpdtscript_la_LDFLAGS = -version-info 22:0:0 libfstpdtscript_la_LIBADD = ../../script/libfstscript.la \ ../../lib/libfst.la -lm $(DL_LIBS) endif openfst-1.7.9/src/extensions/pdt/Makefile.in000066400000000000000000000760141421600557100210410ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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)" "$(DESTDIR)$(libdir)" PROGRAMS = $(bin_PROGRAMS) 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; }; \ } 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) am__pdtcompose_SOURCES_DIST = pdtcompose.cc pdtcompose-main.cc @HAVE_BIN_TRUE@am_pdtcompose_OBJECTS = pdtcompose.$(OBJEXT) \ @HAVE_BIN_TRUE@ pdtcompose-main.$(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 pdtexpand-main.cc @HAVE_BIN_TRUE@am_pdtexpand_OBJECTS = pdtexpand.$(OBJEXT) \ @HAVE_BIN_TRUE@ pdtexpand-main.$(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 pdtinfo-main.cc @HAVE_BIN_TRUE@am_pdtinfo_OBJECTS = pdtinfo.$(OBJEXT) \ @HAVE_BIN_TRUE@ pdtinfo-main.$(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 pdtreplace-main.cc @HAVE_BIN_TRUE@am_pdtreplace_OBJECTS = pdtreplace.$(OBJEXT) \ @HAVE_BIN_TRUE@ pdtreplace-main.$(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 pdtreverse-main.cc @HAVE_BIN_TRUE@am_pdtreverse_OBJECTS = pdtreverse.$(OBJEXT) \ @HAVE_BIN_TRUE@ pdtreverse-main.$(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 \ pdtshortestpath-main.cc @HAVE_BIN_TRUE@am_pdtshortestpath_OBJECTS = pdtshortestpath.$(OBJEXT) \ @HAVE_BIN_TRUE@ pdtshortestpath-main.$(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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/getters.Plo \ ./$(DEPDIR)/pdtcompose-main.Po ./$(DEPDIR)/pdtcompose.Po \ ./$(DEPDIR)/pdtexpand-main.Po ./$(DEPDIR)/pdtexpand.Po \ ./$(DEPDIR)/pdtinfo-main.Po ./$(DEPDIR)/pdtinfo.Po \ ./$(DEPDIR)/pdtreplace-main.Po ./$(DEPDIR)/pdtreplace.Po \ ./$(DEPDIR)/pdtreverse-main.Po ./$(DEPDIR)/pdtreverse.Po \ ./$(DEPDIR)/pdtscript.Plo ./$(DEPDIR)/pdtshortestpath-main.Po \ ./$(DEPDIR)/pdtshortestpath.Po 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 pdtcompose-main.cc @HAVE_BIN_TRUE@pdtexpand_SOURCES = pdtexpand.cc pdtexpand-main.cc @HAVE_BIN_TRUE@pdtinfo_SOURCES = pdtinfo.cc pdtinfo-main.cc @HAVE_BIN_TRUE@pdtreplace_SOURCES = pdtreplace.cc pdtreplace-main.cc @HAVE_BIN_TRUE@pdtreverse_SOURCES = pdtreverse.cc pdtreverse-main.cc @HAVE_BIN_TRUE@pdtshortestpath_SOURCES = pdtshortestpath.cc pdtshortestpath-main.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 22: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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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 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) 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtcompose-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtcompose.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtexpand-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtexpand.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtinfo-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtinfo.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreplace-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreplace.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreverse-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreverse.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtscript.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtshortestpath-main.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtshortestpath.Po@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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) $(LTLIBRARIES) install-binPROGRAMS: install-libLTLIBRARIES installdirs: for dir in "$(DESTDIR)$(bindir)" "$(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-binPROGRAMS clean-generic clean-libLTLIBRARIES \ clean-libtool mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/getters.Plo -rm -f ./$(DEPDIR)/pdtcompose-main.Po -rm -f ./$(DEPDIR)/pdtcompose.Po -rm -f ./$(DEPDIR)/pdtexpand-main.Po -rm -f ./$(DEPDIR)/pdtexpand.Po -rm -f ./$(DEPDIR)/pdtinfo-main.Po -rm -f ./$(DEPDIR)/pdtinfo.Po -rm -f ./$(DEPDIR)/pdtreplace-main.Po -rm -f ./$(DEPDIR)/pdtreplace.Po -rm -f ./$(DEPDIR)/pdtreverse-main.Po -rm -f ./$(DEPDIR)/pdtreverse.Po -rm -f ./$(DEPDIR)/pdtscript.Plo -rm -f ./$(DEPDIR)/pdtshortestpath-main.Po -rm -f ./$(DEPDIR)/pdtshortestpath.Po -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 -f ./$(DEPDIR)/getters.Plo -rm -f ./$(DEPDIR)/pdtcompose-main.Po -rm -f ./$(DEPDIR)/pdtcompose.Po -rm -f ./$(DEPDIR)/pdtexpand-main.Po -rm -f ./$(DEPDIR)/pdtexpand.Po -rm -f ./$(DEPDIR)/pdtinfo-main.Po -rm -f ./$(DEPDIR)/pdtinfo.Po -rm -f ./$(DEPDIR)/pdtreplace-main.Po -rm -f ./$(DEPDIR)/pdtreplace.Po -rm -f ./$(DEPDIR)/pdtreverse-main.Po -rm -f ./$(DEPDIR)/pdtreverse.Po -rm -f ./$(DEPDIR)/pdtscript.Plo -rm -f ./$(DEPDIR)/pdtshortestpath-main.Po -rm -f ./$(DEPDIR)/pdtshortestpath.Po -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/pdt/getters.cc000066400000000000000000000013621421600557100207520ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include namespace fst { namespace script { bool GetPdtComposeFilter(const std::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 std::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 openfst-1.7.9/src/extensions/pdt/pdtcompose-main.cc000066400000000000000000000044371421600557100224020ustar00rootroot00000000000000// 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 #include #include DECLARE_string(pdt_parentheses); DECLARE_bool(left_pdt); DECLARE_bool(connect); DECLARE_string(compose_filter); int pdtcompose_main(int argc, char **argv) { namespace s = fst::script; using fst::PdtComposeFilter; using fst::PdtComposeOptions; using fst::ReadLabelPairs; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1]; const std::string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2]; const std::string out_name = argc > 3 && strcmp(argv[3], "-") != 0 ? 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); return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/pdt/pdtcompose.cc000066400000000000000000000011241421600557100214460ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Composes a PDT and an FST. #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 pdtcompose_main(int argc, char **argv); int main(int argc, char **argv) { return pdtcompose_main(argc, argv); } openfst-1.7.9/src/extensions/pdt/pdtexpand-main.cc000066400000000000000000000035721421600557100222130ustar00rootroot00000000000000// 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 #include #include DECLARE_string(pdt_parentheses); DECLARE_bool(connect); DECLARE_bool(keep_parentheses); DECLARE_string(weight); int pdtexpand_main(int argc, char **argv) { namespace s = fst::script; using fst::ReadLabelPairs; using fst::script::FstClass; using fst::script::VectorFstClass; using fst::script::WeightClass; std::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 std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; const std::string out_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? 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)); return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/pdt/pdtexpand.cc000066400000000000000000000010131421600557100212550ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Expands a (bounded-stack) PDT as an FST. #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 pdtexpand_main(int argc, char **argv); int main(int argc, char **argv) { return pdtexpand_main(argc, argv); } openfst-1.7.9/src/extensions/pdt/pdtinfo-main.cc000066400000000000000000000024731421600557100216660ustar00rootroot00000000000000// 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 #include #include DECLARE_string(pdt_parentheses); int pdtinfo_main(int argc, char **argv) { namespace s = fst::script; using fst::ReadLabelPairs; using fst::script::FstClass; std::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 std::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; } openfst-1.7.9/src/extensions/pdt/pdtinfo.cc000066400000000000000000000006311421600557100207360ustar00rootroot00000000000000// 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 DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); int pdtinfo_main(int argc, char **argv); int main(int argc, char **argv) { return pdtinfo_main(argc, argv); } openfst-1.7.9/src/extensions/pdt/pdtreplace-main.cc000066400000000000000000000054251421600557100223460ustar00rootroot00000000000000// 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 #include #include DECLARE_string(pdt_parentheses); DECLARE_string(pdt_parser_type); DECLARE_int64(start_paren_labels); DECLARE_string(left_paren_prefix); DECLARE_string(right_paren_prefix); namespace fst { namespace script { namespace { void Cleanup(std::vector> *pairs) { for (const auto &pair : *pairs) delete pair.second; pairs->clear(); } } // namespace } // namespace script } // namespace fst int pdtreplace_main(int argc, char **argv) { namespace s = fst::script; using fst::PdtParserType; using fst::WriteLabelPairs; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in_name = argv[1]; const std::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) { s::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); s::Cleanup(&pairs); if (!FLAGS_pdt_parentheses.empty()) { if (!WriteLabelPairs(FLAGS_pdt_parentheses, parens)) return 1; } return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/pdt/pdtreplace.cc000066400000000000000000000020161421600557100214150ustar00rootroot00000000000000// 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 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"); int pdtreplace_main(int argc, char **argv); int main(int argc, char **argv) { return pdtreplace_main(argc, argv); } openfst-1.7.9/src/extensions/pdt/pdtreverse-main.cc000066400000000000000000000026521421600557100224050ustar00rootroot00000000000000// 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 #include #include DECLARE_string(pdt_parentheses); int pdtreverse_main(int argc, char **argv) { namespace s = fst::script; using fst::ReadLabelPairs; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; const std::string out_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? 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); return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/pdt/pdtreverse.cc000066400000000000000000000005201421600557100214530ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Reverses a PDT. #include DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs"); int pdtreverse_main(int argc, char **argv); int main(int argc, char **argv) { return pdtreverse_main(argc, argv); } openfst-1.7.9/src/extensions/pdt/pdtscript.cc000066400000000000000000000100161421600557100213050ustar00rootroot00000000000000// 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 #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); } REGISTER_FST_OPERATION_3ARCS(PdtCompose, PdtComposeArgs); 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); } REGISTER_FST_OPERATION_3ARCS(PdtExpand, PdtExpandArgs); 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 std::string &left_paren_prefix, const std::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); } REGISTER_FST_OPERATION_3ARCS(PdtReplace, PdtReplaceArgs); void PdtReverse(const FstClass &ifst, const std::vector> &parens, MutableFstClass *ofst) { PdtReverseArgs args(ifst, parens, ofst); Apply>("PdtReverse", ifst.ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(PdtReverse, PdtReverseArgs); 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); } REGISTER_FST_OPERATION_3ARCS(PdtShortestPath, PdtShortestPathArgs); void PrintPdtInfo(const FstClass &ifst, const std::vector> &parens) { PrintPdtInfoArgs args(ifst, parens); Apply>("PrintPdtInfo", ifst.ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(PrintPdtInfo, PrintPdtInfoArgs); } // namespace script } // namespace fst openfst-1.7.9/src/extensions/pdt/pdtshortestpath-main.cc000066400000000000000000000040311421600557100234530ustar00rootroot00000000000000// 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 #include #include DECLARE_bool(keep_parentheses); DECLARE_string(queue_type); DECLARE_bool(path_gc); DECLARE_string(pdt_parentheses); int pdtshortestpath_main(int argc, char **argv) { namespace s = fst::script; using fst::QueueType; using fst::ReadLabelPairs; using fst::script::FstClass; using fst::script::VectorFstClass; std::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 std::string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : ""; const std::string out_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? 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); return !ofst.Write(out_name); } openfst-1.7.9/src/extensions/pdt/pdtshortestpath.cc000066400000000000000000000012011421600557100225250ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Returns the shortest path in a (bounded-stack) PDT. #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 pdtshortestpath_main(int argc, char **argv); int main(int argc, char **argv) { return pdtshortestpath_main(argc, argv); } openfst-1.7.9/src/extensions/python/000077500000000000000000000000001421600557100175165ustar00rootroot00000000000000openfst-1.7.9/src/extensions/python/Makefile.am000066400000000000000000000015141421600557100215530ustar00rootroot00000000000000# NB: we use the Cython-generated .cpp files rather than the *.pxd/.pyx sources # used to generate them. Consequently, modifications to the .pyx files will not # influence the build unless the .cpp files are regenerated using Cython. python_LTLIBRARIES = pywrapfst.la pyexec_LTILIBRARIES = pywrapfst.la pywrapfst_la_SOURCES = pywrapfst.cpp pywrapfst_la_CPPFLAGS = -I$(srcdir)/../../include $(PYTHON_CPPFLAGS) pywrapfst_la_CXXFLAGS = -fexceptions pywrapfst_la_LDFLAGS = -avoid-version -module pywrapfst_la_LIBADD = ../far/libfstfarscript.la ../far/libfstfar.la \ ../../script/libfstscript.la ../../lib/libfst.la \ -lm $(DL_LIBS) $(PYTHON_LIBS) # Exports the *.pxd/*.pxd source files. EXTRA_DIST = cintegral_types.pxd cios.pxd cpywrapfst.pxd \ cutility.pxd pywrapfst.pxd pywrapfst.pyx openfst-1.7.9/src/extensions/python/Makefile.in000066400000000000000000000560611421600557100215730ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 .cpp files rather than the *.pxd/.pyx sources # used to generate them. Consequently, modifications to the .pyx files will not # influence the build unless the .cpp files are regenerated using Cython. VPATH = @srcdir@ am__is_gnu_make = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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__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) $(pywrapfst_la_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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/pywrapfst_la-pywrapfst.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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.cpp pywrapfst_la_CPPFLAGS = -I$(srcdir)/../../include $(PYTHON_CPPFLAGS) pywrapfst_la_CXXFLAGS = -fexceptions pywrapfst_la_LDFLAGS = -avoid-version -module pywrapfst_la_LIBADD = ../far/libfstfarscript.la ../far/libfstfar.la \ ../../script/libfstscript.la ../../lib/libfst.la \ -lm $(DL_LIBS) $(PYTHON_LIBS) # Exports the *.pxd/*.pxd source files. EXTRA_DIST = cintegral_types.pxd cios.pxd cpywrapfst.pxd \ cutility.pxd pywrapfst.pxd pywrapfst.pyx all: all-am .SUFFIXES: .SUFFIXES: .cpp .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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .cpp.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 $@ $< .cpp.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) '$<'` .cpp.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.cpp @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) $(pywrapfst_la_CXXFLAGS) $(CXXFLAGS) -MT pywrapfst_la-pywrapfst.lo -MD -MP -MF $(DEPDIR)/pywrapfst_la-pywrapfst.Tpo -c -o pywrapfst_la-pywrapfst.lo `test -f 'pywrapfst.cpp' || echo '$(srcdir)/'`pywrapfst.cpp @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.cpp' 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) $(pywrapfst_la_CXXFLAGS) $(CXXFLAGS) -c -o pywrapfst_la-pywrapfst.lo `test -f 'pywrapfst.cpp' || echo '$(srcdir)/'`pywrapfst.cpp 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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/pywrapfst_la-pywrapfst.Plo -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 -f ./$(DEPDIR)/pywrapfst_la-pywrapfst.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/python/cintegral_types.pxd000066400000000000000000000006341421600557100234320ustar00rootroot00000000000000#cython: language_level=3 # See www.openfst.org for extensive documentation on this weighted # finite-state transducer library. from libc.stdint cimport * cdef extern from "base/integral_types.h" 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 openfst-1.7.9/src/extensions/python/cios.pxd000066400000000000000000000027701421600557100211760ustar00rootroot00000000000000#cython: language_level=3 # See www.openfst.org for extensive documentation on this weighted # finite-state transducer library. from libcpp.string cimport string from cintegral_types cimport int8 from cintegral_types cimport int16 from cintegral_types cimport int32 from cintegral_types cimport int64 from cintegral_types cimport uint8 from cintegral_types cimport uint16 from cintegral_types cimport uint32 from cintegral_types 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 cintegral_types. 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) openfst-1.7.9/src/extensions/python/cpywrapfst.pxd000066400000000000000000000470521421600557100224450ustar00rootroot00000000000000#cython: language_level=3 # See www.openfst.org for extensive documentation on this weighted # finite-state transducer library. from libcpp cimport bool from libcpp.string cimport string from libcpp.vector cimport vector from libcpp.utility cimport pair from cios cimport * from cintegral_types cimport * cdef extern from "" nogil: 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 uint8 kArcILabelValue const uint8 kArcOLabelValue const uint8 kArcWeightValue const uint8 kArcNextStateValue const uint8 kArcNoCache const uint8 kArcValueFlags const uint8 kArcFlags # EncodeMapper flags. const uint8 kEncodeLabels const uint8 kEncodeWeights const uint8 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 # TODO(wolfsonkin): Don't do this hack if Cython gets proper enum class # support: https://github.com/cython/cython/issues/1603 ctypedef enum ProjectType: PROJECT_INPUT "fst::ProjectType::INPUT" PROJECT_OUTPUT "fst::ProjectType::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) # This is actually a nested class, but Cython doesn't need to know that. cdef cppclass SymbolTableIterator "fst::SymbolTable::iterator": SymbolTableIterator(const SymbolTableIterator &) cppclass value_type: int64 Label() string Symbol() # When wrapped in a unique_ptr siter.Label() and siter.Symbol() are # ambiguous to Cython because there's no way to make the -> explicit. # This hacks around that. const value_type &Pair "operator*"() SymbolTableIterator &operator++() bool operator==(const SymbolTableIterator &, const SymbolTableIterator &) bool operator!=(const SymbolTableIterator &, const SymbolTableIterator &) # Symbol tables. cdef cppclass SymbolTable: @staticmethod int64 kNoSymbol SymbolTable() SymbolTable(const string &) @staticmethod SymbolTable *Read(const string &) # Aliased for overload. @staticmethod SymbolTable *ReadStream "Read"(istream &, 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"(const string &) # Aliased for overload. bool MemberSymbol "Member"(const 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(ostream &) bool Write(const string &) bool WriteText(ostream &) bool WriteText(const string &) SymbolTableIterator begin() SymbolTableIterator end() int64 AvailableKey() size_t NumSymbols() SymbolTable *CompactSymbolTable(const SymbolTable &syms) SymbolTable *MergeSymbolTable(const SymbolTable &, const SymbolTable &, bool *) SymbolTable *FstReadSymbols(const string &, bool) # TODO(wolfsonkin): Don't do this hack if Cython gets proper enum class # support: https://github.com/cython/cython/issues/1603. ctypedef enum TokenType: SYMBOL "fst::TokenType::SYMBOL" BYTE "fst::TokenType::BYTE" UTF8 "fst::TokenType::UTF8" cdef extern from "" namespace "fst::script" nogil: cdef cppclass WeightClass: WeightClass() WeightClass(const WeightClass &) WeightClass(const string &, const string &) const string &Type() string ToString() bool Member() @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) cdef cppclass ArcClass: ArcClass(const ArcClass &) ArcClass(int64, int64, const WeightClass &, int64) int64 ilabel int64 olabel WeightClass weight int64 nextstate cdef cppclass FstClass: FstClass(const FstClass &) @staticmethod FstClass *Read(const string &) # Aliased for overload. @staticmethod FstClass *ReadStream "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() void AddStates(size_t) 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(const SymbolTable *) void SetOutputSymbols(const SymbolTable *) void SetProperties(uint64, uint64) cdef cppclass VectorFstClass(MutableFstClass): VectorFstClass(const FstClass &) VectorFstClass(const string &) 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() const string &WeightType() uint32 Flags() uint64 Properties(uint64) @staticmethod EncodeMapperClass *Read(const string &) # Aliased for overload. @staticmethod EncodeMapperClass *ReadStream "Read"(istream &, const string &) bool Write(const string &) # Aliased for overload. bool WriteStream "Write"(ostream &, const string &) const SymbolTable *InputSymbols() const SymbolTable *OutputSymbols() void SetInputSymbols(const SymbolTable *) void SetOutputSymbols(const SymbolTable *) cdef cppclass ArcIteratorClass: ArcIteratorClass(const FstClass &, int64) bool Done() ArcClass Value() void Next() void Reset() void Seek(size_t) size_t Position() uint8 Flags() void SetFlags(uint8, uint8) 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() uint8 Flags() void SetFlags(uint8, uint8) 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 Draw(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 bool GetProjectType(const string &, ProjectType *) cdef void Project(MutableFstClass *, ProjectType) cdef void Print(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 *, uint8 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, const RandGenOptions[RandArcSelection] &, float, uint64) cdef void RandGen(const FstClass &, MutableFstClass *, const RandGenOptions[RandArcSelection] &, uint64) 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 vector[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 uint8 GetEncodeFlags(bool, bool) cdef bool GetMapType(const string &, MapType *) cdef uint8 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 bool GetTokenType(const string &, TokenType *) cdef extern from "" namespace "fst" nogil: # TODO(wolfsonkin): Don't do this hack if Cython gets proper enum class # support: https://github.com/cython/cython/issues/1603 ctypedef enum FarType: FAR_DEFAULT "fst::FarType::DEFAULT" FAR_STTABLE "fst::FarType::STTABLE" FAR_STLIST "fst::FarType::STLIST" FAR_FST "fst::FarType::FST" FAR_SSTABLE "fst::FarType::SSTABLE" cdef extern from "" \ namespace "fst" nogil: string GetFarTypeString(FarType) cdef extern from "" \ namespace "fst::script" nogil: bool GetFarType(const string &, FarType *) 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) openfst-1.7.9/src/extensions/python/cutility.pxd000066400000000000000000000014021421600557100220760ustar00rootroot00000000000000#cython: language_level=3 # See www.openfst.org for extensive documentation on this weighted # finite-state transducer library. #TODO(kbg): When/if PR https://github.com/cython/cython/pull/3358 is merged # and we update third-party Cython up to or beyond a version that includes # this, delete this file and instead use libcpp.utility.move. cdef extern from * namespace "fst": """ #include #include namespace fst { template inline typename std::remove_reference::type &&move(T &t) { return std::move(t); } template inline typename std::remove_reference::type &&move(T &&t) { return std::move(t); } } // namespace fst """ cdef T move[T](T) openfst-1.7.9/src/extensions/python/pywrapfst.cpp000066400000000000000000116732121421600557100222760ustar00rootroot00000000000000/* Generated by Cython 0.29.21 */ #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_29_21" #define CYTHON_HEX_VERSION 0x001D15F0 #define CYTHON_FUTURE_DIVISION 1 #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 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 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 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 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 (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #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 #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #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 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" #if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #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) #endif #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 #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *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 | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #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_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(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 #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 PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #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 CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #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) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #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 #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? 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 #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #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 #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #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) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #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 #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_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) 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 /* Early includes */ #include "ios" #include "new" #include "stdexcept" #include "typeinfo" #include #include #include #include #if __cplusplus > 199711L #include namespace cython_std { template typename std::remove_reference::type&& move(T& t) noexcept { return std::move(t); } template typename std::remove_reference::type&& move(T&& t) noexcept { return std::move(t); } } #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace fst { template inline typename std::remove_reference::type &&move(T &t) { return std::move(t); } template inline typename std::remove_reference::type &&move(T &&t) { return std::move(t); } } // namespace fst #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_UTF8 1 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "utf8" #define __Pyx_PyObject_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyUnicode_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))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #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) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(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) + 1); 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 = NULL; 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", }; /*--- Type declarations ---*/ struct __pyx_obj_9pywrapfst_Weight; struct __pyx_obj_9pywrapfst_SymbolTableView; struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView; struct __pyx_obj_9pywrapfst__FstSymbolTableView; struct __pyx_obj_9pywrapfst__MutableSymbolTable; struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView; 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_VectorFst; 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; struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__; /* "cpywrapfst.pxd":507 * * * ctypedef pair[int64, const FstClass *] LabelFstClassPair # <<<<<<<<<<<<<< * * ctypedef pair[int64, int64] LabelPair */ typedef std::pair __pyx_t_10cpywrapfst_LabelFstClassPair; /* "cpywrapfst.pxd":509 * ctypedef pair[int64, const FstClass *] LabelFstClassPair * * ctypedef pair[int64, int64] LabelPair # <<<<<<<<<<<<<< * * */ typedef std::pair __pyx_t_10cpywrapfst_LabelPair; struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol; struct __pyx_opt_args_9pywrapfst_3Fst_draw; struct __pyx_opt_args_9pywrapfst_3Fst_print; struct __pyx_opt_args_9pywrapfst_10MutableFst__arcsort; struct __pyx_opt_args_9pywrapfst_10MutableFst__closure; struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_arcs; struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_states; struct __pyx_opt_args_9pywrapfst_10MutableFst__minimize; struct __pyx_opt_args_9pywrapfst_10MutableFst__prune; struct __pyx_opt_args_9pywrapfst_10MutableFst__push; struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_pairs; struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_tables; struct __pyx_opt_args_9pywrapfst_10MutableFst__reweight; struct __pyx_opt_args_9pywrapfst_10MutableFst__rmepsilon; struct __pyx_opt_args_9pywrapfst_10MutableFst__set_final; 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":103 * # SymbolTable. * * ctypedef fst.SymbolTable * SymbolTable_ptr # <<<<<<<<<<<<<< * ctypedef const fst.SymbolTable * const_SymbolTable_ptr * */ typedef fst::SymbolTable *__pyx_t_9pywrapfst_SymbolTable_ptr; /* "pywrapfst.pxd":104 * * ctypedef fst.SymbolTable * SymbolTable_ptr * ctypedef const fst.SymbolTable * const_SymbolTable_ptr # <<<<<<<<<<<<<< * * */ typedef fst::SymbolTable const *__pyx_t_9pywrapfst_const_SymbolTable_ptr; /* "pywrapfst.pxd":160 * cdef fst.SymbolTable *_mutable_raw_ptr_or_raise(self) except * * * cpdef int64 add_symbol(self, symbol, int64 key=?) except * # <<<<<<<<<<<<<< * * cpdef void add_table(self, SymbolTableView syms) except * */ struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol { int __pyx_n; int64 key; }; /* "pywrapfst.pxd":207 * * * ctypedef fst.EncodeMapperClass * EncodeMapperClass_ptr # <<<<<<<<<<<<<< * * */ typedef fst::script::EncodeMapperClass *__pyx_t_9pywrapfst_EncodeMapperClass_ptr; /* "pywrapfst.pxd":241 * * * ctypedef fst.FstClass * FstClass_ptr # <<<<<<<<<<<<<< * ctypedef const fst.FstClass * const_FstClass_ptr * ctypedef fst.MutableFstClass * MutableFstClass_ptr */ typedef fst::script::FstClass *__pyx_t_9pywrapfst_FstClass_ptr; /* "pywrapfst.pxd":242 * * ctypedef fst.FstClass * FstClass_ptr * ctypedef const fst.FstClass * const_FstClass_ptr # <<<<<<<<<<<<<< * ctypedef fst.MutableFstClass * MutableFstClass_ptr * ctypedef fst.VectorFstClass * VectorFstClass_ptr */ typedef fst::script::FstClass const *__pyx_t_9pywrapfst_const_FstClass_ptr; /* "pywrapfst.pxd":243 * ctypedef fst.FstClass * FstClass_ptr * ctypedef const fst.FstClass * const_FstClass_ptr * ctypedef fst.MutableFstClass * MutableFstClass_ptr # <<<<<<<<<<<<<< * ctypedef fst.VectorFstClass * VectorFstClass_ptr * */ typedef fst::script::MutableFstClass *__pyx_t_9pywrapfst_MutableFstClass_ptr; /* "pywrapfst.pxd":244 * ctypedef const fst.FstClass * const_FstClass_ptr * ctypedef fst.MutableFstClass * MutableFstClass_ptr * ctypedef fst.VectorFstClass * VectorFstClass_ptr # <<<<<<<<<<<<<< * * */ typedef fst::script::VectorFstClass *__pyx_t_9pywrapfst_VectorFstClass_ptr; /* "pywrapfst.pxd":260 * cpdef Fst copy(self) * * cpdef void draw(self, # <<<<<<<<<<<<<< * source, * SymbolTableView isymbols=?, */ struct __pyx_opt_args_9pywrapfst_3Fst_draw { int __pyx_n; struct __pyx_obj_9pywrapfst_SymbolTableView *isymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *osymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *ssymbols; bool acceptor; PyObject *title; double width; double height; bool portrait; bool vertical; double ranksep; double nodesep; int32 fontsize; int32 precision; PyObject *float_format; bool show_weight_one; }; /* "pywrapfst.pxd":292 * cpdef _FstSymbolTableView output_symbols(self) * * cpdef string print(self, # <<<<<<<<<<<<<< * SymbolTableView isymbols=?, * SymbolTableView osymbols=?, */ struct __pyx_opt_args_9pywrapfst_3Fst_print { int __pyx_n; struct __pyx_obj_9pywrapfst_SymbolTableView *isymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *osymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *ssymbols; bool acceptor; bool show_weight_one; PyObject *missing_sym; }; /* "pywrapfst.pxd":325 * cpdef void add_states(self, size_t) * * cdef void _arcsort(self, sort_type=?) except * # <<<<<<<<<<<<<< * * cdef void _closure(self, bool closure_plus=?) */ struct __pyx_opt_args_9pywrapfst_10MutableFst__arcsort { int __pyx_n; PyObject *sort_type; }; /* "pywrapfst.pxd":327 * cdef void _arcsort(self, sort_type=?) except * * * cdef void _closure(self, bool closure_plus=?) # <<<<<<<<<<<<<< * * cdef void _concat(self, Fst fst2) except * */ struct __pyx_opt_args_9pywrapfst_10MutableFst__closure { int __pyx_n; bool closure_plus; }; /* "pywrapfst.pxd":335 * 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_10MutableFst__delete_arcs { int __pyx_n; size_t n; }; /* "pywrapfst.pxd":337 * 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_10MutableFst__delete_states { int __pyx_n; PyObject *states; }; /* "pywrapfst.pxd":343 * cdef void _invert(self) * * cdef void _minimize(self, float delta=?, bool allow_nondet=?) except * # <<<<<<<<<<<<<< * * cpdef MutableArcIterator mutable_arcs(self, int64 state) */ struct __pyx_opt_args_9pywrapfst_10MutableFst__minimize { int __pyx_n; float delta; bool allow_nondet; }; /* "pywrapfst.pxd":351 * cdef void _project(self, project_type) except * * * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except * # <<<<<<<<<<<<<< * * cdef void _push(self, */ struct __pyx_opt_args_9pywrapfst_10MutableFst__prune { int __pyx_n; float delta; int64 nstate; PyObject *weight; }; /* "pywrapfst.pxd":353 * 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_10MutableFst__push { int __pyx_n; float delta; bool remove_total_weight; bool to_final; }; /* "pywrapfst.pxd":358 * bool to_final=?) * * cdef void _relabel_pairs(self, ipairs=?, opairs=?) except * # <<<<<<<<<<<<<< * * cdef void _relabel_tables(self, */ struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_pairs { int __pyx_n; PyObject *ipairs; PyObject *opairs; }; /* "pywrapfst.pxd":360 * cdef void _relabel_pairs(self, ipairs=?, opairs=?) except * * * cdef void _relabel_tables(self, # <<<<<<<<<<<<<< * SymbolTableView old_isymbols=?, * SymbolTableView new_isymbols=?, */ struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_tables { int __pyx_n; struct __pyx_obj_9pywrapfst_SymbolTableView *old_isymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *new_isymbols; PyObject *unknown_isymbol; bool attach_new_isymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *old_osymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *new_osymbols; PyObject *unknown_osymbol; bool attach_new_osymbols; }; /* "pywrapfst.pxd":374 * cdef void _reserve_states(self, int64 n) * * cdef void _reweight(self, potentials, bool to_final=?) except * # <<<<<<<<<<<<<< * * cdef void _rmepsilon(self, */ struct __pyx_opt_args_9pywrapfst_10MutableFst__reweight { int __pyx_n; bool to_final; }; /* "pywrapfst.pxd":376 * cdef void _reweight(self, potentials, bool to_final=?) except * * * cdef void _rmepsilon(self, # <<<<<<<<<<<<<< * queue_type=?, * bool connect=?, */ struct __pyx_opt_args_9pywrapfst_10MutableFst__rmepsilon { int __pyx_n; PyObject *queue_type; bool connect; PyObject *weight; int64 nstate; float delta; }; /* "pywrapfst.pxd":383 * float delta=?) except * * * cdef void _set_final(self, int64 state, weight=?) except * # <<<<<<<<<<<<<< * * cdef void _set_start(self, int64 state) except * */ struct __pyx_opt_args_9pywrapfst_10MutableFst__set_final { int __pyx_n; PyObject *weight; }; /* "pywrapfst.pxd":489 * * * 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":491 * 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, */ struct __pyx_opt_args_9pywrapfst_arcmap { int __pyx_n; float delta; PyObject *map_type; double power; PyObject *weight; }; /* "pywrapfst.pxd":493 * 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_compose { int __pyx_n; PyObject *compose_filter; bool connect; }; /* "pywrapfst.pxd":498 * bool connect=?) * * cpdef Fst convert(Fst ifst, fst_type=?) # <<<<<<<<<<<<<< * * cpdef MutableFst determinize(Fst ifst, */ struct __pyx_opt_args_9pywrapfst_convert { int __pyx_n; PyObject *fst_type; }; /* "pywrapfst.pxd":500 * cpdef Fst convert(Fst ifst, fst_type=?) * * cpdef MutableFst determinize(Fst ifst, # <<<<<<<<<<<<<< * float delta=?, * det_type=?, */ struct __pyx_opt_args_9pywrapfst_determinize { int __pyx_n; float delta; PyObject *det_type; int64 nstate; int64 subsequential_label; PyObject *weight; bool increment_subsequential_label; }; /* "pywrapfst.pxd":508 * bool increment_subsequential_label=?) * * cpdef MutableFst difference(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter=?, */ struct __pyx_opt_args_9pywrapfst_difference { int __pyx_n; PyObject *compose_filter; bool connect; }; /* "pywrapfst.pxd":513 * bool connect=?) * * cpdef MutableFst disambiguate(Fst ifst, # <<<<<<<<<<<<<< * float delta=?, * int64 nstate=?, */ struct __pyx_opt_args_9pywrapfst_disambiguate { int __pyx_n; float delta; int64 nstate; int64 subsequential_label; PyObject *weight; }; /* "pywrapfst.pxd":519 * 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":521 * 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":523 * cpdef bool equal(Fst ifst1, Fst ifst2, float delta=?) * * cpdef bool equivalent(Fst ifst1, Fst ifst2, float delta=?) except * # <<<<<<<<<<<<<< * * cpdef MutableFst intersect(Fst ifst1, */ struct __pyx_opt_args_9pywrapfst_equivalent { int __pyx_n; float delta; }; /* "pywrapfst.pxd":525 * cpdef bool equivalent(Fst ifst1, Fst ifst2, float delta=?) except * * * cpdef MutableFst intersect(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter=?, */ struct __pyx_opt_args_9pywrapfst_intersect { int __pyx_n; PyObject *compose_filter; bool connect; }; /* "pywrapfst.pxd":530 * bool connect=?) * * cpdef bool isomorphic(Fst ifst1, Fst ifst2, float delta=?) # <<<<<<<<<<<<<< * * cpdef MutableFst prune(Fst ifst, */ struct __pyx_opt_args_9pywrapfst_isomorphic { int __pyx_n; float delta; }; /* "pywrapfst.pxd":532 * cpdef bool isomorphic(Fst ifst1, Fst ifst2, float delta=?) * * cpdef MutableFst prune(Fst ifst, # <<<<<<<<<<<<<< * float delta=?, * int64 nstate=?, */ struct __pyx_opt_args_9pywrapfst_prune { int __pyx_n; float delta; int64 nstate; PyObject *weight; }; /* "pywrapfst.pxd":537 * weight=?) * * cpdef MutableFst push(Fst ifst, # <<<<<<<<<<<<<< * float delta=?, * bool push_weights=?, */ 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":545 * bool to_final=?) * * cpdef bool randequivalent(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * int32 npath=?, */ struct __pyx_opt_args_9pywrapfst_randequivalent { int __pyx_n; int32 npath; float delta; PyObject *select; int32 max_length; uint64 seed; }; /* "pywrapfst.pxd":553 * uint64 seed=?) except * * * cpdef MutableFst randgen(Fst ifst, # <<<<<<<<<<<<<< * int32 npath=?, * select=?, */ struct __pyx_opt_args_9pywrapfst_randgen { int __pyx_n; int32 npath; PyObject *select; int32 max_length; bool remove_total_weight; bool weighted; uint64 seed; }; /* "pywrapfst.pxd":561 * uint64 seed=?) * * cpdef MutableFst replace(pairs, # <<<<<<<<<<<<<< * call_arc_labeling=?, * return_arc_labeling=?, */ struct __pyx_opt_args_9pywrapfst_replace { int __pyx_n; PyObject *call_arc_labeling; PyObject *return_arc_labeling; bool epsilon_on_replace; int64 return_label; }; /* "pywrapfst.pxd":567 * int64 return_label=?) * * cpdef MutableFst reverse(Fst ifst, bool require_superinitial=?) # <<<<<<<<<<<<<< * * cdef void _shortestdistance(Fst ifst, */ struct __pyx_opt_args_9pywrapfst_reverse { int __pyx_n; bool require_superinitial; }; /* "pywrapfst.pxd":569 * cpdef MutableFst reverse(Fst ifst, bool require_superinitial=?) * * cdef void _shortestdistance(Fst ifst, # <<<<<<<<<<<<<< * vector[fst.WeightClass] *, * float delta=?, */ struct __pyx_opt_args_9pywrapfst__shortestdistance { int __pyx_n; float delta; int64 nstate; PyObject *queue_type; bool reverse; }; /* "pywrapfst.pxd":576 * bool reverse=?) except * * * cpdef MutableFst shortestpath(Fst ifst, # <<<<<<<<<<<<<< * float delta=?, * int32 nshortest=?, */ struct __pyx_opt_args_9pywrapfst_shortestpath { int __pyx_n; float delta; int32 nshortest; int64 nstate; PyObject *queue_type; bool unique; PyObject *weight; }; /* "pywrapfst.pxd":71 * * * 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":107 * * * cdef class SymbolTableView(object): # <<<<<<<<<<<<<< * * cdef const fst.SymbolTable *_raw(self) */ struct __pyx_obj_9pywrapfst_SymbolTableView { PyObject_HEAD struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *__pyx_vtab; }; /* "pywrapfst.pxd":138 * * * cdef class _EncodeMapperSymbolTableView(SymbolTableView): # <<<<<<<<<<<<<< * * # Indicates whether this view is of an input or output SymbolTable */ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView { struct __pyx_obj_9pywrapfst_SymbolTableView __pyx_base; bool _input_side; std::shared_ptr _mapper; }; /* "pywrapfst.pxd":146 * * * cdef class _FstSymbolTableView(SymbolTableView): # <<<<<<<<<<<<<< * * # Indicates whether this view is of an input or output SymbolTable */ struct __pyx_obj_9pywrapfst__FstSymbolTableView { struct __pyx_obj_9pywrapfst_SymbolTableView __pyx_base; bool _input_side; std::shared_ptr _fst; }; /* "pywrapfst.pxd":154 * * * cdef class _MutableSymbolTable(SymbolTableView): # <<<<<<<<<<<<<< * * cdef fst.SymbolTable *_mutable_raw(self) */ struct __pyx_obj_9pywrapfst__MutableSymbolTable { struct __pyx_obj_9pywrapfst_SymbolTableView __pyx_base; }; /* "pywrapfst.pxd":167 * * * cdef class _MutableFstSymbolTableView(_MutableSymbolTable): # <<<<<<<<<<<<<< * * # Indicates whether this view is of an input or output SymbolTable */ struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView { struct __pyx_obj_9pywrapfst__MutableSymbolTable __pyx_base; bool _input_side; std::shared_ptr _mfst; }; /* "pywrapfst.pxd":175 * * * 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":198 * * * cdef class _SymbolTableIterator(object): # <<<<<<<<<<<<<< * * cdef SymbolTableView _table */ struct __pyx_obj_9pywrapfst__SymbolTableIterator { PyObject_HEAD struct __pyx_obj_9pywrapfst_SymbolTableView *_table; std::unique_ptr _siter; }; /* "pywrapfst.pxd":210 * * * cdef class EncodeMapper(object): # <<<<<<<<<<<<<< * * cdef shared_ptr[fst.EncodeMapperClass] _mapper */ struct __pyx_obj_9pywrapfst_EncodeMapper { PyObject_HEAD struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *__pyx_vtab; std::shared_ptr _mapper; }; /* "pywrapfst.pxd":247 * * * 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":313 * * * 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":394 * * * cdef class VectorFst(MutableFst): # <<<<<<<<<<<<<< * * pass */ struct __pyx_obj_9pywrapfst_VectorFst { struct __pyx_obj_9pywrapfst_MutableFst __pyx_base; }; /* "pywrapfst.pxd":416 * * * 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":426 * * * 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":448 * * * 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":472 * * * 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":592 * * * 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":613 * # 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":638 * # 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":3271 * * # Magic method used to get a Pythonic Iterator API out of the C++ API. * def __iter__(self): # <<<<<<<<<<<<<< * while not self.done(): * yield self.value() */ struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ { PyObject_HEAD struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self; }; /* "pywrapfst.pyx":404 * * * cdef class Weight: # <<<<<<<<<<<<<< * * """ */ 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); bool (*member)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch); }; static struct __pyx_vtabstruct_9pywrapfst_Weight *__pyx_vtabptr_9pywrapfst_Weight; /* "pywrapfst.pyx":731 * * * cdef class SymbolTableView: # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst_SymbolTableView { fst::SymbolTable const *(*_raw)(struct __pyx_obj_9pywrapfst_SymbolTableView *); void (*_raise_nonexistent)(struct __pyx_obj_9pywrapfst_SymbolTableView *); fst::SymbolTable const *(*_raw_ptr_or_raise)(struct __pyx_obj_9pywrapfst_SymbolTableView *); int64 (*available_key)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); PyObject *(*checksum)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); struct __pyx_obj_9pywrapfst_SymbolTable *(*copy)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); int64 (*get_nth_key)(struct __pyx_obj_9pywrapfst_SymbolTableView *, Py_ssize_t, int __pyx_skip_dispatch); PyObject *(*labeled_checksum)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); bool (*member)(struct __pyx_obj_9pywrapfst_SymbolTableView *, PyObject *, int __pyx_skip_dispatch); std::string (*name)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); size_t (*num_symbols)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); void (*write)(struct __pyx_obj_9pywrapfst_SymbolTableView *, PyObject *, int __pyx_skip_dispatch); void (*write_text)(struct __pyx_obj_9pywrapfst_SymbolTableView *, PyObject *, int __pyx_skip_dispatch); PyObject *(*write_to_string)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); }; static struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *__pyx_vtabptr_9pywrapfst_SymbolTableView; /* "pywrapfst.pyx":934 * * * cdef class _EncodeMapperSymbolTableView(SymbolTableView): # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTableView { struct __pyx_vtabstruct_9pywrapfst_SymbolTableView __pyx_base; }; static struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTableView *__pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTableView; /* "pywrapfst.pyx":958 * * * cdef class _FstSymbolTableView(SymbolTableView): # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst__FstSymbolTableView { struct __pyx_vtabstruct_9pywrapfst_SymbolTableView __pyx_base; }; static struct __pyx_vtabstruct_9pywrapfst__FstSymbolTableView *__pyx_vtabptr_9pywrapfst__FstSymbolTableView; /* "pywrapfst.pyx":981 * * * cdef class _MutableSymbolTable(SymbolTableView): # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable { struct __pyx_vtabstruct_9pywrapfst_SymbolTableView __pyx_base; fst::SymbolTable *(*_mutable_raw)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *); fst::SymbolTable *(*_mutable_raw_ptr_or_raise)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *); 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_SymbolTableView *, 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":1053 * * * cdef class _MutableFstSymbolTableView(_MutableSymbolTable): # <<<<<<<<<<<<<< * """ * (No constructor.) */ struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTableView { struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable __pyx_base; }; static struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTableView *__pyx_vtabptr_9pywrapfst__MutableFstSymbolTableView; /* "pywrapfst.pyx":1068 * * * 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":1296 * * * cdef class EncodeMapper: # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst_EncodeMapper { std::string (*arc_type)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); std::string (*weight_type)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); uint8 (*flags)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); void (*write)(struct __pyx_obj_9pywrapfst_EncodeMapper *, PyObject *, int __pyx_skip_dispatch); PyObject *(*write_to_string)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *(*input_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *(*output_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch); void (*_set_input_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst_SymbolTableView *); void (*_set_output_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst_SymbolTableView *); }; static struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *__pyx_vtabptr_9pywrapfst_EncodeMapper; /* "pywrapfst.pyx":1563 * * * cdef class Fst: # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst_Fst { std::string (*_local_render_svg)(std::string const &); std::string (*arc_type)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch); struct __pyx_obj_9pywrapfst_ArcIterator *(*arcs)(struct __pyx_obj_9pywrapfst_Fst *, 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_3Fst_draw *__pyx_optional_args); struct __pyx_obj_9pywrapfst_Weight *(*final)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch); std::string (*fst_type)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch); struct __pyx_obj_9pywrapfst__FstSymbolTableView *(*input_symbols)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch); size_t (*num_arcs)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch); size_t (*num_input_epsilons)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch); size_t (*num_output_epsilons)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch); struct __pyx_obj_9pywrapfst__FstSymbolTableView *(*output_symbols)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch); std::string (*print)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_3Fst_print *__pyx_optional_args); 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); 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); PyObject *(*write_to_string)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch); }; static struct __pyx_vtabstruct_9pywrapfst_Fst *__pyx_vtabptr_9pywrapfst_Fst; /* "pywrapfst.pyx":2028 * * * 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 *, int64, struct __pyx_obj_9pywrapfst_Arc *); int64 (*add_state)(struct __pyx_obj_9pywrapfst_MutableFst *, int __pyx_skip_dispatch); void (*add_states)(struct __pyx_obj_9pywrapfst_MutableFst *, size_t, int __pyx_skip_dispatch); void (*_arcsort)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__arcsort *__pyx_optional_args); void (*_closure)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__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 *, int64, struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_arcs *__pyx_optional_args); void (*_delete_states)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__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_10MutableFst__minimize *__pyx_optional_args); struct __pyx_obj_9pywrapfst_MutableArcIterator *(*mutable_arcs)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, int __pyx_skip_dispatch); int64 (*num_states)(struct __pyx_obj_9pywrapfst_MutableFst *, int __pyx_skip_dispatch); void (*_project)(struct __pyx_obj_9pywrapfst_MutableFst *, PyObject *); void (*_prune)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__prune *__pyx_optional_args); void (*_push)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__push *__pyx_optional_args); void (*_relabel_pairs)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_pairs *__pyx_optional_args); void (*_relabel_tables)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_tables *__pyx_optional_args); void (*_reserve_arcs)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, size_t); void (*_reserve_states)(struct __pyx_obj_9pywrapfst_MutableFst *, int64); void (*_reweight)(struct __pyx_obj_9pywrapfst_MutableFst *, PyObject *, struct __pyx_opt_args_9pywrapfst_10MutableFst__reweight *__pyx_optional_args); void (*_rmepsilon)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__rmepsilon *__pyx_optional_args); void (*_set_final)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, struct __pyx_opt_args_9pywrapfst_10MutableFst__set_final *__pyx_optional_args); void (*_set_start)(struct __pyx_obj_9pywrapfst_MutableFst *, int64); void (*_set_input_symbols)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_obj_9pywrapfst_SymbolTableView *); void (*_set_output_symbols)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_obj_9pywrapfst_SymbolTableView *); void (*_topsort)(struct __pyx_obj_9pywrapfst_MutableFst *); }; static struct __pyx_vtabstruct_9pywrapfst_MutableFst *__pyx_vtabptr_9pywrapfst_MutableFst; /* "pywrapfst.pyx":2890 * * * cdef class VectorFst(MutableFst): # <<<<<<<<<<<<<< * """ * VectorFst(arc_type="standard") */ struct __pyx_vtabstruct_9pywrapfst_VectorFst { struct __pyx_vtabstruct_9pywrapfst_MutableFst __pyx_base; }; static struct __pyx_vtabstruct_9pywrapfst_VectorFst *__pyx_vtabptr_9pywrapfst_VectorFst; /* "pywrapfst.pyx":3073 * * * cdef class Arc: # <<<<<<<<<<<<<< * * """ */ 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":3140 * * * cdef class ArcIterator: # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst_ArcIterator { bool (*done)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch); uint8 (*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 *, uint8, uint8, 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":3251 * * * cdef class MutableArcIterator: # <<<<<<<<<<<<<< * * """ */ struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator { bool (*done)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch); uint8 (*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 *, uint8, uint8, 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":3371 * * * cdef class StateIterator: # <<<<<<<<<<<<<< * * """ */ 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); int64 (*value)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch); }; static struct __pyx_vtabstruct_9pywrapfst_StateIterator *__pyx_vtabptr_9pywrapfst_StateIterator; /* "pywrapfst.pyx":4280 * * * cdef class Compiler: # <<<<<<<<<<<<<< * * """ */ 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":4417 * * * cdef class FarReader: # <<<<<<<<<<<<<< * * """ */ 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":4572 * * * cdef class FarWriter: # <<<<<<<<<<<<<< * * """ */ 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); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* PyObjectFormatSimple.proto */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #elif PY_MAJOR_VERSION < 3 #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ PyObject_Format(s, f)) #elif CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_str(s) :\ likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_str(s) :\ PyObject_Format(s, f)) #else #define __Pyx_PyObject_FormatSimple(s, f) (\ likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ PyObject_Format(s, f)) #endif /* PyObjectFormatAndDecref.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); /* IncludeStringH.proto */ #include /* JoinPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, Py_UCS4 max_char); /* 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, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #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); /* 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); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectFormat.proto */ #if CYTHON_USE_UNICODE_WRITER static PyObject* __Pyx_PyObject_Format(PyObject* s, PyObject* f); #else #define __Pyx_PyObject_Format(s, f) PyObject_Format(s, f) #endif /* 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); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* 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 /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(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); /* 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); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) #endif /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* 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); /* ClassMethod.proto */ #include "descrobject.h" static CYTHON_UNUSED PyObject* __Pyx_Method_ClassMethod(PyObject *method); /* GetNameInClass.proto */ #define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name) static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name); /* SetNameInClass.proto */ #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) #elif CYTHON_COMPILING_IN_CPYTHON #define __Pyx_SetNameInClass(ns, name, value)\ (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) #else #define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) #endif /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto */ #define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ (likely(is_tuple || PyTuple_Check(tuple)) ?\ (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* Globals.proto */ static PyObject* __Pyx_Globals(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_int64_t(int64_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint8_t(uint8_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long 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 int32_t __Pyx_PyInt_As_int32_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE uint8_t __Pyx_PyInt_As_uint8_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *); /* 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 #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); /* PyObjectCallMethod1.proto */ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); /* CoroutineBase.proto */ typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_ExcInfoStruct _PyErr_StackItem #else typedef struct { PyObject *exc_type; PyObject *exc_value; PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif typedef struct { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; __Pyx_ExcInfoStruct gi_exc_state; PyObject *gi_weakreflist; PyObject *classobj; PyObject *yieldfrom; PyObject *gi_name; PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; int resume_label; char is_running; } __pyx_CoroutineObject; static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); static int __Pyx_Coroutine_clear(PyObject *self); static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); static PyObject *__Pyx_Coroutine_Close(PyObject *self); static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_Coroutine_SwapException(self) #define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) #else #define __Pyx_Coroutine_SwapException(self) {\ __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ } #define __Pyx_Coroutine_ResetAndClearException(self) {\ __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ } #endif #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) #else #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) #endif static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); /* PatchModuleWithCoroutine.proto */ static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); /* PatchGeneratorABC.proto */ static int __Pyx_patch_abc(void); /* Generator.proto */ #define __Pyx_Generator_USED static PyTypeObject *__pyx_GeneratorType = 0; #define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) #define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ __Pyx__Coroutine_New(__pyx_GeneratorType, body, code, closure, name, qualname, module_name) static PyObject *__Pyx_Generator_Next(PyObject *self); static int __pyx_Generator_init(void); /* 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 bool __pyx_f_9pywrapfst_6Weight_member(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_15SymbolTableView__raw(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self); /* proto*/ static void __pyx_f_9pywrapfst_15SymbolTableView__raise_nonexistent(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self); /* proto*/ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_15SymbolTableView__raw_ptr_or_raise(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self); /* proto*/ static int64 __pyx_f_9pywrapfst_15SymbolTableView_available_key(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static PyObject *__pyx_f_9pywrapfst_15SymbolTableView_checksum(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_15SymbolTableView_copy(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static int64 __pyx_f_9pywrapfst_15SymbolTableView_get_nth_key(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, Py_ssize_t __pyx_v_pos, int __pyx_skip_dispatch); /* proto*/ static PyObject *__pyx_f_9pywrapfst_15SymbolTableView_labeled_checksum(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static bool __pyx_f_9pywrapfst_15SymbolTableView_member(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch); /* proto*/ static std::string __pyx_f_9pywrapfst_15SymbolTableView_name(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static size_t __pyx_f_9pywrapfst_15SymbolTableView_num_symbols(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_15SymbolTableView_write(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_source, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_15SymbolTableView_write_text(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_source, int __pyx_skip_dispatch); /* proto*/ static PyObject *__pyx_f_9pywrapfst_15SymbolTableView_write_to_string(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_28_EncodeMapperSymbolTableView__raw(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_v_self); /* proto*/ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_19_FstSymbolTableView__raw(struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_v_self); /* proto*/ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_19_MutableSymbolTable__raw(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self); /* proto*/ static __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_19_MutableSymbolTable__mutable_raw(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self); /* proto*/ static __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_19_MutableSymbolTable__mutable_raw_ptr_or_raise(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self); /* proto*/ static 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_SymbolTableView *__pyx_v_symbols, 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 __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_26_MutableFstSymbolTableView__mutable_raw(struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *__pyx_v_self); /* proto*/ static __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_11SymbolTable__mutable_raw(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self); /* proto*/ static std::string __pyx_f_9pywrapfst_12EncodeMapper_arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, 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 uint8 __pyx_f_9pywrapfst_12EncodeMapper_flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_12EncodeMapper_write(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, PyObject *__pyx_v_source, int __pyx_skip_dispatch); /* proto*/ static PyObject *__pyx_f_9pywrapfst_12EncodeMapper_write_to_string(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, 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_SymbolTableView *__pyx_v_symbols); /* proto*/ static void __pyx_f_9pywrapfst_12EncodeMapper__set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols); /* proto*/ static std::string __pyx_f_9pywrapfst_3Fst__local_render_svg(std::string const &__pyx_v_dot); /* proto*/ static std::string __pyx_f_9pywrapfst_3Fst_arc_type(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_f_9pywrapfst_3Fst_arcs(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst_Fst *__pyx_f_9pywrapfst_3Fst_copy(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_3Fst_draw(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, PyObject *__pyx_v_source, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_3Fst_draw *__pyx_optional_args); /* proto*/ static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_3Fst_final(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ static std::string __pyx_f_9pywrapfst_3Fst_fst_type(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_f_9pywrapfst_3Fst_input_symbols(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static size_t __pyx_f_9pywrapfst_3Fst_num_arcs(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ static size_t __pyx_f_9pywrapfst_3Fst_num_input_epsilons(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ static size_t __pyx_f_9pywrapfst_3Fst_num_output_epsilons(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_f_9pywrapfst_3Fst_output_symbols(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static std::string __pyx_f_9pywrapfst_3Fst_print(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_3Fst_print *__pyx_optional_args); /* proto*/ static int64 __pyx_f_9pywrapfst_3Fst_start(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static struct __pyx_obj_9pywrapfst_StateIterator *__pyx_f_9pywrapfst_3Fst_states(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static bool __pyx_f_9pywrapfst_3Fst_verify(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static std::string __pyx_f_9pywrapfst_3Fst_weight_type(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_3Fst_write(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, PyObject *__pyx_v_source, int __pyx_skip_dispatch); /* proto*/ static PyObject *__pyx_f_9pywrapfst_3Fst_write_to_string(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__check_mutating_imethod(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__add_arc(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto*/ static int64 __pyx_f_9pywrapfst_10MutableFst_add_state(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst_add_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, size_t __pyx_v_n, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__arcsort(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__arcsort *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__closure(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__closure *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__concat(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_fst2); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__connect(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__decode(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_mapper); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__delete_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_arcs *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__delete_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_states *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__encode(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_mapper); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__invert(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__minimize(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__minimize *__pyx_optional_args); /* proto*/ static struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_f_9pywrapfst_10MutableFst_mutable_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/ static int64 __pyx_f_9pywrapfst_10MutableFst_num_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__project(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_project_type); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__prune(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__prune *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__push(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__push *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__relabel_pairs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_pairs *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__relabel_tables(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_tables *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__reserve_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, size_t __pyx_v_n); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__reserve_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_n); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__reweight(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, struct __pyx_opt_args_9pywrapfst_10MutableFst__reweight *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__rmepsilon(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__rmepsilon *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__set_final(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_10MutableFst__set_final *__pyx_optional_args); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__set_input_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__set_output_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__set_start(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state); /* proto*/ static void __pyx_f_9pywrapfst_10MutableFst__topsort(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self); /* 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 uint8 __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, uint8 __pyx_v_flags, uint8 __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 uint8 __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, uint8 __pyx_v_flags, uint8 __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 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 'libcpp' */ /* Module declarations from 'libcpp.memory' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libcpp.string' */ /* Module declarations from 'libcpp.utility' */ /* Module declarations from 'libcpp.vector' */ /* Module declarations from 'libc.stdint' */ /* Module declarations from 'cintegral_types' */ /* Module declarations from 'cios' */ /* Module declarations from 'cpywrapfst' */ /* Module declarations from 'libc.stddef' */ /* Module declarations from 'libc.time' */ /* Module declarations from 'libcpp.cast' */ /* Module declarations from 'cmemory' */ /* Module declarations from 'cutility' */ /* Module declarations from 'pywrapfst' */ static PyTypeObject *__pyx_ptype_9pywrapfst_Weight = 0; static PyTypeObject *__pyx_ptype_9pywrapfst_SymbolTableView = 0; static PyTypeObject *__pyx_ptype_9pywrapfst__EncodeMapperSymbolTableView = 0; static PyTypeObject *__pyx_ptype_9pywrapfst__FstSymbolTableView = 0; static PyTypeObject *__pyx_ptype_9pywrapfst__MutableSymbolTable = 0; static PyTypeObject *__pyx_ptype_9pywrapfst__MutableFstSymbolTableView = 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_VectorFst = 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 PyTypeObject *__pyx_ptype_9pywrapfst___pyx_scope_struct____iter__ = 0; static std::string __pyx_f_9pywrapfst_tostring(PyObject *); /*proto*/ static std::string __pyx_f_9pywrapfst_weight_tostring(PyObject *); /*proto*/ static std::string __pyx_f_9pywrapfst_path_tostring(PyObject *); /*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__no_weight(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__EncodeMapperSymbolTableView *__pyx_f_9pywrapfst__init_EncodeMapperSymbolTableView(std::shared_ptr , bool); /*proto*/ static struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_f_9pywrapfst__init_FstSymbolTableView(std::shared_ptr , bool); /*proto*/ static struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *__pyx_f_9pywrapfst__init_MutableFstSymbolTableView(std::shared_ptr , bool); /*proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__init_SymbolTable(std::unique_ptr ); /*proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__read_SymbolTable_from_string(std::string, int __pyx_skip_dispatch); /*proto*/ static struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_f_9pywrapfst__init_EncodeMapper(__pyx_t_9pywrapfst_EncodeMapperClass_ptr); /*proto*/ static struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_f_9pywrapfst__read_EncodeMapper_from_string(std::string, int __pyx_skip_dispatch); /*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_Fst *__pyx_f_9pywrapfst__read_Fst(PyObject *, int __pyx_skip_dispatch); /*proto*/ static struct __pyx_obj_9pywrapfst_Fst *__pyx_f_9pywrapfst__read_Fst_from_string(std::string, 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 void __pyx_f_9pywrapfst__shortestdistance(struct __pyx_obj_9pywrapfst_Fst *, std::vector *, 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 fst::FarType __pyx_f_9pywrapfst__get_far_type(std::string const &); /*proto*/ static fst::ProjectType __pyx_f_9pywrapfst__get_project_type(std::string const &); /*proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_compact_symbol_table(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch); /*proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_merge_symbol_table(struct __pyx_obj_9pywrapfst_SymbolTableView *, struct __pyx_obj_9pywrapfst_SymbolTableView *, 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_convert_vector_from_py_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_IndexError; static PyObject *__pyx_builtin_IOError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_staticmethod; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_id; static PyObject *__pyx_builtin_NotImplementedError; static PyObject *__pyx_builtin_StopIteration; static PyObject *__pyx_builtin_KeyError; static const char __pyx_k_[] = ": "; 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_x[] = "x"; static const char __pyx_k__2[] = "<"; static const char __pyx_k__3[] = ">"; static const char __pyx_k_id[] = "id"; static const char __pyx_k_os[] = "os"; static const char __pyx_k_Arc[] = "Arc"; static const char __pyx_k_Fst[] = "Fst"; static const char __pyx_k__11[] = ""; static const char __pyx_k_add[] = "add"; static const char __pyx_k_arc[] = "arc"; 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_one[] = "one"; static const char __pyx_k_rhs[] = "rhs"; static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_Flag[] = "Flag"; static const char __pyx_k_PIPE[] = "PIPE"; static const char __pyx_k_Tsvg[] = "-Tsvg"; static const char __pyx_k_arcs[] = "arcs"; static const char __pyx_k_args[] = "args"; 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_enum[] = "enum"; static const char __pyx_k_find[] = "find"; static const char __pyx_k_ifst[] = "ifst"; static const char __pyx_k_iter[] = "__iter__"; 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_send[] = "send"; static const char __pyx_k_test[] = "test"; static const char __pyx_k_type[] = "type"; static const char __pyx_k_zero[] = "zero"; static const char __pyx_k_ERROR[] = "ERROR"; static const char __pyx_k_Popen[] = "Popen"; static const char __pyx_k_at_0x[] = " at 0x"; static const char __pyx_k_class[] = "__class__"; static const char __pyx_k_close[] = "close"; 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_items[] = "items"; 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_print[] = "print"; 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_throw[] = "throw"; 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_Weight[] = " Weight "; static const char __pyx_k_create[] = "create"; static const char __pyx_k_divide[] = "divide"; static const char __pyx_k_failed[] = " failed"; static const char __pyx_k_fspath[] = "fspath"; 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_olabel[] = "olabel"; static const char __pyx_k_opairs[] = "opairs"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_select[] = "select"; static const char __pyx_k_source[] = "source"; static const char __pyx_k_states[] = "states"; 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_typing[] = "typing"; 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_FarType[] = "FarType"; static const char __pyx_k_IOError[] = "IOError"; static const char __pyx_k_MUTABLE[] = "MUTABLE"; static const char __pyx_k_class_2[] = "_class__"; 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_members[] = "__members__"; 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_symbols[] = "symbols"; 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_Compiler[] = "Compiler"; static const char __pyx_k_EPSILONS[] = "EPSILONS"; static const char __pyx_k_EXPANDED[] = "EXPANDED"; static const char __pyx_k_Expected[] = "Expected "; static const char __pyx_k_FstError[] = "FstError"; static const char __pyx_k_KeyError[] = "KeyError"; static const char __pyx_k_NO_LABEL[] = "NO_LABEL"; static const char __pyx_k_SortType[] = "SortType"; static const char __pyx_k_WEIGHTED[] = "WEIGHTED"; static const char __pyx_k_Weight_2[] = "Weight"; 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_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_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_weight_2[] = "_weight"; static const char __pyx_k_weighted[] = "weighted"; static const char __pyx_k_ARC_FLAGS[] = "ARC_FLAGS"; static const char __pyx_k_Arc_at_0x[] = " __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8); __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_but_received); __pyx_t_5 += 14; __Pyx_GIVEREF(__pyx_kp_u_but_received); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_but_received); /* "pywrapfst.pyx":197 * return data * raise TypeError(f"Expected {str.__name__} but received " * f"{type(data).__name__}: {data!r}") # <<<<<<<<<<<<<< * * */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_data)), __pyx_n_s_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_); __pyx_t_5 += 2; __Pyx_GIVEREF(__pyx_kp_u_); PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_kp_u_); __pyx_t_7 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_data), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_t_7); __pyx_t_7 = 0; /* "pywrapfst.pyx":196 * if isinstance(data, str): * return data * raise TypeError(f"Expected {str.__name__} but received " # <<<<<<<<<<<<<< * f"{type(data).__name__}: {data!r}") * */ __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_4, 6, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(0, 196, __pyx_L1_error) /* "pywrapfst.pyx":175 * * * cdef string tostring(data) except *: # <<<<<<<<<<<<<< * """Converts strings to bytestrings. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __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":200 * * * cdef string weight_tostring(data) except *: # <<<<<<<<<<<<<< * """Converts strings or numerics to bytestrings. * */ static std::string __pyx_f_9pywrapfst_weight_tostring(PyObject *__pyx_v_data) { 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; Py_ssize_t __pyx_t_6; Py_UCS4 __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("weight_tostring", 0); /* "pywrapfst.pyx":222 * """ * # A Python string can be implicitly cast to a C++ string. * if isinstance(data, str): # <<<<<<<<<<<<<< * return data * elif isinstance(data, numbers.Number): */ __pyx_t_1 = PyUnicode_Check(__pyx_v_data); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":223 * # A Python string can be implicitly cast to a C++ string. * if isinstance(data, str): * return data # <<<<<<<<<<<<<< * elif isinstance(data, numbers.Number): * return str(data) */ __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 223, __pyx_L1_error) __pyx_r = __pyx_t_3; goto __pyx_L0; /* "pywrapfst.pyx":222 * """ * # A Python string can be implicitly cast to a C++ string. * if isinstance(data, str): # <<<<<<<<<<<<<< * return data * elif isinstance(data, numbers.Number): */ } /* "pywrapfst.pyx":224 * if isinstance(data, str): * return data * elif isinstance(data, numbers.Number): # <<<<<<<<<<<<<< * return str(data) * raise TypeError(f"Expected {str.__name__} but received " */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __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, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = PyObject_IsInstance(__pyx_v_data, __pyx_t_5); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":225 * return data * elif isinstance(data, numbers.Number): * return str(data) # <<<<<<<<<<<<<< * raise TypeError(f"Expected {str.__name__} but received " * f"{type(data).__name__}: {data!r}") */ __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyUnicode_Type)), __pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 225, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __pyx_t_3; goto __pyx_L0; /* "pywrapfst.pyx":224 * if isinstance(data, str): * return data * elif isinstance(data, numbers.Number): # <<<<<<<<<<<<<< * return str(data) * raise TypeError(f"Expected {str.__name__} but received " */ } /* "pywrapfst.pyx":226 * elif isinstance(data, numbers.Number): * return str(data) * raise TypeError(f"Expected {str.__name__} but received " # <<<<<<<<<<<<<< * f"{type(data).__name__}: {data!r}") * */ __pyx_t_5 = PyTuple_New(6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 0; __pyx_t_7 = 127; __Pyx_INCREF(__pyx_kp_u_Expected); __pyx_t_6 += 9; __Pyx_GIVEREF(__pyx_kp_u_Expected); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Expected); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)(&PyUnicode_Type)), __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_4, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_7; __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_8); __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_but_received); __pyx_t_6 += 14; __Pyx_GIVEREF(__pyx_kp_u_but_received); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_but_received); /* "pywrapfst.pyx":227 * return str(data) * raise TypeError(f"Expected {str.__name__} but received " * f"{type(data).__name__}: {data!r}") # <<<<<<<<<<<<<< * * */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)Py_TYPE(__pyx_v_data)), __pyx_n_s_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_7; __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_); __pyx_t_6 += 2; __Pyx_GIVEREF(__pyx_kp_u_); PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_kp_u_); __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_data), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_7; __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":226 * elif isinstance(data, numbers.Number): * return str(data) * raise TypeError(f"Expected {str.__name__} but received " # <<<<<<<<<<<<<< * f"{type(data).__name__}: {data!r}") * */ __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_5, 6, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 226, __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, 226, __pyx_L1_error) /* "pywrapfst.pyx":200 * * * cdef string weight_tostring(data) 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_8); __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":230 * * * cdef string path_tostring(data) except *: # <<<<<<<<<<<<<< * return tostring(os.fspath(data)) * */ static std::string __pyx_f_9pywrapfst_path_tostring(PyObject *__pyx_v_data) { std::string __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; std::string __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("path_tostring", 0); /* "pywrapfst.pyx":231 * * cdef string path_tostring(data) except *: * return tostring(os.fspath(data)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_fspath); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_data) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_data); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = __pyx_f_9pywrapfst_tostring(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 231, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_4; goto __pyx_L0; /* "pywrapfst.pyx":230 * * * cdef string path_tostring(data) except *: # <<<<<<<<<<<<<< * return tostring(os.fspath(data)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pywrapfst.path_tostring", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":234 * * * cdef fst.FarType _get_far_type(const string &far_type) except *: # <<<<<<<<<<<<<< * """Matches string with the appropriate FarType enum value. * */ static fst::FarType __pyx_f_9pywrapfst__get_far_type(std::string const &__pyx_v_far_type) { fst::FarType __pyx_v__far_type; fst::FarType __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_far_type", 0); /* "pywrapfst.pyx":250 * """ * cdef fst.FarType _far_type * if not fst.GetFarType(far_type, addr(_far_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown FAR type: {far_type!r}") * return _far_type */ __pyx_t_1 = ((!(fst::script::GetFarType(__pyx_v_far_type, (&__pyx_v__far_type)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":251 * cdef fst.FarType _far_type * if not fst.GetFarType(far_type, addr(_far_type)): * raise FstArgError(f"Unknown FAR type: {far_type!r}") # <<<<<<<<<<<<<< * return _far_type * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_far_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_FAR_type, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __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, 251, __pyx_L1_error) /* "pywrapfst.pyx":250 * """ * cdef fst.FarType _far_type * if not fst.GetFarType(far_type, addr(_far_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown FAR type: {far_type!r}") * return _far_type */ } /* "pywrapfst.pyx":252 * if not fst.GetFarType(far_type, addr(_far_type)): * raise FstArgError(f"Unknown FAR type: {far_type!r}") * return _far_type # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__far_type; goto __pyx_L0; /* "pywrapfst.pyx":234 * * * cdef fst.FarType _get_far_type(const string &far_type) except *: # <<<<<<<<<<<<<< * """Matches string with the appropriate FarType 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_AddTraceback("pywrapfst._get_far_type", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = (fst::FarType) 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":255 * * * 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 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_compose_filter", 0); /* "pywrapfst.pyx":277 * """ * cdef fst.ComposeFilter _compose_filter * if not fst.GetComposeFilter(compose_filter, addr(_compose_filter)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown compose filter type: {compose_filter!r}") * return _compose_filter */ __pyx_t_1 = ((!(fst::script::GetComposeFilter(__pyx_v_compose_filter, (&__pyx_v__compose_filter)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":278 * cdef fst.ComposeFilter _compose_filter * if not fst.GetComposeFilter(compose_filter, addr(_compose_filter)): * raise FstArgError(f"Unknown compose filter type: {compose_filter!r}") # <<<<<<<<<<<<<< * return _compose_filter * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_compose_filter); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_compose_filter_type, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __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, 278, __pyx_L1_error) /* "pywrapfst.pyx":277 * """ * cdef fst.ComposeFilter _compose_filter * if not fst.GetComposeFilter(compose_filter, addr(_compose_filter)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown compose filter type: {compose_filter!r}") * return _compose_filter */ } /* "pywrapfst.pyx":279 * if not fst.GetComposeFilter(compose_filter, addr(_compose_filter)): * raise FstArgError(f"Unknown compose filter type: {compose_filter!r}") * return _compose_filter # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__compose_filter; goto __pyx_L0; /* "pywrapfst.pyx":255 * * * 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_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":282 * * * 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 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_determinize_type", 0); /* "pywrapfst.pyx":298 * """ * cdef fst.DeterminizeType _det_type * if not fst.GetDeterminizeType(det_type, addr(_det_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown determinization type: {det_type!r}") * return _det_type */ __pyx_t_1 = ((!(fst::script::GetDeterminizeType(__pyx_v_det_type, (&__pyx_v__det_type)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":299 * cdef fst.DeterminizeType _det_type * if not fst.GetDeterminizeType(det_type, addr(_det_type)): * raise FstArgError(f"Unknown determinization type: {det_type!r}") # <<<<<<<<<<<<<< * return _det_type * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_det_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_determinization_type, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __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, 299, __pyx_L1_error) /* "pywrapfst.pyx":298 * """ * cdef fst.DeterminizeType _det_type * if not fst.GetDeterminizeType(det_type, addr(_det_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown determinization type: {det_type!r}") * return _det_type */ } /* "pywrapfst.pyx":300 * if not fst.GetDeterminizeType(det_type, addr(_det_type)): * raise FstArgError(f"Unknown determinization type: {det_type!r}") * return _det_type # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__det_type; goto __pyx_L0; /* "pywrapfst.pyx":282 * * * 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_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":303 * * * cdef fst.ProjectType _get_project_type(const string &project_type) except *: # <<<<<<<<<<<<<< * """Matches string with the appropriate ProjectType enum value. * */ static fst::ProjectType __pyx_f_9pywrapfst__get_project_type(std::string const &__pyx_v_project_type) { fst::ProjectType __pyx_v__project_type; fst::ProjectType __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_project_type", 0); /* "pywrapfst.pyx":319 * """ * cdef fst.ProjectType _project_type * if not fst.GetProjectType(project_type, addr(_project_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown projection type: {project_type!r}") * return _project_type */ __pyx_t_1 = ((!(fst::script::GetProjectType(__pyx_v_project_type, (&__pyx_v__project_type)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":320 * cdef fst.ProjectType _project_type * if not fst.GetProjectType(project_type, addr(_project_type)): * raise FstArgError(f"Unknown projection type: {project_type!r}") # <<<<<<<<<<<<<< * return _project_type * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_project_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_projection_type, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __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, 320, __pyx_L1_error) /* "pywrapfst.pyx":319 * """ * cdef fst.ProjectType _project_type * if not fst.GetProjectType(project_type, addr(_project_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown projection type: {project_type!r}") * return _project_type */ } /* "pywrapfst.pyx":321 * if not fst.GetProjectType(project_type, addr(_project_type)): * raise FstArgError(f"Unknown projection type: {project_type!r}") * return _project_type # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__project_type; goto __pyx_L0; /* "pywrapfst.pyx":303 * * * cdef fst.ProjectType _get_project_type(const string &project_type) except *: # <<<<<<<<<<<<<< * """Matches string with the appropriate ProjectType 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_AddTraceback("pywrapfst._get_project_type", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = (fst::ProjectType) 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":324 * * * 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 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_queue_type", 0); /* "pywrapfst.pyx":343 * """ * cdef fst.QueueType _queue_type * if not fst.GetQueueType(queue_type, addr(_queue_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown queue type: {queue_type!r}") * return _queue_type */ __pyx_t_1 = ((!(fst::script::GetQueueType(__pyx_v_queue_type, (&__pyx_v__queue_type)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":344 * cdef fst.QueueType _queue_type * if not fst.GetQueueType(queue_type, addr(_queue_type)): * raise FstArgError(f"Unknown queue type: {queue_type!r}") # <<<<<<<<<<<<<< * return _queue_type * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_queue_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_queue_type, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 344, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 344, __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, 344, __pyx_L1_error) /* "pywrapfst.pyx":343 * """ * cdef fst.QueueType _queue_type * if not fst.GetQueueType(queue_type, addr(_queue_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown queue type: {queue_type!r}") * return _queue_type */ } /* "pywrapfst.pyx":345 * if not fst.GetQueueType(queue_type, addr(_queue_type)): * raise FstArgError(f"Unknown queue type: {queue_type!r}") * return _queue_type # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__queue_type; goto __pyx_L0; /* "pywrapfst.pyx":324 * * * 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_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":348 * * * 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 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_rand_arc_selection", 0); /* "pywrapfst.pyx":368 * """ * cdef fst.RandArcSelection _select * if not fst.GetRandArcSelection(select, addr(_select)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown random arc selection type: {select!r}") * return _select */ __pyx_t_1 = ((!(fst::script::GetRandArcSelection(__pyx_v_select, (&__pyx_v__select)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":369 * cdef fst.RandArcSelection _select * if not fst.GetRandArcSelection(select, addr(_select)): * raise FstArgError(f"Unknown random arc selection type: {select!r}") # <<<<<<<<<<<<<< * return _select * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_select); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_random_arc_selection_typ, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 369, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 369, __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, 369, __pyx_L1_error) /* "pywrapfst.pyx":368 * """ * cdef fst.RandArcSelection _select * if not fst.GetRandArcSelection(select, addr(_select)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown random arc selection type: {select!r}") * return _select */ } /* "pywrapfst.pyx":370 * if not fst.GetRandArcSelection(select, addr(_select)): * raise FstArgError(f"Unknown random arc selection type: {select!r}") * return _select # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__select; goto __pyx_L0; /* "pywrapfst.pyx":348 * * * 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_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":373 * * * 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 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_replace_label_type", 0); /* "pywrapfst.pyx":394 * """ * cdef fst.ReplaceLabelType _replace_label_type * if not fst.GetReplaceLabelType(replace_label_type, # <<<<<<<<<<<<<< * epsilon_on_replace, * addr(_replace_label_type)): */ __pyx_t_1 = ((!(fst::script::GetReplaceLabelType(__pyx_v_replace_label_type, __pyx_v_epsilon_on_replace, (&__pyx_v__replace_label_type)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":397 * epsilon_on_replace, * addr(_replace_label_type)): * raise FstArgError(f"Unknown replace label type: {replace_label_type!r}") # <<<<<<<<<<<<<< * return _replace_label_type * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_replace_label_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_4), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_replace_label_type, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __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, 397, __pyx_L1_error) /* "pywrapfst.pyx":394 * """ * cdef fst.ReplaceLabelType _replace_label_type * if not fst.GetReplaceLabelType(replace_label_type, # <<<<<<<<<<<<<< * epsilon_on_replace, * addr(_replace_label_type)): */ } /* "pywrapfst.pyx":398 * addr(_replace_label_type)): * raise FstArgError(f"Unknown replace label type: {replace_label_type!r}") * return _replace_label_type # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__replace_label_type; goto __pyx_L0; /* "pywrapfst.pyx":373 * * * 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_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":424 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.type()} Weight {self.to_string()} at 0x{id(self):x}>" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":425 * * def __repr__(self): * return f"<{self.type()} Weight {self.to_string()} at 0x{id(self):x}>" # <<<<<<<<<<<<<< * * def __str__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u__2); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u__2); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "type"); __PYX_ERR(0, 425, __pyx_L1_error) } __pyx_t_4 = __pyx_convert_PyUnicode_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_4)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_Weight); __pyx_t_2 += 8; __Pyx_GIVEREF(__pyx_kp_u_Weight); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_Weight); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "to_string"); __PYX_ERR(0, 425, __pyx_L1_error) } __pyx_t_4 = __pyx_convert_PyUnicode_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, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_at_0x); __pyx_t_2 += 6; __Pyx_GIVEREF(__pyx_kp_u_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":424 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.type()} Weight {self.to_string()} at 0x{id(self):x}>" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __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":427 * return f"<{self.type()} Weight {self.to_string()} at 0x{id(self):x}>" * * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); /* "pywrapfst.pyx":428 * * 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, 428, __pyx_L1_error) } __pyx_t_1 = __pyx_convert_PyUnicode_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, 428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":427 * return f"<{self.type()} Weight {self.to_string()} at 0x{id(self):x}>" * * 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":433 * # 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__float__", 0); /* "pywrapfst.pyx":434 * * 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, 434, __pyx_L1_error) } __pyx_t_1 = __pyx_convert_PyUnicode_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, 434, __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, 434, __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":433 * # 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":436 * 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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weight_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weight)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 436, __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, 436, __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, 436, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":437 * * 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, 437, __pyx_L1_error) } __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 437, __pyx_L1_error) /* "pywrapfst.pyx":438 * 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); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 438, __pyx_L1_error) /* "pywrapfst.pyx":437 * * 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":439 * 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, 439, __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, 439, __pyx_L1_error) /* "pywrapfst.pyx":436 * 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":441 * 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; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_check_weight", 0); /* "pywrapfst.pyx":442 * * cdef void _check_weight(self) except *: * if self.type() == b"none": # <<<<<<<<<<<<<< * raise FstArgError("Weight type not found") * if not self.member(): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "type"); __PYX_ERR(0, 442, __pyx_L1_error) } __pyx_t_1 = ((((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->type(__pyx_v_self, 0) == ((char const *)"none")) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":443 * cdef void _check_weight(self) except *: * if self.type() == b"none": * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< * if not self.member(): * raise FstBadWeightError("Invalid weight") */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Weight_type_not_found) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Weight_type_not_found); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 443, __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, 443, __pyx_L1_error) /* "pywrapfst.pyx":442 * * cdef void _check_weight(self) except *: * if self.type() == b"none": # <<<<<<<<<<<<<< * raise FstArgError("Weight type not found") * if not self.member(): */ } /* "pywrapfst.pyx":444 * if self.type() == b"none": * raise FstArgError("Weight type not found") * if not self.member(): # <<<<<<<<<<<<<< * raise FstBadWeightError("Invalid weight") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "member"); __PYX_ERR(0, 444, __pyx_L1_error) } __pyx_t_1 = ((!(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->member(__pyx_v_self, 0) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":445 * raise FstArgError("Weight type not found") * if not self.member(): * raise FstBadWeightError("Invalid weight") # <<<<<<<<<<<<<< * * cpdef Weight copy(self): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Invalid_weight) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Invalid_weight); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 445, __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, 445, __pyx_L1_error) /* "pywrapfst.pyx":444 * if self.type() == b"none": * raise FstArgError("Weight type not found") * if not self.member(): # <<<<<<<<<<<<<< * raise FstBadWeightError("Invalid weight") * */ } /* "pywrapfst.pyx":441 * 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_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.Weight._check_weight", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":447 * 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__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 447, __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, 447, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":453 * Returns a copy of the Weight. * """ * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset(new fst.WeightClass(deref(self._weight))) * return _weight */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 453, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":454 * """ * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(deref(self._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, 454, __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, 454, __pyx_L1_error) } __pyx_v__weight->_weight.reset(new fst::script::WeightClass((*__pyx_v_self->_weight))); /* "pywrapfst.pyx":455 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(deref(self._weight))) * return _weight # <<<<<<<<<<<<<< * * # To get around the inability to declare cdef class methods, we define the */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":447 * 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__weight); __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 447, __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":461 * * @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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("zero", 0); /* "pywrapfst.pyx":467 * 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, 467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":461 * * @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":470 * * @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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("one", 0); /* "pywrapfst.pyx":476 * 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, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":470 * * @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":479 * * @classmethod * def no_weight(cls, weight_type): # <<<<<<<<<<<<<< * """ * Weight.no_weight(weight_type) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_6Weight_15no_weight(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /*proto*/ static char __pyx_doc_9pywrapfst_6Weight_14no_weight[] = "\n Weight.no_weight(weight_type)\n\n Constructs a non-member weight in the semiring.\n "; static PyObject *__pyx_pw_9pywrapfst_6Weight_15no_weight(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("no_weight (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_6Weight_14no_weight(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_weight_type)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_6Weight_14no_weight(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("no_weight", 0); /* "pywrapfst.pyx":485 * Constructs a non-member weight in the semiring. * """ * return _no_weight(weight_type) # <<<<<<<<<<<<<< * * def __eq__(Weight w1, Weight w2): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__no_weight(__pyx_v_weight_type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":479 * * @classmethod * def no_weight(cls, weight_type): # <<<<<<<<<<<<<< * """ * Weight.no_weight(weight_type) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pywrapfst.Weight.no_weight", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":487 * return _no_weight(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) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 487, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__eq__", 0); /* "pywrapfst.pyx":488 * * 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, 488, __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, 488, __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, 488, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":487 * return _no_weight(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":490 * 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) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 490, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__ne__", 0); /* "pywrapfst.pyx":491 * * 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, 491, __pyx_L1_error) __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 491, __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, 491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":490 * 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":493 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 493, __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, 493, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":494 * * 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, 494, __pyx_L1_error) } __pyx_r = __pyx_v_self->_weight.get()->ToString(); goto __pyx_L0; /* "pywrapfst.pyx":493 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("to_string", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_6Weight_to_string(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 493, __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":496 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 496, __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, 496, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":501 * Returns a string indicating the weight type. * """ * return self._weight.get().Type() # <<<<<<<<<<<<<< * * cpdef bool member(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 501, __pyx_L1_error) } __pyx_r = __pyx_v_self->_weight.get()->Type(); goto __pyx_L0; /* "pywrapfst.pyx":496 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_6Weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 496, __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; } /* "pywrapfst.pyx":503 * return self._weight.get().Type() * * cpdef bool member(self): # <<<<<<<<<<<<<< * return self._weight.get().Member() * */ static PyObject *__pyx_pw_9pywrapfst_6Weight_25member(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static bool __pyx_f_9pywrapfst_6Weight_member(struct __pyx_obj_9pywrapfst_Weight *__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_member); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_6Weight_25member)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 503, __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, 503, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":504 * * cpdef bool member(self): * return self._weight.get().Member() # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 504, __pyx_L1_error) } __pyx_r = __pyx_v_self->_weight.get()->Member(); goto __pyx_L0; /* "pywrapfst.pyx":503 * return self._weight.get().Type() * * cpdef bool member(self): # <<<<<<<<<<<<<< * return self._weight.get().Member() * */ /* 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.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_6Weight_25member(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_6Weight_25member(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("member (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_6Weight_24member(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_6Weight_24member(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("member", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_6Weight_member(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __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.member", __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_27__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_6Weight_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_6Weight_26__reduce_cython__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_6Weight_26__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__4, 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_29__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_6Weight_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_6Weight_28__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_28__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__5, 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":507 * * * cdef Weight _plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight = 0; struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_plus", 0); /* "pywrapfst.pyx":508 * * cdef Weight _plus(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), * deref(rhs._weight)))) */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 508, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":509 * cdef Weight _plus(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), # <<<<<<<<<<<<<< * deref(rhs._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, 509, __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, 509, __pyx_L1_error) } /* "pywrapfst.pyx":510 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), * deref(rhs._weight)))) # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 510, __pyx_L1_error) } /* "pywrapfst.pyx":509 * cdef Weight _plus(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), # <<<<<<<<<<<<<< * deref(rhs._weight)))) * return _weight */ __pyx_v__weight->_weight.reset(new fst::script::WeightClass(fst::script::Plus((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight)))); /* "pywrapfst.pyx":511 * _weight._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), * deref(rhs._weight)))) * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":507 * * * cdef Weight _plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":514 * * * 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)(void*)(PyCFunctionWithKeywords)__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("plus", 1, 2, 2, 1); __PYX_ERR(0, 514, __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, 514, __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, 514, __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, 514, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 514, __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__weight = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("plus", 0); /* "pywrapfst.pyx":534 * FstBadWeightError: invalid weight. * """ * cdef Weight _weight = _plus(lhs, rhs) # <<<<<<<<<<<<<< * _weight._check_weight() * return _weight */ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__plus(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":535 * """ * cdef Weight _weight = _plus(lhs, rhs) * _weight._check_weight() # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); __PYX_ERR(0, 535, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v__weight->__pyx_vtab)->_check_weight(__pyx_v__weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 535, __pyx_L1_error) /* "pywrapfst.pyx":536 * cdef Weight _weight = _plus(lhs, rhs) * _weight._check_weight() * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = ((PyObject *)__pyx_v__weight); goto __pyx_L0; /* "pywrapfst.pyx":514 * * * 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__weight); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":539 * * * cdef Weight _times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight = 0; struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_times", 0); /* "pywrapfst.pyx":540 * * cdef Weight _times(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), * deref(rhs._weight)))) */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 540, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":541 * cdef Weight _times(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), # <<<<<<<<<<<<<< * deref(rhs._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, 541, __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, 541, __pyx_L1_error) } /* "pywrapfst.pyx":542 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), * deref(rhs._weight)))) # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 542, __pyx_L1_error) } /* "pywrapfst.pyx":541 * cdef Weight _times(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), # <<<<<<<<<<<<<< * deref(rhs._weight)))) * return _weight */ __pyx_v__weight->_weight.reset(new fst::script::WeightClass(fst::script::Times((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight)))); /* "pywrapfst.pyx":543 * _weight._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), * deref(rhs._weight)))) * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":539 * * * cdef Weight _times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":546 * * * 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)(void*)(PyCFunctionWithKeywords)__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("times", 1, 2, 2, 1); __PYX_ERR(0, 546, __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, 546, __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, 546, __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, 546, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 546, __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__weight = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("times", 0); /* "pywrapfst.pyx":566 * FstBadWeightError: Invalid weight. * """ * cdef Weight _weight = _times(lhs, rhs) # <<<<<<<<<<<<<< * _weight._check_weight() * return _weight */ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__times(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":567 * """ * cdef Weight _weight = _times(lhs, rhs) * _weight._check_weight() # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); __PYX_ERR(0, 567, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v__weight->__pyx_vtab)->_check_weight(__pyx_v__weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 567, __pyx_L1_error) /* "pywrapfst.pyx":568 * cdef Weight _weight = _times(lhs, rhs) * _weight._check_weight() * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = ((PyObject *)__pyx_v__weight); goto __pyx_L0; /* "pywrapfst.pyx":546 * * * 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__weight); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":571 * * * cdef Weight _divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight = 0; struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_divide", 0); /* "pywrapfst.pyx":572 * * cdef Weight _divide(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), * deref(rhs._weight)))) */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":573 * cdef Weight _divide(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), # <<<<<<<<<<<<<< * deref(rhs._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, 573, __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, 573, __pyx_L1_error) } /* "pywrapfst.pyx":574 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), * deref(rhs._weight)))) # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 574, __pyx_L1_error) } /* "pywrapfst.pyx":573 * cdef Weight _divide(Weight lhs, Weight rhs): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), # <<<<<<<<<<<<<< * deref(rhs._weight)))) * return _weight */ __pyx_v__weight->_weight.reset(new fst::script::WeightClass(fst::script::Divide((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight)))); /* "pywrapfst.pyx":575 * _weight._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), * deref(rhs._weight)))) * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":571 * * * cdef Weight _divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":578 * * * 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)(void*)(PyCFunctionWithKeywords)__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("divide", 1, 2, 2, 1); __PYX_ERR(0, 578, __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, 578, __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, 578, __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, 578, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 578, __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__weight = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("divide", 0); /* "pywrapfst.pyx":600 * FstBadWeightError: Invalid weight. * """ * cdef Weight _weight = _divide(lhs, rhs) # <<<<<<<<<<<<<< * _weight._check_weight() * return _weight */ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__divide(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":601 * """ * cdef Weight _weight = _divide(lhs, rhs) * _weight._check_weight() # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); __PYX_ERR(0, 601, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v__weight->__pyx_vtab)->_check_weight(__pyx_v__weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 601, __pyx_L1_error) /* "pywrapfst.pyx":602 * cdef Weight _weight = _divide(lhs, rhs) * _weight._check_weight() * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = ((PyObject *)__pyx_v__weight); goto __pyx_L0; /* "pywrapfst.pyx":578 * * * 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__weight); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":605 * * * cdef Weight _power(Weight w, size_t n): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight = 0; struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_power", 0); /* "pywrapfst.pyx":606 * * cdef Weight _power(Weight w, size_t n): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) * return _weight */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 606, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":607 * cdef Weight _power(Weight w, size_t n): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 607, __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, 607, __pyx_L1_error) } __pyx_v__weight->_weight.reset(new fst::script::WeightClass(fst::script::Power((*__pyx_v_w->_weight), __pyx_v_n))); /* "pywrapfst.pyx":608 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":605 * * * cdef Weight _power(Weight w, size_t n): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._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__weight); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":611 * * * 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)(void*)(PyCFunctionWithKeywords)__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("power", 1, 2, 2, 1); __PYX_ERR(0, 611, __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, 611, __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, 611, __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, 611, __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, 611, __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__weight = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("power", 0); /* "pywrapfst.pyx":628 * FstBadWeightError: Invalid weight. * """ * cdef Weight _weight = _power(w, n) # <<<<<<<<<<<<<< * _weight._check_weight() * return _weight */ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__power(__pyx_v_w, __pyx_v_n)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":629 * """ * cdef Weight _weight = _power(w, n) * _weight._check_weight() # <<<<<<<<<<<<<< * return _weight * */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_weight"); __PYX_ERR(0, 629, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v__weight->__pyx_vtab)->_check_weight(__pyx_v__weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 629, __pyx_L1_error) /* "pywrapfst.pyx":630 * cdef Weight _weight = _power(w, n) * _weight._check_weight() * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = ((PyObject *)__pyx_v__weight); goto __pyx_L0; /* "pywrapfst.pyx":611 * * * 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__weight); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":633 * * * 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__weight; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_WeightClass_or_zero", 0); /* "pywrapfst.pyx":651 * """ * cdef fst.WeightClass _weight * if weight is None: # <<<<<<<<<<<<<< * _weight = 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":652 * cdef fst.WeightClass _weight * if weight is None: * _weight = fst.WeightClass.Zero(weight_type) # <<<<<<<<<<<<<< * elif isinstance(weight, Weight): * _weight = deref( ( weight)._weight.get()) */ __pyx_v__weight = fst::script::WeightClass::Zero(__pyx_v_weight_type); /* "pywrapfst.pyx":651 * """ * cdef fst.WeightClass _weight * if weight is None: # <<<<<<<<<<<<<< * _weight = fst.WeightClass.Zero(weight_type) * elif isinstance(weight, Weight): */ goto __pyx_L3; } /* "pywrapfst.pyx":653 * if weight is None: * _weight = fst.WeightClass.Zero(weight_type) * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< * _weight = 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":654 * _weight = fst.WeightClass.Zero(weight_type) * elif isinstance(weight, Weight): * _weight = deref( ( weight)._weight.get()) # <<<<<<<<<<<<<< * else: * _weight = 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, 654, __pyx_L1_error) } __pyx_v__weight = (*((fst::script::WeightClass *)((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_weight)->_weight.get())); /* "pywrapfst.pyx":653 * if weight is None: * _weight = fst.WeightClass.Zero(weight_type) * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< * _weight = deref( ( weight)._weight.get()) * else: */ goto __pyx_L3; } /* "pywrapfst.pyx":656 * _weight = deref( ( weight)._weight.get()) * else: * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) # <<<<<<<<<<<<<< * if not _weight.Member(): * raise FstBadWeightError(weight_tostring(weight)) */ /*else*/ { __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) __pyx_v__weight = fst::script::WeightClass(__pyx_v_weight_type, __pyx_t_3); /* "pywrapfst.pyx":657 * else: * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) * if not _weight.Member(): # <<<<<<<<<<<<<< * raise FstBadWeightError(weight_tostring(weight)) * return _weight */ __pyx_t_1 = ((!(__pyx_v__weight.Member() != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":658 * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) * if not _weight.Member(): * raise FstBadWeightError(weight_tostring(weight)) # <<<<<<<<<<<<<< * return _weight * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 658, __pyx_L1_error) __pyx_t_6 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 658, __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); } } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 658, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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, 658, __pyx_L1_error) /* "pywrapfst.pyx":657 * else: * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) * if not _weight.Member(): # <<<<<<<<<<<<<< * raise FstBadWeightError(weight_tostring(weight)) * return _weight */ } } __pyx_L3:; /* "pywrapfst.pyx":659 * if not _weight.Member(): * raise FstBadWeightError(weight_tostring(weight)) * return _weight # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":633 * * * 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_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":662 * * * 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__weight; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_WeightClass_or_one", 0); /* "pywrapfst.pyx":680 * """ * cdef fst.WeightClass _weight * if weight is None: # <<<<<<<<<<<<<< * _weight = 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":681 * cdef fst.WeightClass _weight * if weight is None: * _weight = fst.WeightClass.One(weight_type) # <<<<<<<<<<<<<< * elif isinstance(weight, Weight): * _weight = deref( ( weight)._weight.get()) */ __pyx_v__weight = fst::script::WeightClass::One(__pyx_v_weight_type); /* "pywrapfst.pyx":680 * """ * cdef fst.WeightClass _weight * if weight is None: # <<<<<<<<<<<<<< * _weight = fst.WeightClass.One(weight_type) * elif isinstance(weight, Weight): */ goto __pyx_L3; } /* "pywrapfst.pyx":682 * if weight is None: * _weight = fst.WeightClass.One(weight_type) * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< * _weight = 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":683 * _weight = fst.WeightClass.One(weight_type) * elif isinstance(weight, Weight): * _weight = deref( ( weight)._weight.get()) # <<<<<<<<<<<<<< * else: * _weight = 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, 683, __pyx_L1_error) } __pyx_v__weight = (*((fst::script::WeightClass *)((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_weight)->_weight.get())); /* "pywrapfst.pyx":682 * if weight is None: * _weight = fst.WeightClass.One(weight_type) * elif isinstance(weight, Weight): # <<<<<<<<<<<<<< * _weight = deref( ( weight)._weight.get()) * else: */ goto __pyx_L3; } /* "pywrapfst.pyx":685 * _weight = deref( ( weight)._weight.get()) * else: * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) # <<<<<<<<<<<<<< * if not _weight.Member(): * raise FstBadWeightError(weight_tostring(weight)) */ /*else*/ { __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 685, __pyx_L1_error) __pyx_v__weight = fst::script::WeightClass(__pyx_v_weight_type, __pyx_t_3); /* "pywrapfst.pyx":686 * else: * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) * if not _weight.Member(): # <<<<<<<<<<<<<< * raise FstBadWeightError(weight_tostring(weight)) * return _weight */ __pyx_t_1 = ((!(__pyx_v__weight.Member() != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":687 * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) * if not _weight.Member(): * raise FstBadWeightError(weight_tostring(weight)) # <<<<<<<<<<<<<< * return _weight * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __pyx_f_9pywrapfst_weight_tostring(__pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 687, __pyx_L1_error) __pyx_t_6 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 687, __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); } } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 687, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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, 687, __pyx_L1_error) /* "pywrapfst.pyx":686 * else: * _weight = fst.WeightClass(weight_type, weight_tostring(weight)) * if not _weight.Member(): # <<<<<<<<<<<<<< * raise FstBadWeightError(weight_tostring(weight)) * return _weight */ } } __pyx_L3:; /* "pywrapfst.pyx":688 * if not _weight.Member(): * raise FstBadWeightError(weight_tostring(weight)) * return _weight # <<<<<<<<<<<<<< * * */ __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":662 * * * 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_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":691 * * * cdef Weight _zero(weight_type): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( */ static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__zero(PyObject *__pyx_v_weight_type) { struct __pyx_obj_9pywrapfst_Weight *__pyx_v__weight = 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; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_zero", 0); /* "pywrapfst.pyx":692 * * cdef Weight _zero(weight_type): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":693 * cdef Weight _zero(weight_type): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( # <<<<<<<<<<<<<< * new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 693, __pyx_L1_error) } /* "pywrapfst.pyx":694 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) # <<<<<<<<<<<<<< * if _weight._weight.get().Type() == b"none": * raise FstArgError("Weight type not found") */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 694, __pyx_L1_error) /* "pywrapfst.pyx":693 * cdef Weight _zero(weight_type): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( # <<<<<<<<<<<<<< * new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": */ __pyx_v__weight->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::Zero(__pyx_t_2))); /* "pywrapfst.pyx":695 * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": # <<<<<<<<<<<<<< * raise FstArgError("Weight type not found") * return _weight */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 695, __pyx_L1_error) } __pyx_t_3 = ((__pyx_v__weight->_weight.get()->Type() == ((char const *)"none")) != 0); if (unlikely(__pyx_t_3)) { /* "pywrapfst.pyx":696 * new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< * return _weight * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 696, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_u_Weight_type_not_found) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_Weight_type_not_found); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 696, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 696, __pyx_L1_error) /* "pywrapfst.pyx":695 * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": # <<<<<<<<<<<<<< * raise FstArgError("Weight type not found") * return _weight */ } /* "pywrapfst.pyx":697 * if _weight._weight.get().Type() == b"none": * raise FstArgError("Weight type not found") * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":691 * * * cdef Weight _zero(weight_type): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pywrapfst._zero", __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":700 * * * cdef Weight _one(weight_type): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( */ static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__one(PyObject *__pyx_v_weight_type) { struct __pyx_obj_9pywrapfst_Weight *__pyx_v__weight = 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; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_one", 0); /* "pywrapfst.pyx":701 * * cdef Weight _one(weight_type): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 701, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":702 * cdef Weight _one(weight_type): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( # <<<<<<<<<<<<<< * new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 702, __pyx_L1_error) } /* "pywrapfst.pyx":703 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) # <<<<<<<<<<<<<< * if _weight._weight.get().Type() == b"none": * raise FstArgError("Weight type not found") */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 703, __pyx_L1_error) /* "pywrapfst.pyx":702 * cdef Weight _one(weight_type): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( # <<<<<<<<<<<<<< * new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": */ __pyx_v__weight->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::One(__pyx_t_2))); /* "pywrapfst.pyx":704 * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": # <<<<<<<<<<<<<< * raise FstArgError("Weight type not found") * return _weight */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 704, __pyx_L1_error) } __pyx_t_3 = ((__pyx_v__weight->_weight.get()->Type() == ((char const *)"none")) != 0); if (unlikely(__pyx_t_3)) { /* "pywrapfst.pyx":705 * new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": * raise FstArgError("Weight type not found") # <<<<<<<<<<<<<< * return _weight * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_u_Weight_type_not_found) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_Weight_type_not_found); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 705, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 705, __pyx_L1_error) /* "pywrapfst.pyx":704 * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) * if _weight._weight.get().Type() == b"none": # <<<<<<<<<<<<<< * raise FstArgError("Weight type not found") * return _weight */ } /* "pywrapfst.pyx":706 * if _weight._weight.get().Type() == b"none": * raise FstArgError("Weight type not found") * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":700 * * * cdef Weight _one(weight_type): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pywrapfst._one", __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":709 * * * cdef Weight _no_weight(weight_type): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( */ static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__no_weight(PyObject *__pyx_v_weight_type) { struct __pyx_obj_9pywrapfst_Weight *__pyx_v__weight = 0; struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; std::string __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_no_weight", 0); /* "pywrapfst.pyx":710 * * cdef Weight _no_weight(weight_type): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.NoWeight(tostring(weight_type)))) */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 710, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":711 * cdef Weight _no_weight(weight_type): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( # <<<<<<<<<<<<<< * new fst.WeightClass(fst.WeightClass.NoWeight(tostring(weight_type)))) * return _weight */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 711, __pyx_L1_error) } /* "pywrapfst.pyx":712 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.NoWeight(tostring(weight_type)))) # <<<<<<<<<<<<<< * return _weight * */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 712, __pyx_L1_error) /* "pywrapfst.pyx":711 * cdef Weight _no_weight(weight_type): * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( # <<<<<<<<<<<<<< * new fst.WeightClass(fst.WeightClass.NoWeight(tostring(weight_type)))) * return _weight */ __pyx_v__weight->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::NoWeight(__pyx_t_2))); /* "pywrapfst.pyx":713 * _weight._weight.reset( * new fst.WeightClass(fst.WeightClass.NoWeight(tostring(weight_type)))) * return _weight # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__weight)); __pyx_r = __pyx_v__weight; goto __pyx_L0; /* "pywrapfst.pyx":709 * * * cdef Weight _no_weight(weight_type): # <<<<<<<<<<<<<< * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset( */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pywrapfst._no_weight", __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":745 * # Doing so will allow undefined behavior. * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * */ /* Python wrapper */ static int __pyx_pw_9pywrapfst_15SymbolTableView_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_9pywrapfst_15SymbolTableView_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_15SymbolTableView___init__(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_9pywrapfst_15SymbolTableView___init__(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":746 * * def __init__(self): * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") # <<<<<<<<<<<<<< * * def __iter__(self): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Cannot_construct, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 746, __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, 746, __pyx_L1_error) /* "pywrapfst.pyx":745 * # Doing so will allow undefined behavior. * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pywrapfst.SymbolTableView.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":748 * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * * def __iter__(self): # <<<<<<<<<<<<<< * return _SymbolTableIterator(self) * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_3__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_3__iter__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_2__iter__(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_2__iter__(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__iter__", 0); /* "pywrapfst.pyx":749 * * def __iter__(self): * return _SymbolTableIterator(self) # <<<<<<<<<<<<<< * * # Registers the class for pickling. */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pywrapfst__SymbolTableIterator), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":748 * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * * def __iter__(self): # <<<<<<<<<<<<<< * return _SymbolTableIterator(self) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pywrapfst.SymbolTableView.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":753 * # Registers the class for pickling. * * def __reduce__(self): # <<<<<<<<<<<<<< * return (_read_SymbolTable_from_string, (self.write_to_string(),)) * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_5__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_5__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_15SymbolTableView_4__reduce__(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_4__reduce__(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce__", 0); /* "pywrapfst.pyx":754 * * def __reduce__(self): * return (_read_SymbolTable_from_string, (self.write_to_string(),)) # <<<<<<<<<<<<<< * * # Returns a raw const pointer to SymbolTable. */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_read_SymbolTable_from_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 754, __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, 754, __pyx_L1_error) } __pyx_t_2 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->write_to_string(__pyx_v_self, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 754, __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, 754, __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":753 * # Registers the class for pickling. * * def __reduce__(self): # <<<<<<<<<<<<<< * return (_read_SymbolTable_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.SymbolTableView.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":760 * # Should not be directly accessed except by `_raw_ptr_or_raise()`. * # All other methods should use the safer _raw_ptr_or_raise() instead. * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return NULL * */ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_15SymbolTableView__raw(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_raw", 0); /* "pywrapfst.pyx":761 * # All other methods should use the safer _raw_ptr_or_raise() instead. * cdef const_SymbolTable_ptr _raw(self): * return NULL # <<<<<<<<<<<<<< * * # Raises an FstOpError for a nonexistent SymbolTable. */ __pyx_r = NULL; goto __pyx_L0; /* "pywrapfst.pyx":760 * # Should not be directly accessed except by `_raw_ptr_or_raise()`. * # All other methods should use the safer _raw_ptr_or_raise() instead. * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return NULL * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":764 * * # Raises an FstOpError for a nonexistent SymbolTable. * cdef void _raise_nonexistent(self) except *: # <<<<<<<<<<<<<< * raise FstOpError("SymbolTable no longer exists") * */ static void __pyx_f_9pywrapfst_15SymbolTableView__raise_nonexistent(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_raise_nonexistent", 0); /* "pywrapfst.pyx":765 * # Raises an FstOpError for a nonexistent SymbolTable. * cdef void _raise_nonexistent(self) except *: * raise FstOpError("SymbolTable no longer exists") # <<<<<<<<<<<<<< * * # Internal API method that should be used when a const pointer to an */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_SymbolTable_no_longer_exists) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_SymbolTable_no_longer_exists); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 765, __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, 765, __pyx_L1_error) /* "pywrapfst.pyx":764 * * # Raises an FstOpError for a nonexistent SymbolTable. * cdef void _raise_nonexistent(self) except *: # <<<<<<<<<<<<<< * raise FstOpError("SymbolTable no longer exists") * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pywrapfst.SymbolTableView._raise_nonexistent", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":769 * # Internal API method that should be used when a const pointer to an * # fst.SymbolTable is required. * cdef const_SymbolTable_ptr _raw_ptr_or_raise(self) except *: # <<<<<<<<<<<<<< * cdef const_SymbolTable_ptr _raw = self._raw() * if _raw == NULL: */ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_15SymbolTableView__raw_ptr_or_raise(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_v__raw; __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_raw_ptr_or_raise", 0); /* "pywrapfst.pyx":770 * # fst.SymbolTable is required. * cdef const_SymbolTable_ptr _raw_ptr_or_raise(self) except *: * cdef const_SymbolTable_ptr _raw = self._raw() # <<<<<<<<<<<<<< * if _raw == NULL: * self._raise_nonexistent() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw"); __PYX_ERR(0, 770, __pyx_L1_error) } __pyx_v__raw = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw(__pyx_v_self); /* "pywrapfst.pyx":771 * cdef const_SymbolTable_ptr _raw_ptr_or_raise(self) except *: * cdef const_SymbolTable_ptr _raw = self._raw() * if _raw == NULL: # <<<<<<<<<<<<<< * self._raise_nonexistent() * return _raw */ __pyx_t_1 = ((__pyx_v__raw == NULL) != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":772 * cdef const_SymbolTable_ptr _raw = self._raw() * if _raw == NULL: * self._raise_nonexistent() # <<<<<<<<<<<<<< * return _raw * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raise_nonexistent"); __PYX_ERR(0, 772, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raise_nonexistent(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 772, __pyx_L1_error) /* "pywrapfst.pyx":771 * cdef const_SymbolTable_ptr _raw_ptr_or_raise(self) except *: * cdef const_SymbolTable_ptr _raw = self._raw() * if _raw == NULL: # <<<<<<<<<<<<<< * self._raise_nonexistent() * return _raw */ } /* "pywrapfst.pyx":773 * if _raw == NULL: * self._raise_nonexistent() * return _raw # <<<<<<<<<<<<<< * * cpdef int64 available_key(self) except *: */ __pyx_r = __pyx_v__raw; goto __pyx_L0; /* "pywrapfst.pyx":769 * # Internal API method that should be used when a const pointer to an * # fst.SymbolTable is required. * cdef const_SymbolTable_ptr _raw_ptr_or_raise(self) except *: # <<<<<<<<<<<<<< * cdef const_SymbolTable_ptr _raw = self._raw() * if _raw == NULL: */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pywrapfst.SymbolTableView._raw_ptr_or_raise", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":775 * return _raw * * cpdef int64 available_key(self) except *: # <<<<<<<<<<<<<< * """ * available_key(self) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_7available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static int64 __pyx_f_9pywrapfst_15SymbolTableView_available_key(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch) { 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; int64 __pyx_t_5; fst::SymbolTable const *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_available_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 775, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_7available_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 775, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 775, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":781 * Returns an integer indicating the next available key index in the table. * """ * return self._raw_ptr_or_raise().AvailableKey() # <<<<<<<<<<<<<< * * cpdef bytes checksum(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 781, __pyx_L1_error) } __pyx_t_6 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 781, __pyx_L1_error) __pyx_r = __pyx_t_6->AvailableKey(); goto __pyx_L0; /* "pywrapfst.pyx":775 * return _raw * * cpdef int64 available_key(self) except *: # <<<<<<<<<<<<<< * """ * 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_AddTraceback("pywrapfst.SymbolTableView.available_key", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_7available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_6available_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_15SymbolTableView_7available_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_15SymbolTableView_6available_key(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_6available_key(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int64 __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("available_key", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_available_key(__pyx_v_self, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 775, __pyx_L1_error) __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 775, __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.SymbolTableView.available_key", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":783 * return self._raw_ptr_or_raise().AvailableKey() * * cpdef bytes checksum(self): # <<<<<<<<<<<<<< * """ * checksum(self) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_9checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_f_9pywrapfst_15SymbolTableView_checksum(struct __pyx_obj_9pywrapfst_SymbolTableView *__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; fst::SymbolTable const *__pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 783, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_9checksum)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 783, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 783, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":789 * Returns a bytestring indicating the label-independent MD5 checksum. * """ * return self._raw_ptr_or_raise().CheckSum() # <<<<<<<<<<<<<< * * cpdef SymbolTable copy(self): */ __Pyx_XDECREF(__pyx_r); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 789, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 789, __pyx_L1_error) __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_5->CheckSum()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 789, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":783 * return self._raw_ptr_or_raise().AvailableKey() * * cpdef bytes 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_AddTraceback("pywrapfst.SymbolTableView.checksum", __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_15SymbolTableView_9checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_8checksum[] = "\n checksum(self)\n\n Returns a bytestring indicating the label-independent MD5 checksum.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_9checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("checksum (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_8checksum(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_8checksum(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("checksum", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_checksum(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 783, __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.SymbolTableView.checksum", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":791 * return self._raw_ptr_or_raise().CheckSum() * * cpdef SymbolTable copy(self): # <<<<<<<<<<<<<< * """ * copy(self) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_11copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_15SymbolTableView_copy(struct __pyx_obj_9pywrapfst_SymbolTableView *__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; fst::SymbolTable const *__pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_11copy)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 791, __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, 791, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":797 * Returns a mutable copy of the SymbolTable. * """ * return _init_SymbolTable(WrapUnique(self._raw_ptr_or_raise().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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 797, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 797, __pyx_L1_error) __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::WrapUnique(__pyx_t_5->Copy()))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __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":791 * return self._raw_ptr_or_raise().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.SymbolTableView.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_15SymbolTableView_11copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_10copy[] = "\n copy(self)\n\n Returns a mutable copy of the SymbolTable.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_11copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("copy (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_10copy(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_10copy(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_15SymbolTableView_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 791, __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.SymbolTableView.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":799 * return _init_SymbolTable(WrapUnique(self._raw_ptr_or_raise().Copy())) * * def find(self, key): # <<<<<<<<<<<<<< * """ * find(self, key) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_13find(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_12find[] = "\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_15SymbolTableView_13find(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("find (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_12find(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), ((PyObject *)__pyx_v_key)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_12find(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_key) { __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_v__raw; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations fst::SymbolTable const *__pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; std::string __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int64 __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("find", 0); /* "pywrapfst.pyx":816 * not found. * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() # <<<<<<<<<<<<<< * try: * return _raw.FindIndex(tostring(key)) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 816, __pyx_L1_error) } __pyx_t_1 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 816, __pyx_L1_error) __pyx_v__raw = __pyx_t_1; /* "pywrapfst.pyx":817 * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: # <<<<<<<<<<<<<< * return _raw.FindIndex(tostring(key)) * except TypeError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "pywrapfst.pyx":818 * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: * return _raw.FindIndex(tostring(key)) # <<<<<<<<<<<<<< * except TypeError: * return _raw.FindSymbol(key) */ __Pyx_XDECREF(__pyx_r); __pyx_t_5 = __pyx_f_9pywrapfst_tostring(__pyx_v_key); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 818, __pyx_L3_error) __pyx_t_6 = __Pyx_PyInt_From_int64_t(__pyx_v__raw->Find(__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 818, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L7_try_return; /* "pywrapfst.pyx":817 * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: # <<<<<<<<<<<<<< * return _raw.FindIndex(tostring(key)) * except TypeError: */ } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "pywrapfst.pyx":819 * try: * return _raw.FindIndex(tostring(key)) * except TypeError: # <<<<<<<<<<<<<< * return _raw.FindSymbol(key) * */ __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_7) { __Pyx_AddTraceback("pywrapfst.SymbolTableView.find", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(0, 819, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_9); /* "pywrapfst.pyx":820 * return _raw.FindIndex(tostring(key)) * except TypeError: * return _raw.FindSymbol(key) # <<<<<<<<<<<<<< * * cpdef int64 get_nth_key(self, ssize_t pos) except *: */ __Pyx_XDECREF(__pyx_r); __pyx_t_10 = __Pyx_PyInt_As_int64_t(__pyx_v_key); if (unlikely((__pyx_t_10 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 820, __pyx_L5_except_error) __pyx_t_11 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v__raw->Find(__pyx_t_10)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 820, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_11); __pyx_r = __pyx_t_11; __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L6_except_return; } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "pywrapfst.pyx":817 * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: # <<<<<<<<<<<<<< * return _raw.FindIndex(tostring(key)) * except TypeError: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L7_try_return:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L0; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L0; } /* "pywrapfst.pyx":799 * return _init_SymbolTable(WrapUnique(self._raw_ptr_or_raise().Copy())) * * def find(self, key): # <<<<<<<<<<<<<< * """ * find(self, key) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("pywrapfst.SymbolTableView.find", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":822 * return _raw.FindSymbol(key) * * cpdef int64 get_nth_key(self, ssize_t pos) except *: # <<<<<<<<<<<<<< * """ * get_nth_key(self, pos) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_15get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos); /*proto*/ static int64 __pyx_f_9pywrapfst_15SymbolTableView_get_nth_key(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, Py_ssize_t __pyx_v_pos, int __pyx_skip_dispatch) { 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; int64 __pyx_t_6; fst::SymbolTable const *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_nth_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_15get_nth_key)) { __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 822, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_6 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 822, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":834 * The integer index of the n-th key, or NO_LABEL if not found. * """ * return self._raw_ptr_or_raise().GetNthKey(pos) # <<<<<<<<<<<<<< * * cpdef bytes labeled_checksum(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 834, __pyx_L1_error) } __pyx_t_7 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 834, __pyx_L1_error) __pyx_r = __pyx_t_7->GetNthKey(__pyx_v_pos); goto __pyx_L0; /* "pywrapfst.pyx":822 * return _raw.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_AddTraceback("pywrapfst.SymbolTableView.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_15SymbolTableView_15get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_14get_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_15SymbolTableView_15get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos) { Py_ssize_t __pyx_v_pos; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 822, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst.SymbolTableView.get_nth_key", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_14get_nth_key(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), ((Py_ssize_t)__pyx_v_pos)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_14get_nth_key(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, Py_ssize_t __pyx_v_pos) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int64 __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_nth_key", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_get_nth_key(__pyx_v_self, __pyx_v_pos, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 822, __pyx_L1_error) __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 822, __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.SymbolTableView.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":836 * return self._raw_ptr_or_raise().GetNthKey(pos) * * cpdef bytes labeled_checksum(self): # <<<<<<<<<<<<<< * """ * labeled_checksum(self) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_17labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_f_9pywrapfst_15SymbolTableView_labeled_checksum(struct __pyx_obj_9pywrapfst_SymbolTableView *__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; fst::SymbolTable const *__pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_labeled_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_17labeled_checksum)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 836, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":842 * Returns a bytestring indicating the label-dependent MD5 checksum. * """ * return self._raw_ptr_or_raise().LabeledCheckSum() # <<<<<<<<<<<<<< * * cpdef bool member(self, key) except *: */ __Pyx_XDECREF(__pyx_r); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 842, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 842, __pyx_L1_error) __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_5->LabeledCheckSum()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 842, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":836 * return self._raw_ptr_or_raise().GetNthKey(pos) * * cpdef bytes 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_AddTraceback("pywrapfst.SymbolTableView.labeled_checksum", __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_15SymbolTableView_17labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_16labeled_checksum[] = "\n labeled_checksum(self)\n\n Returns a bytestring indicating the label-dependent MD5 checksum.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_17labeled_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_15SymbolTableView_16labeled_checksum(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_16labeled_checksum(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("labeled_checksum", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_labeled_checksum(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 836, __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.SymbolTableView.labeled_checksum", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":844 * return self._raw_ptr_or_raise().LabeledCheckSum() * * cpdef bool member(self, key) except *: # <<<<<<<<<<<<<< * """ * member(self, key) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_19member(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static bool __pyx_f_9pywrapfst_15SymbolTableView_member(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch) { __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_v__raw; 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; fst::SymbolTable const *__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; int64 __pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_member); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_19member)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_key) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_key); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 844, __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, 844, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":860 * Whether or not the key is present (as a string or a index) in the table. * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() # <<<<<<<<<<<<<< * try: * return _raw.MemberSymbol(tostring(key)) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 860, __pyx_L1_error) } __pyx_t_6 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 860, __pyx_L1_error) __pyx_v__raw = __pyx_t_6; /* "pywrapfst.pyx":861 * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: # <<<<<<<<<<<<<< * return _raw.MemberSymbol(tostring(key)) * except TypeError: */ { __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":862 * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: * return _raw.MemberSymbol(tostring(key)) # <<<<<<<<<<<<<< * except TypeError: * return _raw.MemberIndex(key) */ __pyx_t_10 = __pyx_f_9pywrapfst_tostring(__pyx_v_key); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 862, __pyx_L3_error) __pyx_r = __pyx_v__raw->Member(__pyx_t_10); goto __pyx_L7_try_return; /* "pywrapfst.pyx":861 * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: # <<<<<<<<<<<<<< * return _raw.MemberSymbol(tostring(key)) * except TypeError: */ } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":863 * try: * return _raw.MemberSymbol(tostring(key)) * except TypeError: # <<<<<<<<<<<<<< * return _raw.MemberIndex(key) * */ __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_11) { __Pyx_AddTraceback("pywrapfst.SymbolTableView.member", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 863, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_3); /* "pywrapfst.pyx":864 * return _raw.MemberSymbol(tostring(key)) * except TypeError: * return _raw.MemberIndex(key) # <<<<<<<<<<<<<< * * cpdef string name(self) except *: */ __pyx_t_12 = __Pyx_PyInt_As_int64_t(__pyx_v_key); if (unlikely((__pyx_t_12 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 864, __pyx_L5_except_error) __pyx_r = __pyx_v__raw->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":861 * """ * cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() * try: # <<<<<<<<<<<<<< * return _raw.MemberSymbol(tostring(key)) * except TypeError: */ __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":844 * return self._raw_ptr_or_raise().LabeledCheckSum() * * cpdef bool member(self, key) except *: # <<<<<<<<<<<<<< * """ * 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_AddTraceback("pywrapfst.SymbolTableView.member", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_19member(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_18member[] = "\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_15SymbolTableView_19member(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("member (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_18member(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), ((PyObject *)__pyx_v_key)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_18member(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_key) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations bool __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("member", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_member(__pyx_v_self, __pyx_v_key, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 844, __pyx_L1_error) __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 844, __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.SymbolTableView.member", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":866 * return _raw.MemberIndex(key) * * cpdef string name(self) except *: # <<<<<<<<<<<<<< * """ * name(self) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static std::string __pyx_f_9pywrapfst_15SymbolTableView_name(struct __pyx_obj_9pywrapfst_SymbolTableView *__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; fst::SymbolTable const *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 866, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 866, __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, 866, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":872 * Returns the symbol table's name. * """ * return self._raw_ptr_or_raise().Name() # <<<<<<<<<<<<<< * * cpdef size_t num_symbols(self) except *: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 872, __pyx_L1_error) } __pyx_t_6 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 872, __pyx_L1_error) __pyx_r = __pyx_t_6->Name(); goto __pyx_L0; /* "pywrapfst.pyx":866 * return _raw.MemberIndex(key) * * cpdef string name(self) except *: # <<<<<<<<<<<<<< * """ * 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_AddTraceback("pywrapfst.SymbolTableView.name", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_20name[] = "\n name(self)\n\n Returns the symbol table's name.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_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_15SymbolTableView_20name(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_20name(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("name", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_name(__pyx_v_self, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 866, __pyx_L1_error) __pyx_t_2 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 866, __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.SymbolTableView.name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":874 * return self._raw_ptr_or_raise().Name() * * cpdef size_t num_symbols(self) except *: # <<<<<<<<<<<<<< * """ * num_symbols(self) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static size_t __pyx_f_9pywrapfst_15SymbolTableView_num_symbols(struct __pyx_obj_9pywrapfst_SymbolTableView *__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; fst::SymbolTable const *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 874, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 874, __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, 874, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":880 * Returns the number of symbols in the symbol table. * """ * return self._raw_ptr_or_raise().NumSymbols() # <<<<<<<<<<<<<< * * cpdef void write(self, source) except *: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 880, __pyx_L1_error) } __pyx_t_6 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 880, __pyx_L1_error) __pyx_r = __pyx_t_6->NumSymbols(); goto __pyx_L0; /* "pywrapfst.pyx":874 * return self._raw_ptr_or_raise().Name() * * cpdef size_t num_symbols(self) except *: # <<<<<<<<<<<<<< * """ * 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_AddTraceback("pywrapfst.SymbolTableView.num_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_22num_symbols[] = "\n num_symbols(self)\n\n Returns the number of symbols in the symbol table.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_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_15SymbolTableView_22num_symbols(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_22num_symbols(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations size_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("num_symbols", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_num_symbols(__pyx_v_self, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 874, __pyx_L1_error) __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 874, __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.SymbolTableView.num_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":882 * return self._raw_ptr_or_raise().NumSymbols() * * cpdef void write(self, source) except *: # <<<<<<<<<<<<<< * """ * write(self, source) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static void __pyx_f_9pywrapfst_15SymbolTableView_write(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_source, 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; fst::SymbolTable const *__pyx_t_5; std::string __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 882, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_source) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_source); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 882, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":896 * FstIOError: Write failed. * """ * if not self._raw_ptr_or_raise().Write(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 896, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 896, __pyx_L1_error) __pyx_t_6 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 896, __pyx_L1_error) __pyx_t_7 = ((!(__pyx_t_5->Write(__pyx_t_6) != 0)) != 0); if (unlikely(__pyx_t_7)) { /* "pywrapfst.pyx":897 * """ * if not self._raw_ptr_or_raise().Write(path_tostring(source)): * raise FstIOError(f"Write failed: {source!r}") # <<<<<<<<<<<<<< * * cpdef void write_text(self, source) except *: */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Write_failed, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 897, __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 && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 897, __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, 897, __pyx_L1_error) /* "pywrapfst.pyx":896 * FstIOError: Write failed. * """ * if not self._raw_ptr_or_raise().Write(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ } /* "pywrapfst.pyx":882 * return self._raw_ptr_or_raise().NumSymbols() * * cpdef void write(self, source) except *: # <<<<<<<<<<<<<< * """ * write(self, source) */ /* 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_AddTraceback("pywrapfst.SymbolTableView.write", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_24write[] = "\n write(self, source)\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 source: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("write (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_24write(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), ((PyObject *)__pyx_v_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_24write(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write", 0); __Pyx_XDECREF(__pyx_r); __pyx_f_9pywrapfst_15SymbolTableView_write(__pyx_v_self, __pyx_v_source, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 882, __pyx_L1_error) __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 882, __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.SymbolTableView.write", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":899 * raise FstIOError(f"Write failed: {source!r}") * * cpdef void write_text(self, source) except *: # <<<<<<<<<<<<<< * """ * write_text(self, source) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static void __pyx_f_9pywrapfst_15SymbolTableView_write_text(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_source, 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; fst::SymbolTable const *__pyx_t_5; std::string __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write_text); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_source) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_source); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 899, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":913 * FstIOError: Write failed. * """ * if not self._raw_ptr_or_raise().WriteText(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 913, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 913, __pyx_L1_error) __pyx_t_6 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 913, __pyx_L1_error) __pyx_t_7 = ((!(__pyx_t_5->WriteText(__pyx_t_6) != 0)) != 0); if (unlikely(__pyx_t_7)) { /* "pywrapfst.pyx":914 * """ * if not self._raw_ptr_or_raise().WriteText(path_tostring(source)): * raise FstIOError(f"Write failed: {source!r}") # <<<<<<<<<<<<<< * * cpdef bytes write_to_string(self): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Write_failed, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 914, __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 && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 914, __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, 914, __pyx_L1_error) /* "pywrapfst.pyx":913 * FstIOError: Write failed. * """ * if not self._raw_ptr_or_raise().WriteText(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ } /* "pywrapfst.pyx":899 * raise FstIOError(f"Write failed: {source!r}") * * cpdef void write_text(self, source) except *: # <<<<<<<<<<<<<< * """ * write_text(self, source) */ /* 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_AddTraceback("pywrapfst.SymbolTableView.write_text", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_26write_text[] = "\n write_text(self, source)\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 source: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("write_text (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_15SymbolTableView_26write_text(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), ((PyObject *)__pyx_v_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_26write_text(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write_text", 0); __Pyx_XDECREF(__pyx_r); __pyx_f_9pywrapfst_15SymbolTableView_write_text(__pyx_v_self, __pyx_v_source, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 899, __pyx_L1_error) __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 899, __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.SymbolTableView.write_text", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":916 * raise FstIOError(f"Write failed: {source!r}") * * cpdef bytes write_to_string(self): # <<<<<<<<<<<<<< * """ * write_to_string(self) */ static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_29write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_f_9pywrapfst_15SymbolTableView_write_to_string(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self, int __pyx_skip_dispatch) { std::stringstream __pyx_v__sstrm; 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; fst::SymbolTable const *__pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write_to_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 916, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_15SymbolTableView_29write_to_string)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 916, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 916, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":929 * """ * cdef stringstream _sstrm * if not self._raw_ptr_or_raise().Write(_sstrm): # <<<<<<<<<<<<<< * 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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 929, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 929, __pyx_L1_error) __pyx_t_6 = ((!(__pyx_t_5->Write(__pyx_v__sstrm) != 0)) != 0); if (unlikely(__pyx_t_6)) { /* "pywrapfst.pyx":930 * cdef stringstream _sstrm * if not self._raw_ptr_or_raise().Write(_sstrm): * raise FstIOError("Write to string failed") # <<<<<<<<<<<<<< * return _sstrm.str() * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 930, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_Write_to_string_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_Write_to_string_failed); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 930, __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, 930, __pyx_L1_error) /* "pywrapfst.pyx":929 * """ * cdef stringstream _sstrm * if not self._raw_ptr_or_raise().Write(_sstrm): # <<<<<<<<<<<<<< * raise FstIOError("Write to string failed") * return _sstrm.str() */ } /* "pywrapfst.pyx":931 * if not self._raw_ptr_or_raise().Write(_sstrm): * raise FstIOError("Write to string failed") * return _sstrm.str() # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v__sstrm.str()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 931, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":916 * raise FstIOError(f"Write failed: {source!r}") * * cpdef bytes 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_AddTraceback("pywrapfst.SymbolTableView.write_to_string", __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_15SymbolTableView_29write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_15SymbolTableView_28write_to_string[] = "\n write_to_string(self)\n\n Serializes SymbolTable to a string.\n\n Returns:\n A bytestring.\n\n Raises:\n FstIOError: Write to string failed.\n "; static PyObject *__pyx_pw_9pywrapfst_15SymbolTableView_29write_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_15SymbolTableView_28write_to_string(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_15SymbolTableView_28write_to_string(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write_to_string", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_15SymbolTableView_write_to_string(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 916, __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.SymbolTableView.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":949 * # Doing so will allow undefined behavior. * * def __repr__(self): # <<<<<<<<<<<<<< * return (f"") */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_28_EncodeMapperSymbolTableView_1__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_28_EncodeMapperSymbolTableView_1__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_28_EncodeMapperSymbolTableView___repr__(((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_28_EncodeMapperSymbolTableView___repr__(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; std::string __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":950 * * def __repr__(self): * return (f"") * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 950, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_const_EncodeMapper_SymbolTableV); __pyx_t_2 += 36; __Pyx_GIVEREF(__pyx_kp_u_const_EncodeMapper_SymbolTableV); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_const_EncodeMapper_SymbolTableV); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); __PYX_ERR(0, 950, __pyx_L1_error) } __pyx_t_4 = ((struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTableView *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.name(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 950, __pyx_L1_error) __pyx_t_5 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 950, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_5), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 950, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); __pyx_t_6 = 0; __Pyx_INCREF(__pyx_kp_u_at_0x); __pyx_t_2 += 6; __Pyx_GIVEREF(__pyx_kp_u_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_at_0x); /* "pywrapfst.pyx":951 * def __repr__(self): * return (f"") # <<<<<<<<<<<<<< * * cdef const_SymbolTable_ptr _raw(self): */ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 951, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_6, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 951, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__3); /* "pywrapfst.pyx":950 * * def __repr__(self): * return (f"") * */ __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 950, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":949 * # Doing so will allow undefined behavior. * * def __repr__(self): # <<<<<<<<<<<<<< * return (f"") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pywrapfst._EncodeMapperSymbolTableView.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":953 * f"at 0x{id(self):x}>") * * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return (self._mapper.get().InputSymbols() if self._input_side * else self._mapper.get().OutputSymbols()) */ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_28_EncodeMapperSymbolTableView__raw(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_v_self) { __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations fst::SymbolTable const *__pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_raw", 0); /* "pywrapfst.pyx":954 * * cdef const_SymbolTable_ptr _raw(self): * return (self._mapper.get().InputSymbols() if self._input_side # <<<<<<<<<<<<<< * else self._mapper.get().OutputSymbols()) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_input_side"); __PYX_ERR(0, 954, __pyx_L1_error) } if ((__pyx_v_self->_input_side != 0)) { if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 954, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_mapper.get()->InputSymbols(); } else { /* "pywrapfst.pyx":955 * cdef const_SymbolTable_ptr _raw(self): * return (self._mapper.get().InputSymbols() if self._input_side * else self._mapper.get().OutputSymbols()) # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 955, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_mapper.get()->OutputSymbols(); } __pyx_r = __pyx_t_1; goto __pyx_L0; /* "pywrapfst.pyx":953 * f"at 0x{id(self):x}>") * * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return (self._mapper.get().InputSymbols() if self._input_side * else self._mapper.get().OutputSymbols()) */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst._EncodeMapperSymbolTableView._raw", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":972 * # Doing so will allow undefined behavior. * * def __repr__(self): # <<<<<<<<<<<<<< * return (f"") */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_19_FstSymbolTableView_1__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_19_FstSymbolTableView_1__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_19_FstSymbolTableView___repr__(((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_19_FstSymbolTableView___repr__(struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; std::string __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":973 * * def __repr__(self): * return (f"") * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_const_Fst_SymbolTableView); __pyx_t_2 += 27; __Pyx_GIVEREF(__pyx_kp_u_const_Fst_SymbolTableView); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_const_Fst_SymbolTableView); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); __PYX_ERR(0, 973, __pyx_L1_error) } __pyx_t_4 = ((struct __pyx_vtabstruct_9pywrapfst__FstSymbolTableView *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.name(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 973, __pyx_L1_error) __pyx_t_5 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_5), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); __pyx_t_6 = 0; __Pyx_INCREF(__pyx_kp_u_at_0x); __pyx_t_2 += 6; __Pyx_GIVEREF(__pyx_kp_u_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_at_0x); /* "pywrapfst.pyx":974 * def __repr__(self): * return (f"") # <<<<<<<<<<<<<< * * cdef const_SymbolTable_ptr _raw(self): */ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_6, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__3); /* "pywrapfst.pyx":973 * * def __repr__(self): * return (f"") * */ __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 973, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":972 * # Doing so will allow undefined behavior. * * def __repr__(self): # <<<<<<<<<<<<<< * return (f"") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pywrapfst._FstSymbolTableView.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":976 * f"at 0x{id(self):x}>") * * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return (self._fst.get().InputSymbols() if self._input_side * else self._fst.get().OutputSymbols()) */ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_19_FstSymbolTableView__raw(struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_v_self) { __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations fst::SymbolTable const *__pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_raw", 0); /* "pywrapfst.pyx":977 * * cdef const_SymbolTable_ptr _raw(self): * return (self._fst.get().InputSymbols() if self._input_side # <<<<<<<<<<<<<< * else self._fst.get().OutputSymbols()) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_input_side"); __PYX_ERR(0, 977, __pyx_L1_error) } if ((__pyx_v_self->_input_side != 0)) { if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 977, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_fst.get()->InputSymbols(); } else { /* "pywrapfst.pyx":978 * cdef const_SymbolTable_ptr _raw(self): * return (self._fst.get().InputSymbols() if self._input_side * else self._fst.get().OutputSymbols()) # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 978, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_fst.get()->OutputSymbols(); } __pyx_r = __pyx_t_1; goto __pyx_L0; /* "pywrapfst.pyx":976 * f"at 0x{id(self):x}>") * * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return (self._fst.get().InputSymbols() if self._input_side * else self._fst.get().OutputSymbols()) */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst._FstSymbolTableView._raw", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":992 * """ * * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return self._mutable_raw() * */ static __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_f_9pywrapfst_19_MutableSymbolTable__raw(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self) { __pyx_t_9pywrapfst_const_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_raw", 0); /* "pywrapfst.pyx":993 * * cdef const_SymbolTable_ptr _raw(self): * return self._mutable_raw() # <<<<<<<<<<<<<< * * # Returns a mutable raw pointer to SymbolTable. */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mutable_raw"); __PYX_ERR(0, 993, __pyx_L1_error) } __pyx_r = ((struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->_mutable_raw(__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":992 * """ * * cdef const_SymbolTable_ptr _raw(self): # <<<<<<<<<<<<<< * return self._mutable_raw() * */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst._MutableSymbolTable._raw", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":999 * # Should not be directly accessed except by `_mutable__raw_ptr_or_raise()`. * # All other methods should use the safer _mutable__raw_ptr_or_raise() instead. * cdef SymbolTable_ptr _mutable_raw(self): # <<<<<<<<<<<<<< * return NULL * */ static __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_19_MutableSymbolTable__mutable_raw(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self) { __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_mutable_raw", 0); /* "pywrapfst.pyx":1000 * # All other methods should use the safer _mutable__raw_ptr_or_raise() instead. * cdef SymbolTable_ptr _mutable_raw(self): * return NULL # <<<<<<<<<<<<<< * * # Internal API method that should be used when a mutable pointer to an */ __pyx_r = NULL; goto __pyx_L0; /* "pywrapfst.pyx":999 * # Should not be directly accessed except by `_mutable__raw_ptr_or_raise()`. * # All other methods should use the safer _mutable__raw_ptr_or_raise() instead. * cdef SymbolTable_ptr _mutable_raw(self): # <<<<<<<<<<<<<< * return NULL * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1004 * # Internal API method that should be used when a mutable pointer to an * # fst.SymbolTable is required. * cdef SymbolTable_ptr _mutable_raw_ptr_or_raise(self) except *: # <<<<<<<<<<<<<< * cdef SymbolTable_ptr mutable_raw = self._mutable_raw() * if mutable_raw == NULL: */ static __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_19_MutableSymbolTable__mutable_raw_ptr_or_raise(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self) { __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_v_mutable_raw; __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_mutable_raw_ptr_or_raise", 0); /* "pywrapfst.pyx":1005 * # fst.SymbolTable is required. * cdef SymbolTable_ptr _mutable_raw_ptr_or_raise(self) except *: * cdef SymbolTable_ptr mutable_raw = self._mutable_raw() # <<<<<<<<<<<<<< * if mutable_raw == NULL: * self._raise_nonexistent() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mutable_raw"); __PYX_ERR(0, 1005, __pyx_L1_error) } __pyx_v_mutable_raw = ((struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->_mutable_raw(__pyx_v_self); /* "pywrapfst.pyx":1006 * cdef SymbolTable_ptr _mutable_raw_ptr_or_raise(self) except *: * cdef SymbolTable_ptr mutable_raw = self._mutable_raw() * if mutable_raw == NULL: # <<<<<<<<<<<<<< * self._raise_nonexistent() * return mutable_raw */ __pyx_t_1 = ((__pyx_v_mutable_raw == NULL) != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":1007 * cdef SymbolTable_ptr mutable_raw = self._mutable_raw() * if mutable_raw == NULL: * self._raise_nonexistent() # <<<<<<<<<<<<<< * return mutable_raw * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raise_nonexistent"); __PYX_ERR(0, 1007, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._raise_nonexistent(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1007, __pyx_L1_error) /* "pywrapfst.pyx":1006 * cdef SymbolTable_ptr _mutable_raw_ptr_or_raise(self) except *: * cdef SymbolTable_ptr mutable_raw = self._mutable_raw() * if mutable_raw == NULL: # <<<<<<<<<<<<<< * self._raise_nonexistent() * return mutable_raw */ } /* "pywrapfst.pyx":1008 * if mutable_raw == NULL: * self._raise_nonexistent() * return mutable_raw # <<<<<<<<<<<<<< * * cpdef int64 add_symbol(self, symbol, int64 key=fst.kNoSymbol) except *: */ __pyx_r = __pyx_v_mutable_raw; goto __pyx_L0; /* "pywrapfst.pyx":1004 * # Internal API method that should be used when a mutable pointer to an * # fst.SymbolTable is required. * cdef SymbolTable_ptr _mutable_raw_ptr_or_raise(self) except *: # <<<<<<<<<<<<<< * cdef SymbolTable_ptr mutable_raw = self._mutable_raw() * if mutable_raw == NULL: */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pywrapfst._MutableSymbolTable._mutable_raw_ptr_or_raise", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1010 * return mutable_raw * * cpdef int64 add_symbol(self, symbol, int64 key=fst.kNoSymbol) except *: # <<<<<<<<<<<<<< * """ * 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 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) { int64 __pyx_v_key = __pyx_k__6; __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_v__mutable_raw; std::string __pyx_v__symbol; 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; int64 __pyx_t_8; fst::SymbolTable *__pyx_t_9; std::string __pyx_t_10; int __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1010, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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, 1010, __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, 1010, __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, 1010, __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, 1010, __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, 1010, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1010, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1027 * The integer key of the new symbol. * """ * cdef SymbolTable_ptr _mutable_raw = self._mutable_raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef string _symbol = tostring(symbol) * if key != fst.kNoSymbol: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mutable_raw_ptr_or_raise"); __PYX_ERR(0, 1027, __pyx_L1_error) } __pyx_t_9 = ((struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->_mutable_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1027, __pyx_L1_error) __pyx_v__mutable_raw = __pyx_t_9; /* "pywrapfst.pyx":1028 * """ * cdef SymbolTable_ptr _mutable_raw = self._mutable_raw_ptr_or_raise() * cdef string _symbol = tostring(symbol) # <<<<<<<<<<<<<< * if key != fst.kNoSymbol: * return _mutable_raw.AddSymbol(_symbol, key) */ __pyx_t_10 = __pyx_f_9pywrapfst_tostring(__pyx_v_symbol); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1028, __pyx_L1_error) __pyx_v__symbol = __pyx_t_10; /* "pywrapfst.pyx":1029 * cdef SymbolTable_ptr _mutable_raw = self._mutable_raw_ptr_or_raise() * cdef string _symbol = tostring(symbol) * if key != fst.kNoSymbol: # <<<<<<<<<<<<<< * return _mutable_raw.AddSymbol(_symbol, key) * else: */ __pyx_t_11 = ((__pyx_v_key != fst::kNoSymbol) != 0); if (__pyx_t_11) { /* "pywrapfst.pyx":1030 * cdef string _symbol = tostring(symbol) * if key != fst.kNoSymbol: * return _mutable_raw.AddSymbol(_symbol, key) # <<<<<<<<<<<<<< * else: * return _mutable_raw.AddSymbol(_symbol) */ __pyx_r = __pyx_v__mutable_raw->AddSymbol(__pyx_v__symbol, __pyx_v_key); goto __pyx_L0; /* "pywrapfst.pyx":1029 * cdef SymbolTable_ptr _mutable_raw = self._mutable_raw_ptr_or_raise() * cdef string _symbol = tostring(symbol) * if key != fst.kNoSymbol: # <<<<<<<<<<<<<< * return _mutable_raw.AddSymbol(_symbol, key) * else: */ } /* "pywrapfst.pyx":1032 * return _mutable_raw.AddSymbol(_symbol, key) * else: * return _mutable_raw.AddSymbol(_symbol) # <<<<<<<<<<<<<< * * cpdef void add_table(self, SymbolTableView symbols) except *: */ /*else*/ { __pyx_r = __pyx_v__mutable_raw->AddSymbol(__pyx_v__symbol); goto __pyx_L0; } /* "pywrapfst.pyx":1010 * return mutable_raw * * cpdef int64 add_symbol(self, symbol, int64 key=fst.kNoSymbol) except *: # <<<<<<<<<<<<<< * """ * 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_AddTraceback("pywrapfst._MutableSymbolTable.add_symbol", __pyx_clineno, __pyx_lineno, __pyx_filename); __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; int64 __pyx_v_key; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 1010, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1010, __pyx_L3_error) } else { __pyx_v_key = __pyx_k__6; } } 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, 1010, __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, int64 __pyx_v_key) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int64 __pyx_t_1; struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1010, __pyx_L1_error) __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1010, __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":1034 * return _mutable_raw.AddSymbol(_symbol) * * cpdef void add_table(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * """ * add_table(self, symbols) */ static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols); /*proto*/ static void __pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols, 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; fst::SymbolTable *__pyx_t_5; fst::SymbolTable const *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1034, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_symbols)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_symbols)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1034, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1046 * symbols: A SymbolTable to be merged with the current table. * """ * self._mutable_raw_ptr_or_raise().AddTable( # <<<<<<<<<<<<<< * deref(symbols._raw_ptr_or_raise())) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mutable_raw_ptr_or_raise"); __PYX_ERR(0, 1046, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->_mutable_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1046, __pyx_L1_error) /* "pywrapfst.pyx":1047 * """ * self._mutable_raw_ptr_or_raise().AddTable( * deref(symbols._raw_ptr_or_raise())) # <<<<<<<<<<<<<< * * cpdef void set_name(self, new_name) except *: */ if (unlikely(((PyObject *)__pyx_v_symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1047, __pyx_L1_error) } __pyx_t_6 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_symbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1047, __pyx_L1_error) /* "pywrapfst.pyx":1046 * symbols: A SymbolTable to be merged with the current table. * """ * self._mutable_raw_ptr_or_raise().AddTable( # <<<<<<<<<<<<<< * deref(symbols._raw_ptr_or_raise())) * */ __pyx_t_5->AddTable((*__pyx_t_6)); /* "pywrapfst.pyx":1034 * return _mutable_raw.AddSymbol(_symbol) * * cpdef void add_table(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * """ * add_table(self, symbols) */ /* 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_AddTraceback("pywrapfst._MutableSymbolTable.add_table", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols); /*proto*/ static char __pyx_doc_9pywrapfst_19_MutableSymbolTable_2add_table[] = "\n add_table(self, symbols)\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 symbols: 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_symbols) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add_table (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_symbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "symbols", 0))) __PYX_ERR(0, 1034, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_2add_table(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_symbols)); /* 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_SymbolTableView *__pyx_v_symbols) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_table", 0); __Pyx_XDECREF(__pyx_r); __pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(__pyx_v_self, __pyx_v_symbols, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1034, __pyx_L1_error) __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1034, __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":1049 * deref(symbols._raw_ptr_or_raise())) * * cpdef void set_name(self, new_name) except *: # <<<<<<<<<<<<<< * self._mutable_raw_ptr_or_raise().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; fst::SymbolTable *__pyx_t_5; std::string __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_new_name) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_new_name); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1049, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1050 * * cpdef void set_name(self, new_name) except *: * self._mutable_raw_ptr_or_raise().SetName(tostring(new_name)) # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mutable_raw_ptr_or_raise"); __PYX_ERR(0, 1050, __pyx_L1_error) } __pyx_t_5 = ((struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->_mutable_raw_ptr_or_raise(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1050, __pyx_L1_error) __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_new_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1050, __pyx_L1_error) __pyx_t_5->SetName(__pyx_t_6); /* "pywrapfst.pyx":1049 * deref(symbols._raw_ptr_or_raise())) * * cpdef void set_name(self, new_name) except *: # <<<<<<<<<<<<<< * self._mutable_raw_ptr_or_raise().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_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 1049, __pyx_L1_error) __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1049, __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; } /* "pywrapfst.pyx":1060 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_26_MutableFstSymbolTableView_1__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_26_MutableFstSymbolTableView_1__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_26_MutableFstSymbolTableView___repr__(((struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_26_MutableFstSymbolTableView___repr__(struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; std::string __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":1061 * * def __repr__(self): * return f"" # <<<<<<<<<<<<<< * * cdef SymbolTable_ptr _mutable_raw(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_Fst_SymbolTableView); __pyx_t_2 += 21; __Pyx_GIVEREF(__pyx_kp_u_Fst_SymbolTableView); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Fst_SymbolTableView); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); __PYX_ERR(0, 1061, __pyx_L1_error) } __pyx_t_4 = ((struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTableView *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.name(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1061, __pyx_L1_error) __pyx_t_5 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_5), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); __pyx_t_6 = 0; __Pyx_INCREF(__pyx_kp_u_at_0x); __pyx_t_2 += 6; __Pyx_GIVEREF(__pyx_kp_u_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_at_0x); __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_6, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1061, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1060 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pywrapfst._MutableFstSymbolTableView.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1063 * return f"" * * cdef SymbolTable_ptr _mutable_raw(self): # <<<<<<<<<<<<<< * return (self._mfst.get().MutableInputSymbols() if self._input_side else * self._mfst.get().MutableOutputSymbols()) */ static __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_26_MutableFstSymbolTableView__mutable_raw(struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *__pyx_v_self) { __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations fst::SymbolTable *__pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_mutable_raw", 0); /* "pywrapfst.pyx":1064 * * cdef SymbolTable_ptr _mutable_raw(self): * return (self._mfst.get().MutableInputSymbols() if self._input_side else # <<<<<<<<<<<<<< * self._mfst.get().MutableOutputSymbols()) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_input_side"); __PYX_ERR(0, 1064, __pyx_L1_error) } if ((__pyx_v_self->_input_side != 0)) { if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 1064, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_mfst.get()->MutableInputSymbols(); } else { /* "pywrapfst.pyx":1065 * cdef SymbolTable_ptr _mutable_raw(self): * return (self._mfst.get().MutableInputSymbols() if self._input_side else * self._mfst.get().MutableOutputSymbols()) # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 1065, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_mfst.get()->MutableOutputSymbols(); } __pyx_r = __pyx_t_1; goto __pyx_L0; /* "pywrapfst.pyx":1063 * return f"" * * cdef SymbolTable_ptr _mutable_raw(self): # <<<<<<<<<<<<<< * return (self._mfst.get().MutableInputSymbols() if self._input_side else * self._mfst.get().MutableOutputSymbols()) */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst._MutableFstSymbolTableView._mutable_raw", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1085 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; std::string __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":1086 * * def __repr__(self): * return f"" # <<<<<<<<<<<<<< * * def __init__(self, name=""): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_SymbolTable); __pyx_t_2 += 13; __Pyx_GIVEREF(__pyx_kp_u_SymbolTable); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_SymbolTable); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "name"); __PYX_ERR(0, 1086, __pyx_L1_error) } __pyx_t_4 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTable *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.name(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_self), 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1086, __pyx_L1_error) __pyx_t_5 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_5), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); __pyx_t_6 = 0; __Pyx_INCREF(__pyx_kp_u_at_0x); __pyx_t_2 += 6; __Pyx_GIVEREF(__pyx_kp_u_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_at_0x); __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_6, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1086, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1085 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __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":1088 * return f"" * * def __init__(self, name=""): # <<<<<<<<<<<<<< * self._smart_table.reset(new fst.SymbolTable(tostring(name))) * */ /* 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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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_u_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 = __Pyx_PyDict_GetItemStr(__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, 1088, __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, 1088, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":1089 * * def __init__(self, name=""): * self._smart_table.reset(new fst.SymbolTable(tostring(name))) # <<<<<<<<<<<<<< * * cdef SymbolTable_ptr _mutable_raw(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_smart_table"); __PYX_ERR(0, 1089, __pyx_L1_error) } __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1089, __pyx_L1_error) __pyx_v_self->_smart_table.reset(new fst::SymbolTable(__pyx_t_1)); /* "pywrapfst.pyx":1088 * return f"" * * def __init__(self, name=""): # <<<<<<<<<<<<<< * self._smart_table.reset(new fst.SymbolTable(tostring(name))) * */ /* 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":1091 * self._smart_table.reset(new fst.SymbolTable(tostring(name))) * * cdef SymbolTable_ptr _mutable_raw(self): # <<<<<<<<<<<<<< * return self._smart_table.get() * */ static __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_f_9pywrapfst_11SymbolTable__mutable_raw(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self) { __pyx_t_9pywrapfst_SymbolTable_ptr __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_mutable_raw", 0); /* "pywrapfst.pyx":1092 * * cdef SymbolTable_ptr _mutable_raw(self): * return self._smart_table.get() # <<<<<<<<<<<<<< * * @classmethod */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_smart_table"); __PYX_ERR(0, 1092, __pyx_L1_error) } __pyx_r = __pyx_v_self->_smart_table.get(); goto __pyx_L0; /* "pywrapfst.pyx":1091 * self._smart_table.reset(new fst.SymbolTable(tostring(name))) * * cdef SymbolTable_ptr _mutable_raw(self): # <<<<<<<<<<<<<< * return self._smart_table.get() * */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst.SymbolTable._mutable_raw", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1095 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * SymbolTable.read(source) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_5read(PyObject *__pyx_v_cls, PyObject *__pyx_v_source); /*proto*/ static char __pyx_doc_9pywrapfst_11SymbolTable_4read[] = "\n SymbolTable.read(source)\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 source: The string location of the input binary file.\n\n Returns:\n A new SymbolTable instance.\n "; static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_5read(PyObject *__pyx_v_cls, PyObject *__pyx_v_source) { 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_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_4read(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_source) { std::unique_ptr __pyx_v__symbols; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read", 0); /* "pywrapfst.pyx":1110 * """ * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.Read(path_tostring(source))) # <<<<<<<<<<<<<< * if _symbols.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") */ __pyx_t_1 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1110, __pyx_L1_error) __pyx_v__symbols.reset(fst::SymbolTable::Read(__pyx_t_1)); /* "pywrapfst.pyx":1111 * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.Read(path_tostring(source))) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_SymbolTable(move(_symbols)) */ __pyx_t_2 = ((__pyx_v__symbols.get() == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":1112 * _symbols.reset(fst.SymbolTable.Read(path_tostring(source))) * if _symbols.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") # <<<<<<<<<<<<<< * return _init_SymbolTable(move(_symbols)) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Read_failed, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1112, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 1112, __pyx_L1_error) /* "pywrapfst.pyx":1111 * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.Read(path_tostring(source))) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_SymbolTable(move(_symbols)) */ } /* "pywrapfst.pyx":1113 * if _symbols.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") * return _init_SymbolTable(move(_symbols)) # <<<<<<<<<<<<<< * * @classmethod */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::move >(__pyx_v__symbols))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1113, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1095 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * SymbolTable.read(source) */ /* 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_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":1116 * * @classmethod * def read_text(cls, source, bool allow_negative_labels=False): # <<<<<<<<<<<<<< * """ * SymbolTable.read_text(source) */ /* 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(source)\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 source: 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 "; static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_7read_text(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_source = 0; bool __pyx_v_allow_negative_labels; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read_text (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source,&__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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_source)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 1116, __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_source = 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, 1116, __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, 1116, __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_source, __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_source, bool __pyx_v_allow_negative_labels) { std::unique_ptr __pyx_v__opts; std::unique_ptr __pyx_v__symbols; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read_text", 0); /* "pywrapfst.pyx":1133 * """ * cdef unique_ptr[fst.SymbolTableTextOptions] _opts * _opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.ReadText(path_tostring(source), */ __pyx_v__opts.reset(new fst::SymbolTableTextOptions(__pyx_v_allow_negative_labels)); /* "pywrapfst.pyx":1135 * _opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.ReadText(path_tostring(source), # <<<<<<<<<<<<<< * deref(_opts))) * if _symbols.get() == NULL: */ __pyx_t_1 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1135, __pyx_L1_error) /* "pywrapfst.pyx":1136 * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.ReadText(path_tostring(source), * deref(_opts))) # <<<<<<<<<<<<<< * if _symbols.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") */ __pyx_v__symbols.reset(fst::SymbolTable::ReadText(__pyx_t_1, (*__pyx_v__opts))); /* "pywrapfst.pyx":1137 * _symbols.reset(fst.SymbolTable.ReadText(path_tostring(source), * deref(_opts))) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_SymbolTable(move(_symbols)) */ __pyx_t_2 = ((__pyx_v__symbols.get() == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":1138 * deref(_opts))) * if _symbols.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") # <<<<<<<<<<<<<< * return _init_SymbolTable(move(_symbols)) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Read_failed, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1138, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1138, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 1138, __pyx_L1_error) /* "pywrapfst.pyx":1137 * _symbols.reset(fst.SymbolTable.ReadText(path_tostring(source), * deref(_opts))) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_SymbolTable(move(_symbols)) */ } /* "pywrapfst.pyx":1139 * if _symbols.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") * return _init_SymbolTable(move(_symbols)) # <<<<<<<<<<<<<< * * @classmethod */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::move >(__pyx_v__symbols))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1116 * * @classmethod * def read_text(cls, source, bool allow_negative_labels=False): # <<<<<<<<<<<<<< * """ * SymbolTable.read_text(source) */ /* 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_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":1142 * * @classmethod * def read_fst(cls, source, bool input_table): # <<<<<<<<<<<<<< * """ * SymbolTable.read_fst(source, 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(source, 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 source: 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 "; static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_9read_fst(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_source = 0; bool __pyx_v_input_table; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read_fst (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source,&__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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_source)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_input_table)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("read_fst", 1, 2, 2, 1); __PYX_ERR(0, 1142, __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, 1142, __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_source = values[0]; __pyx_v_input_table = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_input_table == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1142, __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, 1142, __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_source, __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_source, bool __pyx_v_input_table) { std::unique_ptr __pyx_v__symbols; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read_fst", 0); /* "pywrapfst.pyx":1163 * """ * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.FstReadSymbols(path_tostring(source), input_table)) # <<<<<<<<<<<<<< * if _symbols.get() == NULL: * raise FstIOError(f"Read from FST failed: {source!r}") */ __pyx_t_1 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1163, __pyx_L1_error) __pyx_v__symbols.reset(fst::FstReadSymbols(__pyx_t_1, __pyx_v_input_table)); /* "pywrapfst.pyx":1164 * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.FstReadSymbols(path_tostring(source), input_table)) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read from FST failed: {source!r}") * return _init_SymbolTable(move(_symbols)) */ __pyx_t_2 = ((__pyx_v__symbols.get() == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":1165 * _symbols.reset(fst.FstReadSymbols(path_tostring(source), input_table)) * if _symbols.get() == NULL: * raise FstIOError(f"Read from FST failed: {source!r}") # <<<<<<<<<<<<<< * return _init_SymbolTable(move(_symbols)) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Read_from_FST_failed, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1165, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 1165, __pyx_L1_error) /* "pywrapfst.pyx":1164 * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.FstReadSymbols(path_tostring(source), input_table)) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read from FST failed: {source!r}") * return _init_SymbolTable(move(_symbols)) */ } /* "pywrapfst.pyx":1166 * if _symbols.get() == NULL: * raise FstIOError(f"Read from FST failed: {source!r}") * return _init_SymbolTable(move(_symbols)) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::move >(__pyx_v__symbols))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1142 * * @classmethod * def read_fst(cls, source, bool input_table): # <<<<<<<<<<<<<< * """ * SymbolTable.read_fst(source, 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_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; } /* "pywrapfst.pyx":1169 * * * cdef _EncodeMapperSymbolTableView _init_EncodeMapperSymbolTableView( # <<<<<<<<<<<<<< * shared_ptr[fst.EncodeMapperClass] mapper, bool input_side): * cdef _EncodeMapperSymbolTableView _symbols = ( */ static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_f_9pywrapfst__init_EncodeMapperSymbolTableView(std::shared_ptr __pyx_v_mapper, bool __pyx_v_input_side) { struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_v__symbols = 0; struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_EncodeMapperSymbolTableView", 0); /* "pywrapfst.pyx":1172 * shared_ptr[fst.EncodeMapperClass] mapper, bool input_side): * cdef _EncodeMapperSymbolTableView _symbols = ( * _EncodeMapperSymbolTableView.__new__(_EncodeMapperSymbolTableView)) # <<<<<<<<<<<<<< * _symbols._mapper = move(mapper) * _symbols._input_side = input_side */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst__EncodeMapperSymbolTableView(((PyTypeObject *)__pyx_ptype_9pywrapfst__EncodeMapperSymbolTableView), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1172, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__symbols = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1173 * cdef _EncodeMapperSymbolTableView _symbols = ( * _EncodeMapperSymbolTableView.__new__(_EncodeMapperSymbolTableView)) * _symbols._mapper = move(mapper) # <<<<<<<<<<<<<< * _symbols._input_side = input_side * return _symbols */ if (unlikely(((PyObject *)__pyx_v__symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1173, __pyx_L1_error) } __pyx_v__symbols->_mapper = fst::move >(__pyx_v_mapper); /* "pywrapfst.pyx":1174 * _EncodeMapperSymbolTableView.__new__(_EncodeMapperSymbolTableView)) * _symbols._mapper = move(mapper) * _symbols._input_side = input_side # <<<<<<<<<<<<<< * return _symbols * */ if (unlikely(((PyObject *)__pyx_v__symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_input_side"); __PYX_ERR(0, 1174, __pyx_L1_error) } __pyx_v__symbols->_input_side = __pyx_v_input_side; /* "pywrapfst.pyx":1175 * _symbols._mapper = move(mapper) * _symbols._input_side = input_side * return _symbols # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__symbols)); __pyx_r = __pyx_v__symbols; goto __pyx_L0; /* "pywrapfst.pyx":1169 * * * cdef _EncodeMapperSymbolTableView _init_EncodeMapperSymbolTableView( # <<<<<<<<<<<<<< * shared_ptr[fst.EncodeMapperClass] mapper, bool input_side): * cdef _EncodeMapperSymbolTableView _symbols = ( */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pywrapfst._init_EncodeMapperSymbolTableView", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v__symbols); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1178 * * * cdef _FstSymbolTableView _init_FstSymbolTableView(shared_ptr[fst.FstClass] ifst, # <<<<<<<<<<<<<< * bool input_side): * cdef _FstSymbolTableView _symbols = ( */ static struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_f_9pywrapfst__init_FstSymbolTableView(std::shared_ptr __pyx_v_ifst, bool __pyx_v_input_side) { struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_v__symbols = 0; struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_FstSymbolTableView", 0); /* "pywrapfst.pyx":1181 * bool input_side): * cdef _FstSymbolTableView _symbols = ( * _FstSymbolTableView.__new__(_FstSymbolTableView)) # <<<<<<<<<<<<<< * _symbols._fst = move(ifst) * _symbols._input_side = input_side */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst__FstSymbolTableView(((PyTypeObject *)__pyx_ptype_9pywrapfst__FstSymbolTableView), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1181, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__symbols = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1182 * cdef _FstSymbolTableView _symbols = ( * _FstSymbolTableView.__new__(_FstSymbolTableView)) * _symbols._fst = move(ifst) # <<<<<<<<<<<<<< * _symbols._input_side = input_side * return _symbols */ if (unlikely(((PyObject *)__pyx_v__symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1182, __pyx_L1_error) } __pyx_v__symbols->_fst = fst::move >(__pyx_v_ifst); /* "pywrapfst.pyx":1183 * _FstSymbolTableView.__new__(_FstSymbolTableView)) * _symbols._fst = move(ifst) * _symbols._input_side = input_side # <<<<<<<<<<<<<< * return _symbols * */ if (unlikely(((PyObject *)__pyx_v__symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_input_side"); __PYX_ERR(0, 1183, __pyx_L1_error) } __pyx_v__symbols->_input_side = __pyx_v_input_side; /* "pywrapfst.pyx":1184 * _symbols._fst = move(ifst) * _symbols._input_side = input_side * return _symbols # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__symbols)); __pyx_r = __pyx_v__symbols; goto __pyx_L0; /* "pywrapfst.pyx":1178 * * * cdef _FstSymbolTableView _init_FstSymbolTableView(shared_ptr[fst.FstClass] ifst, # <<<<<<<<<<<<<< * bool input_side): * cdef _FstSymbolTableView _symbols = ( */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pywrapfst._init_FstSymbolTableView", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v__symbols); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1187 * * * cdef _MutableFstSymbolTableView _init_MutableFstSymbolTableView( # <<<<<<<<<<<<<< * shared_ptr[fst.MutableFstClass] ifst, * bool input_side): */ static struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *__pyx_f_9pywrapfst__init_MutableFstSymbolTableView(std::shared_ptr __pyx_v_ifst, bool __pyx_v_input_side) { struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *__pyx_v__symbols = 0; struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_MutableFstSymbolTableView", 0); /* "pywrapfst.pyx":1191 * bool input_side): * cdef _MutableFstSymbolTableView _symbols = ( * _MutableFstSymbolTableView.__new__(_MutableFstSymbolTableView)) # <<<<<<<<<<<<<< * _symbols._mfst = move(ifst) * _symbols._input_side = input_side */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst__MutableFstSymbolTableView(((PyTypeObject *)__pyx_ptype_9pywrapfst__MutableFstSymbolTableView), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1191, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__symbols = ((struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1192 * cdef _MutableFstSymbolTableView _symbols = ( * _MutableFstSymbolTableView.__new__(_MutableFstSymbolTableView)) * _symbols._mfst = move(ifst) # <<<<<<<<<<<<<< * _symbols._input_side = input_side * return _symbols */ if (unlikely(((PyObject *)__pyx_v__symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 1192, __pyx_L1_error) } __pyx_v__symbols->_mfst = fst::move >(__pyx_v_ifst); /* "pywrapfst.pyx":1193 * _MutableFstSymbolTableView.__new__(_MutableFstSymbolTableView)) * _symbols._mfst = move(ifst) * _symbols._input_side = input_side # <<<<<<<<<<<<<< * return _symbols * */ if (unlikely(((PyObject *)__pyx_v__symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_input_side"); __PYX_ERR(0, 1193, __pyx_L1_error) } __pyx_v__symbols->_input_side = __pyx_v_input_side; /* "pywrapfst.pyx":1194 * _symbols._mfst = move(ifst) * _symbols._input_side = input_side * return _symbols # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__symbols)); __pyx_r = __pyx_v__symbols; goto __pyx_L0; /* "pywrapfst.pyx":1187 * * * cdef _MutableFstSymbolTableView _init_MutableFstSymbolTableView( # <<<<<<<<<<<<<< * shared_ptr[fst.MutableFstClass] ifst, * bool input_side): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pywrapfst._init_MutableFstSymbolTableView", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v__symbols); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1197 * * * cdef SymbolTable _init_SymbolTable(unique_ptr[fst.SymbolTable] symbols): # <<<<<<<<<<<<<< * cdef SymbolTable _symbols = SymbolTable.__new__(SymbolTable) * _symbols._smart_table = move(symbols) */ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__init_SymbolTable(std::unique_ptr __pyx_v_symbols) { struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v__symbols = 0; struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_SymbolTable", 0); /* "pywrapfst.pyx":1198 * * cdef SymbolTable _init_SymbolTable(unique_ptr[fst.SymbolTable] symbols): * cdef SymbolTable _symbols = SymbolTable.__new__(SymbolTable) # <<<<<<<<<<<<<< * _symbols._smart_table = move(symbols) * return _symbols */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_SymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst_SymbolTable), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1198, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__symbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1199 * cdef SymbolTable _init_SymbolTable(unique_ptr[fst.SymbolTable] symbols): * cdef SymbolTable _symbols = SymbolTable.__new__(SymbolTable) * _symbols._smart_table = move(symbols) # <<<<<<<<<<<<<< * return _symbols * */ if (unlikely(((PyObject *)__pyx_v__symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_smart_table"); __PYX_ERR(0, 1199, __pyx_L1_error) } __pyx_v__symbols->_smart_table = fst::move >(__pyx_v_symbols); /* "pywrapfst.pyx":1200 * cdef SymbolTable _symbols = SymbolTable.__new__(SymbolTable) * _symbols._smart_table = move(symbols) * return _symbols # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v__symbols)); __pyx_r = __pyx_v__symbols; goto __pyx_L0; /* "pywrapfst.pyx":1197 * * * cdef SymbolTable _init_SymbolTable(unique_ptr[fst.SymbolTable] symbols): # <<<<<<<<<<<<<< * cdef SymbolTable _symbols = SymbolTable.__new__(SymbolTable) * _symbols._smart_table = move(symbols) */ /* 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__symbols); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1203 * * * cpdef SymbolTable _read_SymbolTable_from_string(string state): # <<<<<<<<<<<<<< * cdef stringstream _sstrm * _sstrm << state */ static PyObject *__pyx_pw_9pywrapfst_9_read_SymbolTable_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state); /*proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__read_SymbolTable_from_string(std::string __pyx_v_state, CYTHON_UNUSED int __pyx_skip_dispatch) { std::stringstream __pyx_v__sstrm; std::unique_ptr __pyx_v__symbols; struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_SymbolTable_from_string", 0); /* "pywrapfst.pyx":1205 * cpdef SymbolTable _read_SymbolTable_from_string(string state): * cdef stringstream _sstrm * _sstrm << state # <<<<<<<<<<<<<< * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.ReadStream(_sstrm, b"")) */ (void)((__pyx_v__sstrm << __pyx_v_state)); /* "pywrapfst.pyx":1207 * _sstrm << state * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.ReadStream(_sstrm, b"")) # <<<<<<<<<<<<<< * if _symbols.get() == NULL: * raise FstIOError("Read from string failed") */ __pyx_v__symbols.reset(fst::SymbolTable::Read(__pyx_v__sstrm, __pyx_k_pywrapfst)); /* "pywrapfst.pyx":1208 * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.ReadStream(_sstrm, b"")) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError("Read from string failed") * return _init_SymbolTable(move(_symbols)) */ __pyx_t_1 = ((__pyx_v__symbols.get() == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":1209 * _symbols.reset(fst.SymbolTable.ReadStream(_sstrm, b"")) * if _symbols.get() == NULL: * raise FstIOError("Read from string failed") # <<<<<<<<<<<<<< * return _init_SymbolTable(move(_symbols)) * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Read_from_string_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Read_from_string_failed); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1209, __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, 1209, __pyx_L1_error) /* "pywrapfst.pyx":1208 * cdef unique_ptr[fst.SymbolTable] _symbols * _symbols.reset(fst.SymbolTable.ReadStream(_sstrm, b"")) * if _symbols.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError("Read from string failed") * return _init_SymbolTable(move(_symbols)) */ } /* "pywrapfst.pyx":1210 * if _symbols.get() == NULL: * raise FstIOError("Read from string failed") * return _init_SymbolTable(move(_symbols)) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::move >(__pyx_v__symbols))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1203 * * * cpdef SymbolTable _read_SymbolTable_from_string(string state): # <<<<<<<<<<<<<< * cdef stringstream _sstrm * _sstrm << state */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst._read_SymbolTable_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_9_read_SymbolTable_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_9_read_SymbolTable_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state) { std::string __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_read_SymbolTable_from_string (wrapper)", 0); assert(__pyx_arg_state); { __pyx_v_state = __pyx_convert_string_from_py_std__in_string(__pyx_arg_state); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1203, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst._read_SymbolTable_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_9pywrapfst_8_read_SymbolTable_from_string(__pyx_self, ((std::string)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_8_read_SymbolTable_from_string(CYTHON_UNUSED PyObject *__pyx_self, std::string __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_SymbolTable_from_string", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read_SymbolTable_from_string(__pyx_v_state, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1203, __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_SymbolTable_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1216 * * * cpdef SymbolTable compact_symbol_table(SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * compact_symbol_table(symbols) */ static PyObject *__pyx_pw_9pywrapfst_11compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_symbols); /*proto*/ static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_compact_symbol_table(struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols, CYTHON_UNUSED int __pyx_skip_dispatch) { struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; __Pyx_RefNannyDeclarations fst::SymbolTable const *__pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("compact_symbol_table", 0); /* "pywrapfst.pyx":1228 * A new compacted SymbolTable. * """ * return _init_SymbolTable(WrapUnique(fst.CompactSymbolTable( # <<<<<<<<<<<<<< * deref(symbols._raw_ptr_or_raise())))) * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); /* "pywrapfst.pyx":1229 * """ * return _init_SymbolTable(WrapUnique(fst.CompactSymbolTable( * deref(symbols._raw_ptr_or_raise())))) # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1229, __pyx_L1_error) } __pyx_t_1 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_symbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1229, __pyx_L1_error) /* "pywrapfst.pyx":1228 * A new compacted SymbolTable. * """ * return _init_SymbolTable(WrapUnique(fst.CompactSymbolTable( # <<<<<<<<<<<<<< * deref(symbols._raw_ptr_or_raise())))) * */ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::WrapUnique(fst::CompactSymbolTable((*__pyx_t_1))))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1216 * * * cpdef SymbolTable compact_symbol_table(SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * compact_symbol_table(symbols) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __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_11compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_symbols); /*proto*/ static char __pyx_doc_9pywrapfst_10compact_symbol_table[] = "\n compact_symbol_table(symbols)\n\n Constructively relabels a SymbolTable to make it a contiguous mapping.\n\n Args:\n symbols: Input SymbolTable.\n\n Returns:\n A new compacted SymbolTable.\n "; static PyObject *__pyx_pw_9pywrapfst_11compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_symbols) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("compact_symbol_table (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_symbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "symbols", 0))) __PYX_ERR(0, 1216, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10compact_symbol_table(__pyx_self, ((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_symbols)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10compact_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("compact_symbol_table", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_compact_symbol_table(__pyx_v_symbols, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1216, __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":1232 * * * cpdef SymbolTable merge_symbol_table(SymbolTableView lhs, # <<<<<<<<<<<<<< * SymbolTableView rhs): * """ */ static PyObject *__pyx_pw_9pywrapfst_13merge_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_SymbolTableView *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_rhs, CYTHON_UNUSED int __pyx_skip_dispatch) { struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL; __Pyx_RefNannyDeclarations fst::SymbolTable const *__pyx_t_1; fst::SymbolTable const *__pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("merge_symbol_table", 0); /* "pywrapfst.pyx":1255 * A new merged SymbolTable. * """ * return _init_SymbolTable(WrapUnique(fst.MergeSymbolTable( # <<<<<<<<<<<<<< * deref(lhs._raw_ptr_or_raise()), * deref(rhs._raw_ptr_or_raise()), */ __Pyx_XDECREF(((PyObject *)__pyx_r)); /* "pywrapfst.pyx":1256 * """ * return _init_SymbolTable(WrapUnique(fst.MergeSymbolTable( * deref(lhs._raw_ptr_or_raise()), # <<<<<<<<<<<<<< * deref(rhs._raw_ptr_or_raise()), * NULL))) */ if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1256, __pyx_L1_error) } __pyx_t_1 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_lhs->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_lhs); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1256, __pyx_L1_error) /* "pywrapfst.pyx":1257 * return _init_SymbolTable(WrapUnique(fst.MergeSymbolTable( * deref(lhs._raw_ptr_or_raise()), * deref(rhs._raw_ptr_or_raise()), # <<<<<<<<<<<<<< * NULL))) * */ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1257, __pyx_L1_error) } __pyx_t_2 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_rhs->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_rhs); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1257, __pyx_L1_error) /* "pywrapfst.pyx":1255 * A new merged SymbolTable. * """ * return _init_SymbolTable(WrapUnique(fst.MergeSymbolTable( # <<<<<<<<<<<<<< * deref(lhs._raw_ptr_or_raise()), * deref(rhs._raw_ptr_or_raise()), */ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::WrapUnique(fst::MergeSymbolTable((*__pyx_t_1), (*__pyx_t_2), NULL)))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1232 * * * cpdef SymbolTable merge_symbol_table(SymbolTableView lhs, # <<<<<<<<<<<<<< * SymbolTableView rhs): * """ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __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_13merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_12merge_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 "; static PyObject *__pyx_pw_9pywrapfst_13merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_lhs = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_rhs = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("merge_symbol_table", 1, 2, 2, 1); __PYX_ERR(0, 1232, __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, 1232, __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_SymbolTableView *)values[0]); __pyx_v_rhs = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)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, 1232, __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_SymbolTableView, 1, "lhs", 0))) __PYX_ERR(0, 1232, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "rhs", 0))) __PYX_ERR(0, 1233, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_12merge_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_12merge_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_rhs) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 1232, __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":1271 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<_SymbolTableIterator at 0x{id(self):x}>" * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_1__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_20_SymbolTableIterator___repr__(((struct __pyx_obj_9pywrapfst__SymbolTableIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_20_SymbolTableIterator___repr__(struct __pyx_obj_9pywrapfst__SymbolTableIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":1272 * * def __repr__(self): * return f"<_SymbolTableIterator at 0x{id(self):x}>" # <<<<<<<<<<<<<< * * def __init__(self, SymbolTableView symbols): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_SymbolTableIterator_at_0x); __pyx_t_2 += 27; __Pyx_GIVEREF(__pyx_kp_u_SymbolTableIterator_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_SymbolTableIterator_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1271 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<_SymbolTableIterator at 0x{id(self):x}>" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":1274 * return f"<_SymbolTableIterator at 0x{id(self):x}>" * * def __init__(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * self._table = symbols * self._siter.reset( */ /* Python wrapper */ static int __pyx_pw_9pywrapfst_20_SymbolTableIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_9pywrapfst_20_SymbolTableIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_symbols,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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_symbols)) != 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, 1274, __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_symbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)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, 1274, __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_symbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "symbols", 0))) __PYX_ERR(0, 1274, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_20_SymbolTableIterator_2__init__(((struct __pyx_obj_9pywrapfst__SymbolTableIterator *)__pyx_v_self), __pyx_v_symbols); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_9pywrapfst_20_SymbolTableIterator_2__init__(struct __pyx_obj_9pywrapfst__SymbolTableIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { int __pyx_r; __Pyx_RefNannyDeclarations fst::SymbolTable const *__pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":1275 * * def __init__(self, SymbolTableView symbols): * self._table = symbols # <<<<<<<<<<<<<< * self._siter.reset( * new fst.SymbolTableIterator(self._table._raw_ptr_or_raise().begin())) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); __PYX_ERR(0, 1275, __pyx_L1_error) } __Pyx_INCREF(((PyObject *)__pyx_v_symbols)); __Pyx_GIVEREF(((PyObject *)__pyx_v_symbols)); __Pyx_GOTREF(__pyx_v_self->_table); __Pyx_DECREF(((PyObject *)__pyx_v_self->_table)); __pyx_v_self->_table = __pyx_v_symbols; /* "pywrapfst.pyx":1276 * def __init__(self, SymbolTableView symbols): * self._table = symbols * self._siter.reset( # <<<<<<<<<<<<<< * new fst.SymbolTableIterator(self._table._raw_ptr_or_raise().begin())) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); __PYX_ERR(0, 1276, __pyx_L1_error) } /* "pywrapfst.pyx":1277 * self._table = symbols * self._siter.reset( * new fst.SymbolTableIterator(self._table._raw_ptr_or_raise().begin())) # <<<<<<<<<<<<<< * * # 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'", "_table"); __PYX_ERR(0, 1277, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_self->_table) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1277, __pyx_L1_error) } __pyx_t_1 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->_table->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self->_table); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1277, __pyx_L1_error) /* "pywrapfst.pyx":1276 * def __init__(self, SymbolTableView symbols): * self._table = symbols * self._siter.reset( # <<<<<<<<<<<<<< * new fst.SymbolTableIterator(self._table._raw_ptr_or_raise().begin())) * */ __pyx_v_self->_siter.reset(new fst::SymbolTable::iterator(__pyx_t_1->begin())); /* "pywrapfst.pyx":1274 * return f"<_SymbolTableIterator at 0x{id(self):x}>" * * def __init__(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * self._table = symbols * self._siter.reset( */ /* 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":1280 * * # This just registers this class as a possible iterator. * def __iter__(self): # <<<<<<<<<<<<<< * return self * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_5__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_5__iter__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_20_SymbolTableIterator_4__iter__(((struct __pyx_obj_9pywrapfst__SymbolTableIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_20_SymbolTableIterator_4__iter__(struct __pyx_obj_9pywrapfst__SymbolTableIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__", 0); /* "pywrapfst.pyx":1281 * # 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":1280 * * # 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":1284 * * # Magic method used to get a Pythonic API out of the C++ API. * def __next__(self): # <<<<<<<<<<<<<< * if self._table._raw_ptr_or_raise().end() == deref(self._siter): * raise StopIteration */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_7__next__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_7__next__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_20_SymbolTableIterator_6__next__(((struct __pyx_obj_9pywrapfst__SymbolTableIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_20_SymbolTableIterator_6__next__(struct __pyx_obj_9pywrapfst__SymbolTableIterator *__pyx_v_self) { int64 __pyx_v__label; std::string __pyx_v__symbol; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations fst::SymbolTable const *__pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__next__", 0); /* "pywrapfst.pyx":1285 * # Magic method used to get a Pythonic API out of the C++ API. * def __next__(self): * if self._table._raw_ptr_or_raise().end() == deref(self._siter): # <<<<<<<<<<<<<< * raise StopIteration * cdef int64 _label = self._siter.get().Pair().Label() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_table"); __PYX_ERR(0, 1285, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_self->_table) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1285, __pyx_L1_error) } __pyx_t_1 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_self->_table->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_self->_table); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1285, __pyx_L1_error) if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); __PYX_ERR(0, 1285, __pyx_L1_error) } __pyx_t_2 = ((__pyx_t_1->end() == (*__pyx_v_self->_siter)) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":1286 * def __next__(self): * if self._table._raw_ptr_or_raise().end() == deref(self._siter): * raise StopIteration # <<<<<<<<<<<<<< * cdef int64 _label = self._siter.get().Pair().Label() * cdef string _symbol = self._siter.get().Pair().Symbol() */ __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); __PYX_ERR(0, 1286, __pyx_L1_error) /* "pywrapfst.pyx":1285 * # Magic method used to get a Pythonic API out of the C++ API. * def __next__(self): * if self._table._raw_ptr_or_raise().end() == deref(self._siter): # <<<<<<<<<<<<<< * raise StopIteration * cdef int64 _label = self._siter.get().Pair().Label() */ } /* "pywrapfst.pyx":1287 * if self._table._raw_ptr_or_raise().end() == deref(self._siter): * raise StopIteration * cdef int64 _label = self._siter.get().Pair().Label() # <<<<<<<<<<<<<< * cdef string _symbol = self._siter.get().Pair().Symbol() * inc(deref(self._siter)) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); __PYX_ERR(0, 1287, __pyx_L1_error) } __pyx_v__label = __pyx_v_self->_siter.get()->operator*().Label(); /* "pywrapfst.pyx":1288 * raise StopIteration * cdef int64 _label = self._siter.get().Pair().Label() * cdef string _symbol = self._siter.get().Pair().Symbol() # <<<<<<<<<<<<<< * inc(deref(self._siter)) * return (_label, _symbol) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); __PYX_ERR(0, 1288, __pyx_L1_error) } __pyx_v__symbol = __pyx_v_self->_siter.get()->operator*().Symbol(); /* "pywrapfst.pyx":1289 * cdef int64 _label = self._siter.get().Pair().Label() * cdef string _symbol = self._siter.get().Pair().Symbol() * inc(deref(self._siter)) # <<<<<<<<<<<<<< * return (_label, _symbol) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_siter"); __PYX_ERR(0, 1289, __pyx_L1_error) } (void)((++(*__pyx_v_self->_siter))); /* "pywrapfst.pyx":1290 * cdef string _symbol = self._siter.get().Pair().Symbol() * inc(deref(self._siter)) * return (_label, _symbol) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v__label); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v__symbol); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1290, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1284 * * # Magic method used to get a Pythonic API out of the C++ API. * def __next__(self): # <<<<<<<<<<<<<< * if self._table._raw_ptr_or_raise().end() == deref(self._siter): * raise StopIteration */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __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; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self._siter cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_9__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_20_SymbolTableIterator_8__reduce_cython__(((struct __pyx_obj_9pywrapfst__SymbolTableIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_20_SymbolTableIterator_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst__SymbolTableIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self._siter cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._siter 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._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._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 cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self._siter cannot be converted to a Python object for pickling") */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_20_SymbolTableIterator_11__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_20_SymbolTableIterator_10__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_20_SymbolTableIterator_10__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("self._siter cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._siter 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._siter cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("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._SymbolTableIterator.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1319 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":1320 * * def __repr__(self): * return f"" # <<<<<<<<<<<<<< * * def __init__(self, */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_EncodeMapper_at_0x); __pyx_t_2 += 19; __Pyx_GIVEREF(__pyx_kp_u_EncodeMapper_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_EncodeMapper_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1319 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":1322 * return f"" * * def __init__(self, # <<<<<<<<<<<<<< * arc_type="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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arc_type); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_encode_labels); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 1322, __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, 1324, __pyx_L3_error) } else { /* "pywrapfst.pyx":1324 * def __init__(self, * arc_type="standard", * bool encode_labels=False, # <<<<<<<<<<<<<< * bool encode_weights=False): * cdef uint8 _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, 1325, __pyx_L3_error) } else { /* "pywrapfst.pyx":1325 * arc_type="standard", * bool encode_labels=False, * bool encode_weights=False): # <<<<<<<<<<<<<< * cdef uint8 _flags = fst.GetEncodeFlags(encode_labels, encode_weights) * self._mapper.reset( */ __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, 1322, __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":1322 * return f"" * * def __init__(self, # <<<<<<<<<<<<<< * arc_type="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) { uint8 __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":1326 * bool encode_labels=False, * bool encode_weights=False): * cdef uint8 _flags = fst.GetEncodeFlags(encode_labels, encode_weights) # <<<<<<<<<<<<<< * self._mapper.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":1327 * bool encode_weights=False): * cdef uint8 _flags = fst.GetEncodeFlags(encode_labels, encode_weights) * self._mapper.reset( # <<<<<<<<<<<<<< * new fst.EncodeMapperClass(tostring(arc_type), _flags, fst.ENCODE)) * if self._mapper.get() == NULL: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1327, __pyx_L1_error) } /* "pywrapfst.pyx":1328 * cdef uint8 _flags = fst.GetEncodeFlags(encode_labels, encode_weights) * self._mapper.reset( * new fst.EncodeMapperClass(tostring(arc_type), _flags, fst.ENCODE)) # <<<<<<<<<<<<<< * if self._mapper.get() == NULL: * raise FstOpError(f"Unknown arc type: {arc_type!r}") */ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1328, __pyx_L1_error) /* "pywrapfst.pyx":1327 * bool encode_weights=False): * cdef uint8 _flags = fst.GetEncodeFlags(encode_labels, encode_weights) * self._mapper.reset( # <<<<<<<<<<<<<< * new fst.EncodeMapperClass(tostring(arc_type), _flags, fst.ENCODE)) * if self._mapper.get() == NULL: */ __pyx_v_self->_mapper.reset(new fst::script::EncodeMapperClass(__pyx_t_1, __pyx_v__flags, fst::ENCODE)); /* "pywrapfst.pyx":1329 * self._mapper.reset( * new fst.EncodeMapperClass(tostring(arc_type), _flags, fst.ENCODE)) * if self._mapper.get() == NULL: # <<<<<<<<<<<<<< * raise FstOpError(f"Unknown arc type: {arc_type!r}") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1329, __pyx_L1_error) } __pyx_t_2 = ((__pyx_v_self->_mapper.get() == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":1330 * new fst.EncodeMapperClass(tostring(arc_type), _flags, fst.ENCODE)) * if self._mapper.get() == NULL: * raise FstOpError(f"Unknown arc type: {arc_type!r}") # <<<<<<<<<<<<<< * * # Python's equivalent to operator(). */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_arc_type), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_arc_type, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1330, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 1330, __pyx_L1_error) /* "pywrapfst.pyx":1329 * self._mapper.reset( * new fst.EncodeMapperClass(tostring(arc_type), _flags, fst.ENCODE)) * if self._mapper.get() == NULL: # <<<<<<<<<<<<<< * raise FstOpError(f"Unknown arc type: {arc_type!r}") * */ } /* "pywrapfst.pyx":1322 * return f"" * * def __init__(self, # <<<<<<<<<<<<<< * arc_type="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_AddTraceback("pywrapfst.EncodeMapper.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1334 * # Python's equivalent to operator(). * * def __call__(self, Arc arc): # <<<<<<<<<<<<<< * """ * self(state, ilabel, olabel, weight, nextstate) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_4__call__[] = "\n self(state, ilabel, olabel, weight, nextstate)\n\n Uses the mapper 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_4__call__; #endif static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__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, 1334, __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, 1334, __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, 1334, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_4__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_4__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 0); /* "pywrapfst.pyx":1350 * FstOpError: Incompatible or invalid weight. * """ * return _init_Arc(self._mapper.get().__call__(deref(arc._arc))) # <<<<<<<<<<<<<< * * # Registers the class for pickling. */ __Pyx_XDECREF(__pyx_r); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1350, __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, 1350, __pyx_L1_error) } __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_Arc(__pyx_v_self->_mapper.get()->operator()((*__pyx_v_arc->_arc)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1350, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1334 * # 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":1354 * # Registers the class for pickling. * * def __reduce__(self): # <<<<<<<<<<<<<< * return (_read_EncodeMapper_from_string, (self.write_to_string(),)) * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_7__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_7__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_12EncodeMapper_6__reduce__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_6__reduce__(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce__", 0); /* "pywrapfst.pyx":1355 * * def __reduce__(self): * return (_read_EncodeMapper_from_string, (self.write_to_string(),)) # <<<<<<<<<<<<<< * * cpdef string arc_type(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_read_EncodeMapper_from_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1355, __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, 1355, __pyx_L1_error) } __pyx_t_2 = ((struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *)__pyx_v_self->__pyx_vtab)->write_to_string(__pyx_v_self, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1355, __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, 1355, __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":1354 * # Registers the class for pickling. * * def __reduce__(self): # <<<<<<<<<<<<<< * return (_read_EncodeMapper_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.EncodeMapper.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1357 * return (_read_EncodeMapper_from_string, (self.write_to_string(),)) * * cpdef string arc_type(self): # <<<<<<<<<<<<<< * """ * arc_type(self) */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_9arc_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1357, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_12EncodeMapper_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1357, __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, 1357, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1363 * Returns a string indicating the arc type. * """ * return self._mapper.get().ArcType() # <<<<<<<<<<<<<< * * cpdef string weight_type(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1363, __pyx_L1_error) } __pyx_r = __pyx_v_self->_mapper.get()->ArcType(); goto __pyx_L0; /* "pywrapfst.pyx":1357 * return (_read_EncodeMapper_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.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_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_8arc_type[] = "\n arc_type(self)\n\n Returns a string indicating the arc type.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_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_12EncodeMapper_8arc_type(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_8arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("arc_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_12EncodeMapper_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1357, __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":1365 * return self._mapper.get().ArcType() * * cpdef string weight_type(self): # <<<<<<<<<<<<<< * """ * weight_type(self) */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11weight_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_12EncodeMapper_11weight_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1365, __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, 1365, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1371 * Returns a string indicating the weight type. * """ * return self._mapper.get().WeightType() # <<<<<<<<<<<<<< * * cpdef uint8 flags(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1371, __pyx_L1_error) } __pyx_r = __pyx_v_self->_mapper.get()->WeightType(); goto __pyx_L0; /* "pywrapfst.pyx":1365 * return self._mapper.get().ArcType() * * 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_11weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_10weight_type[] = "\n weight_type(self)\n\n Returns a string indicating the weight type.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11weight_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_10weight_type(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_10weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("weight_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_12EncodeMapper_weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1365, __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; } /* "pywrapfst.pyx":1373 * return self._mapper.get().WeightType() * * cpdef uint8 flags(self): # <<<<<<<<<<<<<< * """ * flags(self) */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static uint8 __pyx_f_9pywrapfst_12EncodeMapper_flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { uint8 __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; uint8 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_12EncodeMapper_13flags)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1373, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyInt_As_uint8_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1373, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1379 * Returns the mapper's flags. * """ * return self._mapper.get().Flags() # <<<<<<<<<<<<<< * * def properties(self, mask): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1379, __pyx_L1_error) } __pyx_r = __pyx_v_self->_mapper.get()->Flags(); goto __pyx_L0; /* "pywrapfst.pyx":1373 * return self._mapper.get().WeightType() * * cpdef uint8 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_13flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_12flags[] = "\n flags(self)\n\n Returns the mapper's flags.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13flags(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_12flags(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_12flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("flags", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_uint8_t(__pyx_f_9pywrapfst_12EncodeMapper_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1373, __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":1381 * return self._mapper.get().Flags() * * def properties(self, mask): # <<<<<<<<<<<<<< * """ * properties(self, mask) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_15properties(PyObject *__pyx_v_self, PyObject *__pyx_v_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 mapper.\n\n Args:\n mask: The property mask to be compared to the mapper'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_v_mask) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("properties (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_14properties(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((PyObject *)__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, PyObject *__pyx_v_mask) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; uint64 __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("properties", 0); /* "pywrapfst.pyx":1396 * """ * * return FstProperties(self._mapper.get().Properties(mask.value)) # <<<<<<<<<<<<<< * * @classmethod */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1396, __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'", "_mapper"); __PYX_ERR(0, 1396, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_mask, __pyx_n_s_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_As_uint64_t(__pyx_t_3); if (unlikely((__pyx_t_4 == ((uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1396, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_mapper.get()->Properties(__pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1381 * return self._mapper.get().Flags() * * def properties(self, 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_5); __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":1399 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * EncodeMapper.read(source) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17read(PyObject *__pyx_v_cls, PyObject *__pyx_v_source); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_16read[] = "\n EncodeMapper.read(source)\n\n Reads encode mapper from binary file.\n\n This class method creates a new EncodeMapper from an encode mapper binary\n file.\n\n Args:\n source: The string location of the input binary file.\n\n Returns:\n A new EncodeMapper instance.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17read(PyObject *__pyx_v_cls, PyObject *__pyx_v_source) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_16read(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_16read(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_source) { std::unique_ptr __pyx_v__mapper; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read", 0); /* "pywrapfst.pyx":1415 * """ * cdef unique_ptr[fst.EncodeMapperClass] _mapper * _mapper.reset(fst.EncodeMapperClass.Read(path_tostring(source))) # <<<<<<<<<<<<<< * if _mapper.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") */ __pyx_t_1 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1415, __pyx_L1_error) __pyx_v__mapper.reset(fst::script::EncodeMapperClass::Read(__pyx_t_1)); /* "pywrapfst.pyx":1416 * cdef unique_ptr[fst.EncodeMapperClass] _mapper * _mapper.reset(fst.EncodeMapperClass.Read(path_tostring(source))) * if _mapper.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_EncodeMapper(_mapper.release()) */ __pyx_t_2 = ((__pyx_v__mapper.get() == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":1417 * _mapper.reset(fst.EncodeMapperClass.Read(path_tostring(source))) * if _mapper.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") # <<<<<<<<<<<<<< * return _init_EncodeMapper(_mapper.release()) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Read_failed, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1417, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1417, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 1417, __pyx_L1_error) /* "pywrapfst.pyx":1416 * cdef unique_ptr[fst.EncodeMapperClass] _mapper * _mapper.reset(fst.EncodeMapperClass.Read(path_tostring(source))) * if _mapper.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_EncodeMapper(_mapper.release()) */ } /* "pywrapfst.pyx":1418 * if _mapper.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") * return _init_EncodeMapper(_mapper.release()) # <<<<<<<<<<<<<< * * @staticmethod */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapper(__pyx_v__mapper.release())); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1399 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * EncodeMapper.read(source) */ /* 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_AddTraceback("pywrapfst.EncodeMapper.read", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1421 * * @staticmethod * def read_from_string(state): # <<<<<<<<<<<<<< * """ * read_from_string(state) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_18read_from_string[] = "\n read_from_string(state)\n\n Reads an EncodeMapper from a serialized string.\n\n Args:\n state: A string containing the serialized EncodeMapper.\n\n Returns:\n An EncodeMapper object.\n\n Raises:\n FstIOError: Read failed.\n "; static PyMethodDef __pyx_mdef_9pywrapfst_12EncodeMapper_19read_from_string = {"read_from_string", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_12EncodeMapper_19read_from_string, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_12EncodeMapper_18read_from_string}; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read_from_string (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 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, "read_from_string") < 0)) __PYX_ERR(0, 1421, __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_state = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("read_from_string", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1421, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst.EncodeMapper.read_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_18read_from_string(__pyx_v_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_18read_from_string(PyObject *__pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read_from_string", 0); /* "pywrapfst.pyx":1436 * FstIOError: Read failed. * """ * return _read_EncodeMapper_from_string(state) # <<<<<<<<<<<<<< * * cpdef void write(self, source) except *: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_state); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1436, __pyx_L1_error) __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__read_EncodeMapper_from_string(__pyx_t_1, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1421 * * @staticmethod * def read_from_string(state): # <<<<<<<<<<<<<< * """ * read_from_string(state) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pywrapfst.EncodeMapper.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":1438 * return _read_EncodeMapper_from_string(state) * * cpdef void write(self, source) except *: # <<<<<<<<<<<<<< * """ * write(self, source) */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21write(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static void __pyx_f_9pywrapfst_12EncodeMapper_write(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, PyObject *__pyx_v_source, 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; std::string __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_12EncodeMapper_21write)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_source) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_source); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1438, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1451 * FstIOError: Write failed. * """ * if not self._mapper.get().Write(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1451, __pyx_L1_error) } __pyx_t_5 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1451, __pyx_L1_error) __pyx_t_6 = ((!(__pyx_v_self->_mapper.get()->Write(__pyx_t_5) != 0)) != 0); if (unlikely(__pyx_t_6)) { /* "pywrapfst.pyx":1452 * """ * if not self._mapper.get().Write(path_tostring(source)): * raise FstIOError(f"Write failed: {source!r}") # <<<<<<<<<<<<<< * * cpdef bytes write_to_string(self): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1452, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1452, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Write_failed, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1452, __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 && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1452, __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, 1452, __pyx_L1_error) /* "pywrapfst.pyx":1451 * FstIOError: Write failed. * """ * if not self._mapper.get().Write(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ } /* "pywrapfst.pyx":1438 * return _read_EncodeMapper_from_string(state) * * cpdef void write(self, source) except *: # <<<<<<<<<<<<<< * """ * write(self, source) */ /* 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_AddTraceback("pywrapfst.EncodeMapper.write", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21write(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_20write[] = "\n write(self, source)\n\n Serializes mapper to a file.\n\n This method writes the mapper to a file in a binary format.\n\n Args:\n source: The string location of the output file.\n Raises:\n FstIOError: Write failed.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21write(PyObject *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("write (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_20write(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((PyObject *)__pyx_v_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_20write(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write", 0); __Pyx_XDECREF(__pyx_r); __pyx_f_9pywrapfst_12EncodeMapper_write(__pyx_v_self, __pyx_v_source, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1438, __pyx_L1_error) __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1438, __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.write", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1454 * raise FstIOError(f"Write failed: {source!r}") * * cpdef bytes write_to_string(self): # <<<<<<<<<<<<<< * """ * write_to_string(self) */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_23write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_f_9pywrapfst_12EncodeMapper_write_to_string(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { std::stringstream __pyx_v__sstrm; 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; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write_to_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_12EncodeMapper_23write_to_string)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 1454, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1467 * """ * cdef stringstream _sstrm * if not self._mapper.get().WriteStream(_sstrm, b""): # <<<<<<<<<<<<<< * 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'", "_mapper"); __PYX_ERR(0, 1467, __pyx_L1_error) } __pyx_t_5 = ((!(__pyx_v_self->_mapper.get()->Write(__pyx_v__sstrm, __pyx_k_pywrapfst) != 0)) != 0); if (unlikely(__pyx_t_5)) { /* "pywrapfst.pyx":1468 * cdef stringstream _sstrm * if not self._mapper.get().WriteStream(_sstrm, b""): * raise FstIOError("Write to string failed") # <<<<<<<<<<<<<< * return _sstrm.str() * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_Write_to_string_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_Write_to_string_failed); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1468, __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, 1468, __pyx_L1_error) /* "pywrapfst.pyx":1467 * """ * cdef stringstream _sstrm * if not self._mapper.get().WriteStream(_sstrm, b""): # <<<<<<<<<<<<<< * raise FstIOError("Write to string failed") * return _sstrm.str() */ } /* "pywrapfst.pyx":1469 * if not self._mapper.get().WriteStream(_sstrm, b""): * raise FstIOError("Write to string failed") * return _sstrm.str() # <<<<<<<<<<<<<< * * cpdef _EncodeMapperSymbolTableView input_symbols(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v__sstrm.str()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1454 * raise FstIOError(f"Write failed: {source!r}") * * cpdef bytes 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_AddTraceback("pywrapfst.EncodeMapper.write_to_string", __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_12EncodeMapper_23write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_22write_to_string[] = "\n write_to_string(self)\n\n Serializes mapper to a string.\n\n Returns:\n A bytestring.\n\n Raises:\n FstIOError: Write to string failed.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_23write_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_12EncodeMapper_22write_to_string(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_22write_to_string(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write_to_string", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_12EncodeMapper_write_to_string(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1454, __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.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":1471 * return _sstrm.str() * * cpdef _EncodeMapperSymbolTableView input_symbols(self): # <<<<<<<<<<<<<< * """ * input_symbols(self) */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_25input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_12EncodeMapper_25input_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1471, __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__EncodeMapperSymbolTableView))))) __PYX_ERR(0, 1471, __pyx_L1_error) __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1477 * Returns the mapper's input symbol table, or None if none is present. * """ * if self._mapper.get().InputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=True) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1477, __pyx_L1_error) } __pyx_t_5 = ((__pyx_v_self->_mapper.get()->InputSymbols() == NULL) != 0); if (__pyx_t_5) { /* "pywrapfst.pyx":1478 * """ * if self._mapper.get().InputSymbols() == NULL: * return # <<<<<<<<<<<<<< * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=True) * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)Py_None); __Pyx_INCREF(Py_None); goto __pyx_L0; /* "pywrapfst.pyx":1477 * Returns the mapper's input symbol table, or None if none is present. * """ * if self._mapper.get().InputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=True) */ } /* "pywrapfst.pyx":1479 * if self._mapper.get().InputSymbols() == NULL: * return * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=True) # <<<<<<<<<<<<<< * * cpdef _EncodeMapperSymbolTableView 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'", "_mapper"); __PYX_ERR(0, 1479, __pyx_L1_error) } __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapperSymbolTableView(__pyx_v_self->_mapper, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1471 * return _sstrm.str() * * cpdef _EncodeMapperSymbolTableView 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_25input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_24input_symbols[] = "\n input_symbols(self)\n\n Returns the mapper's input symbol table, or None if none is present.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_25input_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_24input_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_24input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 1471, __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":1481 * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=True) * * cpdef _EncodeMapperSymbolTableView output_symbols(self): # <<<<<<<<<<<<<< * """ * output_symbols(self) */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_27output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) { struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_12EncodeMapper_27output_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1481, __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__EncodeMapperSymbolTableView))))) __PYX_ERR(0, 1481, __pyx_L1_error) __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1487 * Returns the mapper's output symbol table, or None if none is present. * """ * if self._mapper.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=False) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1487, __pyx_L1_error) } __pyx_t_5 = ((__pyx_v_self->_mapper.get()->OutputSymbols() == NULL) != 0); if (__pyx_t_5) { /* "pywrapfst.pyx":1488 * """ * if self._mapper.get().OutputSymbols() == NULL: * return # <<<<<<<<<<<<<< * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=False) * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)Py_None); __Pyx_INCREF(Py_None); goto __pyx_L0; /* "pywrapfst.pyx":1487 * Returns the mapper's output symbol table, or None if none is present. * """ * if self._mapper.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=False) */ } /* "pywrapfst.pyx":1489 * if self._mapper.get().OutputSymbols() == NULL: * return * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=False) # <<<<<<<<<<<<<< * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: */ __Pyx_XDECREF(((PyObject *)__pyx_r)); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1489, __pyx_L1_error) } __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapperSymbolTableView(__pyx_v_self->_mapper, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1481 * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=True) * * cpdef _EncodeMapperSymbolTableView 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_27output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_26output_symbols[] = "\n output_symbols(self)\n\n Returns the mapper's output symbol table, or None if none is present.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_27output_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_26output_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_26output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 1481, __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":1491 * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=False) * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols is None: * self._mapper.get().SetInputSymbols(NULL) */ static void __pyx_f_9pywrapfst_12EncodeMapper__set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; fst::SymbolTable const *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_set_input_symbols", 0); /* "pywrapfst.pyx":1492 * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mapper.get().SetInputSymbols(NULL) * return */ __pyx_t_1 = (((PyObject *)__pyx_v_symbols) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":1493 * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: * if symbols is None: * self._mapper.get().SetInputSymbols(NULL) # <<<<<<<<<<<<<< * return * self._mapper.get().SetInputSymbols(symbols._raw_ptr_or_raise()) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1493, __pyx_L1_error) } __pyx_v_self->_mapper.get()->SetInputSymbols(NULL); /* "pywrapfst.pyx":1494 * if symbols is None: * self._mapper.get().SetInputSymbols(NULL) * return # <<<<<<<<<<<<<< * self._mapper.get().SetInputSymbols(symbols._raw_ptr_or_raise()) * */ goto __pyx_L0; /* "pywrapfst.pyx":1492 * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mapper.get().SetInputSymbols(NULL) * return */ } /* "pywrapfst.pyx":1495 * self._mapper.get().SetInputSymbols(NULL) * return * self._mapper.get().SetInputSymbols(symbols._raw_ptr_or_raise()) # <<<<<<<<<<<<<< * * def set_input_symbols(self, SymbolTableView symbols): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1495, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1495, __pyx_L1_error) } __pyx_t_3 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_symbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1495, __pyx_L1_error) __pyx_v_self->_mapper.get()->SetInputSymbols(__pyx_t_3); /* "pywrapfst.pyx":1491 * return _init_EncodeMapperSymbolTableView(self._mapper, input_side=False) * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols is None: * self._mapper.get().SetInputSymbols(NULL) */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pywrapfst.EncodeMapper._set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":1497 * self._mapper.get().SetInputSymbols(symbols._raw_ptr_or_raise()) * * def set_input_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_input_symbols(self, symbols) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_29set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_28set_input_symbols[] = "\n set_input_symbols(self, symbols)\n\n Sets the mapper's input symbol table.\n\n Passing None as a value will delete the input symbol table.\n\n Args:\n symbols: A SymbolTable.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_29set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_input_symbols (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_symbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "symbols", 0))) __PYX_ERR(0, 1497, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_28set_input_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_symbols)); /* 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_28set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_input_symbols", 0); /* "pywrapfst.pyx":1511 * self. * """ * self._set_input_symbols(symbols) # <<<<<<<<<<<<<< * 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, 1511, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *)__pyx_v_self->__pyx_vtab)->_set_input_symbols(__pyx_v_self, __pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1511, __pyx_L1_error) /* "pywrapfst.pyx":1512 * """ * self._set_input_symbols(symbols) * return self # <<<<<<<<<<<<<< * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":1497 * self._mapper.get().SetInputSymbols(symbols._raw_ptr_or_raise()) * * def set_input_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_input_symbols(self, symbols) */ /* function exit code */ __pyx_L1_error:; __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":1514 * return self * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols is None: * self._mapper.get().SetOutputSymbols(NULL) */ static void __pyx_f_9pywrapfst_12EncodeMapper__set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; fst::SymbolTable const *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_set_output_symbols", 0); /* "pywrapfst.pyx":1515 * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mapper.get().SetOutputSymbols(NULL) * return */ __pyx_t_1 = (((PyObject *)__pyx_v_symbols) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":1516 * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: * if symbols is None: * self._mapper.get().SetOutputSymbols(NULL) # <<<<<<<<<<<<<< * return * self._mapper.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1516, __pyx_L1_error) } __pyx_v_self->_mapper.get()->SetOutputSymbols(NULL); /* "pywrapfst.pyx":1517 * if symbols is None: * self._mapper.get().SetOutputSymbols(NULL) * return # <<<<<<<<<<<<<< * self._mapper.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) * */ goto __pyx_L0; /* "pywrapfst.pyx":1515 * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mapper.get().SetOutputSymbols(NULL) * return */ } /* "pywrapfst.pyx":1518 * self._mapper.get().SetOutputSymbols(NULL) * return * self._mapper.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) # <<<<<<<<<<<<<< * * def set_output_symbols(self, SymbolTableView symbols): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1518, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1518, __pyx_L1_error) } __pyx_t_3 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_symbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1518, __pyx_L1_error) __pyx_v_self->_mapper.get()->SetOutputSymbols(__pyx_t_3); /* "pywrapfst.pyx":1514 * return self * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols is None: * self._mapper.get().SetOutputSymbols(NULL) */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pywrapfst.EncodeMapper._set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":1520 * self._mapper.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) * * def set_output_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_output_symbols(self, symbols) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_31set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols); /*proto*/ static char __pyx_doc_9pywrapfst_12EncodeMapper_30set_output_symbols[] = "\n set_output_symbols(self, symbols)\n\n Sets the mapper's output symbol table.\n\n Passing None as a value will delete the output symbol table.\n\n Args:\n symbols: A SymbolTable.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_31set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_output_symbols (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_symbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "symbols", 0))) __PYX_ERR(0, 1520, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_30set_output_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_symbols)); /* 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_30set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_output_symbols", 0); /* "pywrapfst.pyx":1534 * self. * """ * self._set_output_symbols(symbols) # <<<<<<<<<<<<<< * 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, 1534, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *)__pyx_v_self->__pyx_vtab)->_set_output_symbols(__pyx_v_self, __pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1534, __pyx_L1_error) /* "pywrapfst.pyx":1535 * """ * self._set_output_symbols(symbols) * return self # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":1520 * self._mapper.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) * * def set_output_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_output_symbols(self, symbols) */ /* function exit code */ __pyx_L1_error:; __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":1538 * * * cdef EncodeMapper _init_EncodeMapper(EncodeMapperClass_ptr mapper): # <<<<<<<<<<<<<< * cdef EncodeMapper result = EncodeMapper.__new__(EncodeMapper) * result._mapper.reset(mapper) */ static struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_f_9pywrapfst__init_EncodeMapper(__pyx_t_9pywrapfst_EncodeMapperClass_ptr __pyx_v_mapper) { struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_result = 0; struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_EncodeMapper", 0); /* "pywrapfst.pyx":1539 * * cdef EncodeMapper _init_EncodeMapper(EncodeMapperClass_ptr mapper): * cdef EncodeMapper result = EncodeMapper.__new__(EncodeMapper) # <<<<<<<<<<<<<< * result._mapper.reset(mapper) * return result */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_EncodeMapper(((PyTypeObject *)__pyx_ptype_9pywrapfst_EncodeMapper), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1539, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v_result = ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1540 * cdef EncodeMapper _init_EncodeMapper(EncodeMapperClass_ptr mapper): * cdef EncodeMapper result = EncodeMapper.__new__(EncodeMapper) * result._mapper.reset(mapper) # <<<<<<<<<<<<<< * return result * */ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 1540, __pyx_L1_error) } __pyx_v_result->_mapper.reset(__pyx_v_mapper); /* "pywrapfst.pyx":1541 * cdef EncodeMapper result = EncodeMapper.__new__(EncodeMapper) * result._mapper.reset(mapper) * return result # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_result)); __pyx_r = __pyx_v_result; goto __pyx_L0; /* "pywrapfst.pyx":1538 * * * cdef EncodeMapper _init_EncodeMapper(EncodeMapperClass_ptr mapper): # <<<<<<<<<<<<<< * cdef EncodeMapper result = EncodeMapper.__new__(EncodeMapper) * result._mapper.reset(mapper) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pywrapfst._init_EncodeMapper", __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":1544 * * * cpdef EncodeMapper _read_EncodeMapper_from_string(string state): # <<<<<<<<<<<<<< * cdef stringstream _sstrm * _sstrm << state */ static PyObject *__pyx_pw_9pywrapfst_15_read_EncodeMapper_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state); /*proto*/ static struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_f_9pywrapfst__read_EncodeMapper_from_string(std::string __pyx_v_state, CYTHON_UNUSED int __pyx_skip_dispatch) { std::stringstream __pyx_v__sstrm; std::unique_ptr __pyx_v__mapper; struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_EncodeMapper_from_string", 0); /* "pywrapfst.pyx":1546 * cpdef EncodeMapper _read_EncodeMapper_from_string(string state): * cdef stringstream _sstrm * _sstrm << state # <<<<<<<<<<<<<< * cdef unique_ptr[fst.EncodeMapperClass] _mapper * _mapper.reset(fst.EncodeMapperClass.ReadStream(_sstrm, b"")) */ (void)((__pyx_v__sstrm << __pyx_v_state)); /* "pywrapfst.pyx":1548 * _sstrm << state * cdef unique_ptr[fst.EncodeMapperClass] _mapper * _mapper.reset(fst.EncodeMapperClass.ReadStream(_sstrm, b"")) # <<<<<<<<<<<<<< * if _mapper.get() == NULL: * raise FstIOError("Read from string failed") */ __pyx_v__mapper.reset(fst::script::EncodeMapperClass::Read(__pyx_v__sstrm, __pyx_k_pywrapfst)); /* "pywrapfst.pyx":1549 * cdef unique_ptr[fst.EncodeMapperClass] _mapper * _mapper.reset(fst.EncodeMapperClass.ReadStream(_sstrm, b"")) * if _mapper.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError("Read from string failed") * return _init_EncodeMapper(_mapper.release()) */ __pyx_t_1 = ((__pyx_v__mapper.get() == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":1550 * _mapper.reset(fst.EncodeMapperClass.ReadStream(_sstrm, b"")) * if _mapper.get() == NULL: * raise FstIOError("Read from string failed") # <<<<<<<<<<<<<< * return _init_EncodeMapper(_mapper.release()) * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Read_from_string_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Read_from_string_failed); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1550, __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, 1550, __pyx_L1_error) /* "pywrapfst.pyx":1549 * cdef unique_ptr[fst.EncodeMapperClass] _mapper * _mapper.reset(fst.EncodeMapperClass.ReadStream(_sstrm, b"")) * if _mapper.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError("Read from string failed") * return _init_EncodeMapper(_mapper.release()) */ } /* "pywrapfst.pyx":1551 * if _mapper.get() == NULL: * raise FstIOError("Read from string failed") * return _init_EncodeMapper(_mapper.release()) # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapper(__pyx_v__mapper.release())); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1544 * * * cpdef EncodeMapper _read_EncodeMapper_from_string(string state): # <<<<<<<<<<<<<< * cdef stringstream _sstrm * _sstrm << state */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst._read_EncodeMapper_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_EncodeMapper_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_15_read_EncodeMapper_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state) { std::string __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_read_EncodeMapper_from_string (wrapper)", 0); assert(__pyx_arg_state); { __pyx_v_state = __pyx_convert_string_from_py_std__in_string(__pyx_arg_state); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1544, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst._read_EncodeMapper_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_9pywrapfst_14_read_EncodeMapper_from_string(__pyx_self, ((std::string)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_14_read_EncodeMapper_from_string(CYTHON_UNUSED PyObject *__pyx_self, std::string __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_EncodeMapper_from_string", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read_EncodeMapper_from_string(__pyx_v_state, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1544, __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_EncodeMapper_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1577 * * @staticmethod * cdef string _local_render_svg(const string &dot): # <<<<<<<<<<<<<< * proc = subprocess.Popen(("dot", "-Tsvg"), * stdin=subprocess.PIPE, */ static std::string __pyx_f_9pywrapfst_3Fst__local_render_svg(std::string const &__pyx_v_dot) { PyObject *__pyx_v_proc = NULL; 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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_local_render_svg", 0); /* "pywrapfst.pyx":1578 * @staticmethod * cdef string _local_render_svg(const string &dot): * proc = subprocess.Popen(("dot", "-Tsvg"), # <<<<<<<<<<<<<< * stdin=subprocess.PIPE, * stdout=subprocess.PIPE) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_subprocess); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1578, __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, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1579 * cdef string _local_render_svg(const string &dot): * proc = subprocess.Popen(("dot", "-Tsvg"), * stdin=subprocess.PIPE, # <<<<<<<<<<<<<< * stdout=subprocess.PIPE) * return proc.communicate(dot.encode("utf8"))[0] */ __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_subprocess); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stdin, __pyx_t_4) < 0) __PYX_ERR(0, 1579, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":1580 * proc = subprocess.Popen(("dot", "-Tsvg"), * stdin=subprocess.PIPE, * stdout=subprocess.PIPE) # <<<<<<<<<<<<<< * return proc.communicate(dot.encode("utf8"))[0] * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_subprocess); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stdout, __pyx_t_3) < 0) __PYX_ERR(0, 1579, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pywrapfst.pyx":1578 * @staticmethod * cdef string _local_render_svg(const string &dot): * proc = subprocess.Popen(("dot", "-Tsvg"), # <<<<<<<<<<<<<< * stdin=subprocess.PIPE, * stdout=subprocess.PIPE) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__10, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_proc = __pyx_t_3; __pyx_t_3 = 0; /* "pywrapfst.pyx":1581 * stdin=subprocess.PIPE, * stdout=subprocess.PIPE) * return proc.communicate(dot.encode("utf8"))[0] # <<<<<<<<<<<<<< * * def _repr_svg_(self): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_proc, __pyx_n_s_communicate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_dot); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyUnicode_AsUTF8String(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __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); } } __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_3 == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 1581, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1581, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; goto __pyx_L0; /* "pywrapfst.pyx":1577 * * @staticmethod * cdef string _local_render_svg(const string &dot): # <<<<<<<<<<<<<< * proc = subprocess.Popen(("dot", "-Tsvg"), * stdin=subprocess.PIPE, */ /* 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._local_render_svg", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_XDECREF(__pyx_v_proc); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1583 * return proc.communicate(dot.encode("utf8"))[0] * * def _repr_svg_(self): # <<<<<<<<<<<<<< * """IPython notebook magic to produce an SVG of the FST using GraphViz. * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_1_repr_svg_(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst__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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_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_3Fst__repr_svg_(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst__repr_svg_(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { std::stringstream __pyx_v__sstrm; bool __pyx_v_acceptor; PyObject *__pyx_v_e = 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; int __pyx_t_5; 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; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_repr_svg_", 0); /* "pywrapfst.pyx":1591 * """ * cdef stringstream _sstrm * cdef bool acceptor = (self._fst.get().Properties(fst.kAcceptor, True) == # <<<<<<<<<<<<<< * fst.kAcceptor) * fst.Draw(deref(self._fst), */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1591, __pyx_L1_error) } /* "pywrapfst.pyx":1592 * cdef stringstream _sstrm * cdef bool acceptor = (self._fst.get().Properties(fst.kAcceptor, True) == * fst.kAcceptor) # <<<<<<<<<<<<<< * fst.Draw(deref(self._fst), * self._fst.get().InputSymbols(), */ __pyx_v_acceptor = (__pyx_v_self->_fst.get()->Properties(fst::kAcceptor, 1) == fst::kAcceptor); /* "pywrapfst.pyx":1593 * cdef bool acceptor = (self._fst.get().Properties(fst.kAcceptor, True) == * fst.kAcceptor) * fst.Draw(deref(self._fst), # <<<<<<<<<<<<<< * self._fst.get().InputSymbols(), * self._fst.get().OutputSymbols(), */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1593, __pyx_L1_error) } /* "pywrapfst.pyx":1594 * fst.kAcceptor) * fst.Draw(deref(self._fst), * self._fst.get().InputSymbols(), # <<<<<<<<<<<<<< * self._fst.get().OutputSymbols(), * NULL, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1594, __pyx_L1_error) } /* "pywrapfst.pyx":1595 * fst.Draw(deref(self._fst), * self._fst.get().InputSymbols(), * self._fst.get().OutputSymbols(), # <<<<<<<<<<<<<< * NULL, * acceptor, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1595, __pyx_L1_error) } /* "pywrapfst.pyx":1593 * cdef bool acceptor = (self._fst.get().Properties(fst.kAcceptor, True) == * fst.kAcceptor) * fst.Draw(deref(self._fst), # <<<<<<<<<<<<<< * self._fst.get().InputSymbols(), * self._fst.get().OutputSymbols(), */ fst::script::Draw((*__pyx_v_self->_fst), __pyx_v_self->_fst.get()->InputSymbols(), __pyx_v_self->_fst.get()->OutputSymbols(), NULL, __pyx_v_acceptor, __pyx_k__11, 8.5, 11.0, 1, 0, 0.4, 0.25, 14, 5, __pyx_k_g, 0, __pyx_v__sstrm, __pyx_k_pywrapfst); /* "pywrapfst.pyx":1611 * _sstrm, * b"") * try: # <<<<<<<<<<<<<< * return Fst._local_render_svg(_sstrm.str()) * except Exception as e: */ { __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":1612 * b"") * try: * return Fst._local_render_svg(_sstrm.str()) # <<<<<<<<<<<<<< * except Exception as e: * logging.error("Dot rendering failed: %s", e) */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_3Fst__local_render_svg(__pyx_v__sstrm.str())); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1612, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L7_try_return; /* "pywrapfst.pyx":1611 * _sstrm, * b"") * try: # <<<<<<<<<<<<<< * return Fst._local_render_svg(_sstrm.str()) * except Exception as e: */ } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":1613 * try: * return Fst._local_render_svg(_sstrm.str()) * except Exception as e: # <<<<<<<<<<<<<< * logging.error("Dot rendering failed: %s", e) * */ __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_5) { __Pyx_AddTraceback("pywrapfst.Fst._repr_svg_", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 1613, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "pywrapfst.pyx":1614 * return Fst._local_render_svg(_sstrm.str()) * except Exception as e: * logging.error("Dot rendering failed: %s", e) # <<<<<<<<<<<<<< * * def __init__(self): */ __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_logging); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1614, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_error); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1614, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_10); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_10, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_u_Dot_rendering_failed_s, __pyx_v_e}; __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1614, __pyx_L14_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_8); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_u_Dot_rendering_failed_s, __pyx_v_e}; __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1614, __pyx_L14_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_8); } else #endif { __pyx_t_11 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1614, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_INCREF(__pyx_kp_u_Dot_rendering_failed_s); __Pyx_GIVEREF(__pyx_kp_u_Dot_rendering_failed_s); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_5, __pyx_kp_u_Dot_rendering_failed_s); __Pyx_INCREF(__pyx_v_e); __Pyx_GIVEREF(__pyx_v_e); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_5, __pyx_v_e); __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1614, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } /* "pywrapfst.pyx":1613 * try: * return Fst._local_render_svg(_sstrm.str()) * except Exception as e: # <<<<<<<<<<<<<< * logging.error("Dot rendering failed: %s", e) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L15; } __pyx_L14_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_5 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_5; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L5_except_error; } __pyx_L15:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "pywrapfst.pyx":1611 * _sstrm, * b"") * try: # <<<<<<<<<<<<<< * return Fst._local_render_svg(_sstrm.str()) * except Exception as e: */ __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_L4_exception_handled:; __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); } /* "pywrapfst.pyx":1583 * return proc.communicate(dot.encode("utf8"))[0] * * def _repr_svg_(self): # <<<<<<<<<<<<<< * """IPython notebook magic to produce an SVG of the FST using GraphViz. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __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_AddTraceback("pywrapfst.Fst._repr_svg_", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1616 * logging.error("Dot rendering failed: %s", e) * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {self._class__.__name__}") * */ /* Python wrapper */ static int __pyx_pw_9pywrapfst_3Fst_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_9pywrapfst_3Fst_3__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_3Fst_2__init__(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_9pywrapfst_3Fst_2__init__(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":1617 * * def __init__(self): * raise NotImplementedError(f"Cannot construct {self._class__.__name__}") # <<<<<<<<<<<<<< * * # Registers the class for pickling; must be repeated in any subclass which */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Cannot_construct, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1617, __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, 1617, __pyx_L1_error) /* "pywrapfst.pyx":1616 * logging.error("Dot rendering failed: %s", e) * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {self._class__.__name__}") * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pywrapfst.Fst.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1622 * # can't be derived by _init_XFst. * * def __reduce__(self): # <<<<<<<<<<<<<< * return (_read_Fst_from_string, (self.write_to_string(),)) * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_5__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_3Fst_5__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_3Fst_4__reduce__(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_4__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce__", 0); /* "pywrapfst.pyx":1623 * * def __reduce__(self): * return (_read_Fst_from_string, (self.write_to_string(),)) # <<<<<<<<<<<<<< * * def __repr__(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_read_Fst_from_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1623, __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, 1623, __pyx_L1_error) } __pyx_t_2 = ((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, 1623, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1623, __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, 1623, __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":1622 * # can't be derived by _init_XFst. * * def __reduce__(self): # <<<<<<<<<<<<<< * return (_read_Fst_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":1625 * return (_read_Fst_from_string, (self.write_to_string(),)) * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.fst_type()} Fst at 0x{id(self):x}>" * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_7__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_3Fst_7__repr__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_6__repr__(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_6__repr__(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":1626 * * def __repr__(self): * return f"<{self.fst_type()} Fst at 0x{id(self):x}>" # <<<<<<<<<<<<<< * * def __str__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u__2); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u__2); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "fst_type"); __PYX_ERR(0, 1626, __pyx_L1_error) } __pyx_t_4 = __pyx_convert_PyUnicode_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_4)) __PYX_ERR(0, 1626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_Fst_at_0x); __pyx_t_2 += 10; __Pyx_GIVEREF(__pyx_kp_u_Fst_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_Fst_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1625 * return (_read_Fst_from_string, (self.write_to_string(),)) * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.fst_type()} Fst at 0x{id(self):x}>" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __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":1628 * return f"<{self.fst_type()} Fst at 0x{id(self):x}>" * * def __str__(self): # <<<<<<<<<<<<<< * return self.print() * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_9__str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_3Fst_9__str__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_8__str__(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_8__str__(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); /* "pywrapfst.pyx":1629 * * def __str__(self): * return self.print() # <<<<<<<<<<<<<< * * cpdef string arc_type(self): */ __Pyx_XDECREF(__pyx_r); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "print"); __PYX_ERR(0, 1629, __pyx_L1_error) } __pyx_t_1 = ((struct __pyx_vtabstruct_9pywrapfst_Fst *)__pyx_v_self->__pyx_vtab)->print(__pyx_v_self, 0, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1629, __pyx_L1_error) __pyx_t_2 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1628 * return f"<{self.fst_type()} Fst at 0x{id(self):x}>" * * def __str__(self): # <<<<<<<<<<<<<< * return self.print() * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __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":1631 * return self.print() * * cpdef string arc_type(self): # <<<<<<<<<<<<<< * """ * arc_type(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_11arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static std::string __pyx_f_9pywrapfst_3Fst_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1631, __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, 1631, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1637 * 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, 1637, __pyx_L1_error) } __pyx_r = __pyx_v_self->_fst.get()->ArcType(); goto __pyx_L0; /* "pywrapfst.pyx":1631 * return self.print() * * 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_3Fst_11arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_10arc_type[] = "\n arc_type(self)\n\n Returns a string indicating the arc type.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_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_3Fst_10arc_type(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_10arc_type(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("arc_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_3Fst_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1631, __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":1639 * return self._fst.get().ArcType() * * cpdef ArcIterator arcs(self, int64 state): # <<<<<<<<<<<<<< * """ * arcs(self, state) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_13arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_f_9pywrapfst_3Fst_arcs(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1639, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_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, 1639, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1639, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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, 1639, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1651 * An ArcIterator. * """ * 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, 1651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1651, __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, 1651, __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":1639 * 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_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_3Fst_13arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_13arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1639, __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_3Fst_12arcs(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self), ((int64)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_12arcs(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("arcs", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Fst_arcs(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1639, __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":1653 * return ArcIterator(self, state) * * cpdef Fst copy(self): # <<<<<<<<<<<<<< * """ * copy(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_15copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static struct __pyx_obj_9pywrapfst_Fst *__pyx_f_9pywrapfst_3Fst_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1653, __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, 1653, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1659 * 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, 1659, __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, 1659, __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":1653 * 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_3Fst_15copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_14copy[] = "\n copy(self)\n\n Makes a copy of the FST.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_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_3Fst_14copy(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_14copy(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("copy", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Fst_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1653, __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":1661 * return _init_XFst(new fst.FstClass(deref(self._fst))) * * cpdef void draw(self, # <<<<<<<<<<<<<< * source, * SymbolTableView isymbols=None, */ static PyObject *__pyx_pw_9pywrapfst_3Fst_17draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static void __pyx_f_9pywrapfst_3Fst_draw(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, PyObject *__pyx_v_source, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_3Fst_draw *__pyx_optional_args) { /* "pywrapfst.pyx":1663 * cpdef void draw(self, * source, * SymbolTableView isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView osymbols=None, * SymbolTableView ssymbols=None, */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1664 * source, * SymbolTableView isymbols=None, * SymbolTableView osymbols=None, # <<<<<<<<<<<<<< * SymbolTableView ssymbols=None, * bool acceptor=False, */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1665 * SymbolTableView isymbols=None, * SymbolTableView osymbols=None, * SymbolTableView ssymbols=None, # <<<<<<<<<<<<<< * bool acceptor=False, * title="", */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1666 * SymbolTableView osymbols=None, * SymbolTableView ssymbols=None, * bool acceptor=False, # <<<<<<<<<<<<<< * title="", * double width=8.5, */ bool __pyx_v_acceptor = ((bool)0); PyObject *__pyx_v_title = ((PyObject *)__pyx_kp_u__11); double __pyx_v_width = ((double)8.5); double __pyx_v_height = ((double)11.0); /* "pywrapfst.pyx":1670 * 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":1671 * 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); int32 __pyx_v_fontsize = ((int32)14); int32 __pyx_v_precision = ((int32)5); PyObject *__pyx_v_float_format = ((PyObject *)__pyx_n_u_g); /* "pywrapfst.pyx":1677 * int32 precision=5, * float_format="g", * bool show_weight_one=False) except *: # <<<<<<<<<<<<<< * """ * draw(self, source, isymbols=None, osymbols=None, ssymbols=None, */ bool __pyx_v_show_weight_one = ((bool)0); std::string __pyx_v__source; std::unique_ptr __pyx_v__fstrm; fst::SymbolTable const *__pyx_v__isymbols; fst::SymbolTable const *__pyx_v__osymbols; fst::SymbolTable const *__pyx_v__ssymbols; __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 const *__pyx_t_20; std::string __pyx_t_21; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":1661 * return _init_XFst(new fst.FstClass(deref(self._fst))) * * cpdef void draw(self, # <<<<<<<<<<<<<< * source, * SymbolTableView 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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_draw); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_17draw)) { __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_acceptor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyFloat_FromDouble(__pyx_v_width); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyFloat_FromDouble(__pyx_v_height); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1661, __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, 1661, __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, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyFloat_FromDouble(__pyx_v_ranksep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = PyFloat_FromDouble(__pyx_v_nodesep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1661, __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, 1661, __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, 1661, __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, 1661, __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_source, ((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, 1661, __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_source, ((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, 1661, __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, 1661, __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_source); __Pyx_GIVEREF(__pyx_v_source); PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_v_source); __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, 1661, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1709 * show_weight_one: Should weights equivalent to semiring One be printed? * """ * cdef string _source = path_tostring(source) # <<<<<<<<<<<<<< * cdef unique_ptr[ostream] _fstrm * _fstrm.reset(new ofstream(_source)) */ __pyx_t_17 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1709, __pyx_L1_error) __pyx_v__source = __pyx_t_17; /* "pywrapfst.pyx":1711 * cdef string _source = path_tostring(source) * cdef unique_ptr[ostream] _fstrm * _fstrm.reset(new ofstream(_source)) # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() * if isymbols is not None: */ __pyx_v__fstrm.reset(new std::ofstream(__pyx_v__source)); /* "pywrapfst.pyx":1712 * cdef unique_ptr[ostream] _fstrm * _fstrm.reset(new ofstream(_source)) * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() # <<<<<<<<<<<<<< * if isymbols is not None: * _isymbols = isymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1712, __pyx_L1_error) } __pyx_v__isymbols = __pyx_v_self->_fst.get()->InputSymbols(); /* "pywrapfst.pyx":1713 * _fstrm.reset(new ofstream(_source)) * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() * if isymbols is not None: # <<<<<<<<<<<<<< * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() */ __pyx_t_18 = (((PyObject *)__pyx_v_isymbols) != Py_None); __pyx_t_19 = (__pyx_t_18 != 0); if (__pyx_t_19) { /* "pywrapfst.pyx":1714 * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() * if isymbols is not None: * _isymbols = isymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: */ if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1714, __pyx_L1_error) } __pyx_t_20 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_isymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_isymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1714, __pyx_L1_error) __pyx_v__isymbols = __pyx_t_20; /* "pywrapfst.pyx":1713 * _fstrm.reset(new ofstream(_source)) * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() * if isymbols is not None: # <<<<<<<<<<<<<< * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() */ } /* "pywrapfst.pyx":1715 * if isymbols is not None: * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() # <<<<<<<<<<<<<< * if osymbols is not None: * _osymbols = osymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1715, __pyx_L1_error) } __pyx_v__osymbols = __pyx_v_self->_fst.get()->OutputSymbols(); /* "pywrapfst.pyx":1716 * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: # <<<<<<<<<<<<<< * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL */ __pyx_t_19 = (((PyObject *)__pyx_v_osymbols) != Py_None); __pyx_t_18 = (__pyx_t_19 != 0); if (__pyx_t_18) { /* "pywrapfst.pyx":1717 * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: * _osymbols = osymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1717, __pyx_L1_error) } __pyx_t_20 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_osymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_osymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1717, __pyx_L1_error) __pyx_v__osymbols = __pyx_t_20; /* "pywrapfst.pyx":1716 * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: # <<<<<<<<<<<<<< * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL */ } /* "pywrapfst.pyx":1718 * if osymbols is not None: * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL # <<<<<<<<<<<<<< * if ssymbols is not None: * _ssymbols = ssymbols._raw_ptr_or_raise() */ __pyx_v__ssymbols = NULL; /* "pywrapfst.pyx":1719 * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL * if ssymbols is not None: # <<<<<<<<<<<<<< * _ssymbols = ssymbols._raw_ptr_or_raise() * fst.Draw(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":1720 * cdef const fst.SymbolTable *_ssymbols = NULL * if ssymbols is not None: * _ssymbols = ssymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * fst.Draw(deref(self._fst), * _isymbols, */ if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1720, __pyx_L1_error) } __pyx_t_20 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_ssymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_ssymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1720, __pyx_L1_error) __pyx_v__ssymbols = __pyx_t_20; /* "pywrapfst.pyx":1719 * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL * if ssymbols is not None: # <<<<<<<<<<<<<< * _ssymbols = ssymbols._raw_ptr_or_raise() * fst.Draw(deref(self._fst), */ } /* "pywrapfst.pyx":1721 * if ssymbols is not None: * _ssymbols = ssymbols._raw_ptr_or_raise() * fst.Draw(deref(self._fst), # <<<<<<<<<<<<<< * _isymbols, * _osymbols, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1721, __pyx_L1_error) } /* "pywrapfst.pyx":1726 * _ssymbols, * acceptor, * tostring(title), # <<<<<<<<<<<<<< * width, * height, */ __pyx_t_17 = __pyx_f_9pywrapfst_tostring(__pyx_v_title); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1726, __pyx_L1_error) /* "pywrapfst.pyx":1735 * fontsize, * precision, * tostring(float_format), # <<<<<<<<<<<<<< * show_weight_one, * deref(_fstrm), */ __pyx_t_21 = __pyx_f_9pywrapfst_tostring(__pyx_v_float_format); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1735, __pyx_L1_error) /* "pywrapfst.pyx":1721 * if ssymbols is not None: * _ssymbols = ssymbols._raw_ptr_or_raise() * fst.Draw(deref(self._fst), # <<<<<<<<<<<<<< * _isymbols, * _osymbols, */ fst::script::Draw((*__pyx_v_self->_fst), __pyx_v__isymbols, __pyx_v__osymbols, __pyx_v__ssymbols, __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_21, __pyx_v_show_weight_one, (*__pyx_v__fstrm), __pyx_v__source); /* "pywrapfst.pyx":1661 * return _init_XFst(new fst.FstClass(deref(self._fst))) * * cpdef void draw(self, # <<<<<<<<<<<<<< * source, * SymbolTableView 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_AddTraceback("pywrapfst.Fst.draw", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_17draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_16draw[] = "\n draw(self, source, 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 source: 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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_17draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_source = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_isymbols = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_osymbols = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__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; int32 __pyx_v_fontsize; int32 __pyx_v_precision; PyObject *__pyx_v_float_format = 0; bool __pyx_v_show_weight_one; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("draw (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source,&__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":1663 * cpdef void draw(self, * source, * SymbolTableView isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView osymbols=None, * SymbolTableView ssymbols=None, */ values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1664 * source, * SymbolTableView isymbols=None, * SymbolTableView osymbols=None, # <<<<<<<<<<<<<< * SymbolTableView ssymbols=None, * bool acceptor=False, */ values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1665 * SymbolTableView isymbols=None, * SymbolTableView osymbols=None, * SymbolTableView ssymbols=None, # <<<<<<<<<<<<<< * bool acceptor=False, * title="", */ values[3] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); values[5] = ((PyObject *)__pyx_kp_u__11); values[14] = ((PyObject *)__pyx_n_u_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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_source)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_isymbols); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_osymbols); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ssymbols); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_acceptor); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_title); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_width); if (value) { values[6] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_height); if (value) { values[7] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 8: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_portrait); if (value) { values[8] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 9: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_vertical); if (value) { values[9] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 10: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ranksep); if (value) { values[10] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 11: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nodesep); if (value) { values[11] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 12: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fontsize); if (value) { values[12] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 13: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_precision); if (value) { values[13] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 14: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_float_format); if (value) { values[14] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 15: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 1661, __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_source = values[0]; __pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)values[1]); __pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)values[2]); __pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)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, 1666, __pyx_L3_error) } else { /* "pywrapfst.pyx":1666 * SymbolTableView osymbols=None, * SymbolTableView ssymbols=None, * bool acceptor=False, # <<<<<<<<<<<<<< * title="", * 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, 1668, __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, 1669, __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, 1670, __pyx_L3_error) } else { /* "pywrapfst.pyx":1670 * 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, 1671, __pyx_L3_error) } else { /* "pywrapfst.pyx":1671 * 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, 1672, __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, 1673, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1674, __pyx_L3_error) } else { __pyx_v_fontsize = ((int32)14); } if (values[13]) { __pyx_v_precision = __Pyx_PyInt_As_int32_t(values[13]); if (unlikely((__pyx_v_precision == ((int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1675, __pyx_L3_error) } else { __pyx_v_precision = ((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, 1677, __pyx_L3_error) } else { /* "pywrapfst.pyx":1677 * int32 precision=5, * float_format="g", * bool show_weight_one=False) except *: # <<<<<<<<<<<<<< * """ * draw(self, source, 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, 1661, __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_SymbolTableView, 1, "isymbols", 0))) __PYX_ERR(0, 1663, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "osymbols", 0))) __PYX_ERR(0, 1664, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "ssymbols", 0))) __PYX_ERR(0, 1665, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_3Fst_16draw(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self), __pyx_v_source, __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":1661 * return _init_XFst(new fst.FstClass(deref(self._fst))) * * cpdef void draw(self, # <<<<<<<<<<<<<< * source, * SymbolTableView 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_3Fst_16draw(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, PyObject *__pyx_v_source, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTableView *__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, int32 __pyx_v_fontsize, 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_3Fst_draw __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_source, 1, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1661, __pyx_L1_error) __pyx_t_2 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1661, __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":1740 * _source) * * cpdef Weight final(self, int64 state): # <<<<<<<<<<<<<< * """ * final(self, state) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_19final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_3Fst_final(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, 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; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_final); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_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, 1740, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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, 1740, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1755 * FstIndexError: State index out of range. * """ * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) * if not _weight.member(): */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1755, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1756 * """ * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) # <<<<<<<<<<<<<< * if not _weight.member(): * raise FstIndexError("State index out of range") */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_weight"); __PYX_ERR(0, 1756, __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, 1756, __pyx_L1_error) } __pyx_v__weight->_weight.reset(new fst::script::WeightClass(__pyx_v_self->_fst.get()->Final(__pyx_v_state))); /* "pywrapfst.pyx":1757 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) * if not _weight.member(): # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _weight */ if (unlikely(((PyObject *)__pyx_v__weight) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "member"); __PYX_ERR(0, 1757, __pyx_L1_error) } __pyx_t_6 = ((!(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v__weight->__pyx_vtab)->member(__pyx_v__weight, 0) != 0)) != 0); if (unlikely(__pyx_t_6)) { /* "pywrapfst.pyx":1758 * _weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) * if not _weight.member(): * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< * return _weight * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1758, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1758, __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, 1758, __pyx_L1_error) /* "pywrapfst.pyx":1757 * cdef Weight _weight = Weight.__new__(Weight) * _weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) * if not _weight.member(): # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _weight */ } /* "pywrapfst.pyx":1759 * if not _weight.member(): * raise FstIndexError("State index out of range") * 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":1740 * _source) * * 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_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_3Fst_19final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_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_3Fst_19final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1740, __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_3Fst_18final(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self), ((int64)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_18final(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("final", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Fst_final(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1740, __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":1761 * return _weight * * cpdef string fst_type(self): # <<<<<<<<<<<<<< * """ * fst_type(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_21fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static std::string __pyx_f_9pywrapfst_3Fst_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_fst_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1761, __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, 1761, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1767 * Returns a string indicating the FST type. * """ * return self._fst.get().FstType() # <<<<<<<<<<<<<< * * cpdef _FstSymbolTableView 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, 1767, __pyx_L1_error) } __pyx_r = __pyx_v_self->_fst.get()->FstType(); goto __pyx_L0; /* "pywrapfst.pyx":1761 * 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_3Fst_21fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_20fst_type[] = "\n fst_type(self)\n\n Returns a string indicating the FST type.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_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_3Fst_20fst_type(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_20fst_type(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fst_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_3Fst_fst_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1761, __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":1769 * return self._fst.get().FstType() * * cpdef _FstSymbolTableView input_symbols(self): # <<<<<<<<<<<<<< * """ * input_symbols(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_23input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_f_9pywrapfst_3Fst_input_symbols(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch) { struct __pyx_obj_9pywrapfst__FstSymbolTableView *__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1769, __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__FstSymbolTableView))))) __PYX_ERR(0, 1769, __pyx_L1_error) __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1775 * Returns the FST's input symbol table, or None if none is present. * """ * if self._fst.get().InputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_FstSymbolTableView(self._fst, input_side=True) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1775, __pyx_L1_error) } __pyx_t_5 = ((__pyx_v_self->_fst.get()->InputSymbols() == NULL) != 0); if (__pyx_t_5) { /* "pywrapfst.pyx":1776 * """ * if self._fst.get().InputSymbols() == NULL: * return # <<<<<<<<<<<<<< * return _init_FstSymbolTableView(self._fst, input_side=True) * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)Py_None); __Pyx_INCREF(Py_None); goto __pyx_L0; /* "pywrapfst.pyx":1775 * Returns the FST's input symbol table, or None if none is present. * """ * if self._fst.get().InputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_FstSymbolTableView(self._fst, input_side=True) */ } /* "pywrapfst.pyx":1777 * if self._fst.get().InputSymbols() == NULL: * return * return _init_FstSymbolTableView(self._fst, input_side=True) # <<<<<<<<<<<<<< * * 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, 1777, __pyx_L1_error) } __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_FstSymbolTableView(__pyx_v_self->_fst, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1777, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1769 * return self._fst.get().FstType() * * cpdef _FstSymbolTableView 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_3Fst_23input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_22input_symbols[] = "\n input_symbols(self)\n\n Returns the FST's input symbol table, or None if none is present.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_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_3Fst_22input_symbols(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_22input_symbols(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("input_symbols", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Fst_input_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1769, __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":1779 * return _init_FstSymbolTableView(self._fst, input_side=True) * * cpdef size_t num_arcs(self, int64 state) except *: # <<<<<<<<<<<<<< * """ * num_arcs(self, state) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_25num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static size_t __pyx_f_9pywrapfst_3Fst_num_arcs(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, 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; size_t __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_25num_arcs)) { __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1779, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1779, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1779, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1794 * FstIndexError: State index out of range. * """ * 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, 1794, __pyx_L1_error) } __pyx_v__result = __pyx_v_self->_fst.get()->NumArcs(__pyx_v_state); /* "pywrapfst.pyx":1795 * """ * cdef size_t _result = self._fst.get().NumArcs(state) * if _result == SIZE_MAX: # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _result */ __pyx_t_7 = ((__pyx_v__result == SIZE_MAX) != 0); if (unlikely(__pyx_t_7)) { /* "pywrapfst.pyx":1796 * cdef size_t _result = self._fst.get().NumArcs(state) * if _result == SIZE_MAX: * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< * return _result * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1796, __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, 1796, __pyx_L1_error) /* "pywrapfst.pyx":1795 * """ * cdef size_t _result = self._fst.get().NumArcs(state) * if _result == SIZE_MAX: # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _result */ } /* "pywrapfst.pyx":1797 * 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":1779 * return _init_FstSymbolTableView(self._fst, input_side=True) * * 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_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_3Fst_25num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_25num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1779, __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_3Fst_24num_arcs(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self), ((int64)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_24num_arcs(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations size_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("num_arcs", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_3Fst_num_arcs(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1779, __pyx_L1_error) __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1779, __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":1799 * return _result * * cpdef size_t num_input_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<< * """ * num_input_epsilons(self, state) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_27num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static size_t __pyx_f_9pywrapfst_3Fst_num_input_epsilons(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, 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; size_t __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_input_epsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1799, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_27num_input_epsilons)) { __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1799, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1799, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1799, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1814 * FstIndexError: State index out of range. * """ * 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, 1814, __pyx_L1_error) } __pyx_v__result = __pyx_v_self->_fst.get()->NumInputEpsilons(__pyx_v_state); /* "pywrapfst.pyx":1815 * """ * cdef size_t _result = self._fst.get().NumInputEpsilons(state) * if _result == SIZE_MAX: # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _result */ __pyx_t_7 = ((__pyx_v__result == SIZE_MAX) != 0); if (unlikely(__pyx_t_7)) { /* "pywrapfst.pyx":1816 * cdef size_t _result = self._fst.get().NumInputEpsilons(state) * if _result == SIZE_MAX: * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< * return _result * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1816, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1816, __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, 1816, __pyx_L1_error) /* "pywrapfst.pyx":1815 * """ * cdef size_t _result = self._fst.get().NumInputEpsilons(state) * if _result == SIZE_MAX: # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _result */ } /* "pywrapfst.pyx":1817 * 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":1799 * 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_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_3Fst_27num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_27num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1799, __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_3Fst_26num_input_epsilons(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self), ((int64)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_26num_input_epsilons(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations size_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("num_input_epsilons", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_3Fst_num_input_epsilons(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1799, __pyx_L1_error) __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1799, __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":1819 * return _result * * cpdef size_t num_output_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<< * """ * num_output_epsilons(self, state) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_29num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static size_t __pyx_f_9pywrapfst_3Fst_num_output_epsilons(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, 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; size_t __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_output_epsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_29num_output_epsilons)) { __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1819, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1819, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1834 * FstIndexError: State index out of range. * """ * 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, 1834, __pyx_L1_error) } __pyx_v__result = __pyx_v_self->_fst.get()->NumOutputEpsilons(__pyx_v_state); /* "pywrapfst.pyx":1835 * """ * cdef size_t _result = self._fst.get().NumOutputEpsilons(state) * if _result == SIZE_MAX: # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _result */ __pyx_t_7 = ((__pyx_v__result == SIZE_MAX) != 0); if (unlikely(__pyx_t_7)) { /* "pywrapfst.pyx":1836 * cdef size_t _result = self._fst.get().NumOutputEpsilons(state) * if _result == SIZE_MAX: * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< * return _result * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1836, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1836, __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, 1836, __pyx_L1_error) /* "pywrapfst.pyx":1835 * """ * cdef size_t _result = self._fst.get().NumOutputEpsilons(state) * if _result == SIZE_MAX: # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * return _result */ } /* "pywrapfst.pyx":1837 * if _result == SIZE_MAX: * raise FstIndexError("State index out of range") * return _result # <<<<<<<<<<<<<< * * cpdef _FstSymbolTableView output_symbols(self): */ __pyx_r = __pyx_v__result; goto __pyx_L0; /* "pywrapfst.pyx":1819 * 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_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_3Fst_29num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_29num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1819, __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_3Fst_28num_output_epsilons(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self), ((int64)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_28num_output_epsilons(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int64 __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations size_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("num_output_epsilons", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_3Fst_num_output_epsilons(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1819, __pyx_L1_error) __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1819, __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":1839 * return _result * * cpdef _FstSymbolTableView output_symbols(self): # <<<<<<<<<<<<<< * """ * output_symbols(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_31output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static struct __pyx_obj_9pywrapfst__FstSymbolTableView *__pyx_f_9pywrapfst_3Fst_output_symbols(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch) { struct __pyx_obj_9pywrapfst__FstSymbolTableView *__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1839, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1839, __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__FstSymbolTableView))))) __PYX_ERR(0, 1839, __pyx_L1_error) __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1845 * Returns the FST's output symbol table, or None if none is present. * """ * if self._fst.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_FstSymbolTableView(self._fst, input_side=False) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1845, __pyx_L1_error) } __pyx_t_5 = ((__pyx_v_self->_fst.get()->OutputSymbols() == NULL) != 0); if (__pyx_t_5) { /* "pywrapfst.pyx":1846 * """ * if self._fst.get().OutputSymbols() == NULL: * return # <<<<<<<<<<<<<< * return _init_FstSymbolTableView(self._fst, input_side=False) * */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)Py_None); __Pyx_INCREF(Py_None); goto __pyx_L0; /* "pywrapfst.pyx":1845 * Returns the FST's output symbol table, or None if none is present. * """ * if self._fst.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_FstSymbolTableView(self._fst, input_side=False) */ } /* "pywrapfst.pyx":1847 * if self._fst.get().OutputSymbols() == NULL: * return * return _init_FstSymbolTableView(self._fst, input_side=False) # <<<<<<<<<<<<<< * * cpdef string print(self, SymbolTableView isymbols=None, */ __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, 1847, __pyx_L1_error) } __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_FstSymbolTableView(__pyx_v_self->_fst, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1847, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1839 * return _result * * cpdef _FstSymbolTableView 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_3Fst_31output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_30output_symbols[] = "\n output_symbols(self)\n\n Returns the FST's output symbol table, or None if none is present.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_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_3Fst_30output_symbols(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_30output_symbols(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("output_symbols", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Fst_output_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1839, __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":1849 * return _init_FstSymbolTableView(self._fst, input_side=False) * * cpdef string print(self, SymbolTableView isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, * bool acceptor=False, bool show_weight_one=False, */ static PyObject *__pyx_pw_9pywrapfst_3Fst_33print(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static std::string __pyx_f_9pywrapfst_3Fst_print(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_3Fst_print *__pyx_optional_args) { struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1850 * * cpdef string print(self, SymbolTableView isymbols=None, * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, # <<<<<<<<<<<<<< * bool acceptor=False, bool show_weight_one=False, * missing_sym="") except *: */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1851 * cpdef string print(self, SymbolTableView isymbols=None, * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, * bool acceptor=False, bool show_weight_one=False, # <<<<<<<<<<<<<< * missing_sym="") except *: * """ */ bool __pyx_v_acceptor = ((bool)0); bool __pyx_v_show_weight_one = ((bool)0); PyObject *__pyx_v_missing_sym = ((PyObject *)__pyx_kp_u__11); fst::SymbolTable const *__pyx_v__isymbols; fst::SymbolTable const *__pyx_v__osymbols; fst::SymbolTable const *__pyx_v__ssymbols; 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 const *__pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("print", 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":1849 * return _init_FstSymbolTableView(self._fst, input_side=False) * * cpdef string print(self, SymbolTableView isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, * bool acceptor=False, bool show_weight_one=False, */ /* 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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_print); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_33print)) { __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_acceptor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1849, __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, 1849, __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, 1849, __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, 1849, __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, 1849, __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, 1849, __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, 1849, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1875 * """ * # Prints FST to stringstream, then returns resulting string. * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() # <<<<<<<<<<<<<< * if isymbols is not None: * _isymbols = isymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1875, __pyx_L1_error) } __pyx_v__isymbols = __pyx_v_self->_fst.get()->InputSymbols(); /* "pywrapfst.pyx":1876 * # Prints FST to stringstream, then returns resulting string. * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() * if isymbols is not None: # <<<<<<<<<<<<<< * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() */ __pyx_t_10 = (((PyObject *)__pyx_v_isymbols) != Py_None); __pyx_t_11 = (__pyx_t_10 != 0); if (__pyx_t_11) { /* "pywrapfst.pyx":1877 * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() * if isymbols is not None: * _isymbols = isymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: */ if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1877, __pyx_L1_error) } __pyx_t_12 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_isymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_isymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1877, __pyx_L1_error) __pyx_v__isymbols = __pyx_t_12; /* "pywrapfst.pyx":1876 * # Prints FST to stringstream, then returns resulting string. * cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() * if isymbols is not None: # <<<<<<<<<<<<<< * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() */ } /* "pywrapfst.pyx":1878 * if isymbols is not None: * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() # <<<<<<<<<<<<<< * if osymbols is not None: * _osymbols = osymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1878, __pyx_L1_error) } __pyx_v__osymbols = __pyx_v_self->_fst.get()->OutputSymbols(); /* "pywrapfst.pyx":1879 * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: # <<<<<<<<<<<<<< * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL */ __pyx_t_11 = (((PyObject *)__pyx_v_osymbols) != Py_None); __pyx_t_10 = (__pyx_t_11 != 0); if (__pyx_t_10) { /* "pywrapfst.pyx":1880 * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: * _osymbols = osymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1880, __pyx_L1_error) } __pyx_t_12 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_osymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_osymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1880, __pyx_L1_error) __pyx_v__osymbols = __pyx_t_12; /* "pywrapfst.pyx":1879 * _isymbols = isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() * if osymbols is not None: # <<<<<<<<<<<<<< * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL */ } /* "pywrapfst.pyx":1881 * if osymbols is not None: * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL # <<<<<<<<<<<<<< * if ssymbols is not None: * _ssymbols = ssymbols._raw_ptr_or_raise() */ __pyx_v__ssymbols = NULL; /* "pywrapfst.pyx":1882 * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL * if ssymbols is not None: # <<<<<<<<<<<<<< * _ssymbols = ssymbols._raw_ptr_or_raise() * 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":1883 * cdef const fst.SymbolTable *_ssymbols = NULL * if ssymbols is not None: * _ssymbols = ssymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef stringstream _sstrm * fst.Print(deref(self._fst), */ if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 1883, __pyx_L1_error) } __pyx_t_12 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_ssymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_ssymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1883, __pyx_L1_error) __pyx_v__ssymbols = __pyx_t_12; /* "pywrapfst.pyx":1882 * _osymbols = osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_ssymbols = NULL * if ssymbols is not None: # <<<<<<<<<<<<<< * _ssymbols = ssymbols._raw_ptr_or_raise() * cdef stringstream _sstrm */ } /* "pywrapfst.pyx":1885 * _ssymbols = ssymbols._raw_ptr_or_raise() * cdef stringstream _sstrm * fst.Print(deref(self._fst), # <<<<<<<<<<<<<< * _sstrm, * b"", */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1885, __pyx_L1_error) } /* "pywrapfst.pyx":1893 * acceptor, * show_weight_one, * tostring(missing_sym)) # <<<<<<<<<<<<<< * return _sstrm.str() * */ __pyx_t_9 = __pyx_f_9pywrapfst_tostring(__pyx_v_missing_sym); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1893, __pyx_L1_error) /* "pywrapfst.pyx":1885 * _ssymbols = ssymbols._raw_ptr_or_raise() * cdef stringstream _sstrm * fst.Print(deref(self._fst), # <<<<<<<<<<<<<< * _sstrm, * b"", */ fst::script::Print((*__pyx_v_self->_fst), __pyx_v__sstrm, __pyx_k_pywrapfst, __pyx_v__isymbols, __pyx_v__osymbols, __pyx_v__ssymbols, __pyx_v_acceptor, __pyx_v_show_weight_one, __pyx_t_9); /* "pywrapfst.pyx":1894 * show_weight_one, * tostring(missing_sym)) * return _sstrm.str() # <<<<<<<<<<<<<< * * def properties(self, mask, bool test): */ __pyx_r = __pyx_v__sstrm.str(); goto __pyx_L0; /* "pywrapfst.pyx":1849 * return _init_FstSymbolTableView(self._fst, input_side=False) * * cpdef string print(self, SymbolTableView isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, * bool acceptor=False, bool show_weight_one=False, */ /* 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.Fst.print", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_33print(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_32print[] = "\n print(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_3Fst_33print(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_isymbols = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_osymbols = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_ssymbols = 0; bool __pyx_v_acceptor; bool __pyx_v_show_weight_one; PyObject *__pyx_v_missing_sym = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("print (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_SymbolTableView *)Py_None); /* "pywrapfst.pyx":1850 * * cpdef string print(self, SymbolTableView isymbols=None, * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, # <<<<<<<<<<<<<< * bool acceptor=False, bool show_weight_one=False, * missing_sym="") except *: */ values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); values[5] = ((PyObject *)__pyx_kp_u__11); 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_isymbols); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_osymbols); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ssymbols); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_acceptor); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, "print") < 0)) __PYX_ERR(0, 1849, __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_SymbolTableView *)values[0]); __pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)values[1]); __pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)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, 1851, __pyx_L3_error) } else { /* "pywrapfst.pyx":1851 * cpdef string print(self, SymbolTableView isymbols=None, * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, * bool acceptor=False, bool show_weight_one=False, # <<<<<<<<<<<<<< * missing_sym="") except *: * """ */ __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, 1851, __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("print", 0, 0, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1849, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst.Fst.print", __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_SymbolTableView, 1, "isymbols", 0))) __PYX_ERR(0, 1849, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "osymbols", 0))) __PYX_ERR(0, 1850, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "ssymbols", 0))) __PYX_ERR(0, 1850, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_3Fst_32print(((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":1849 * return _init_FstSymbolTableView(self._fst, input_side=False) * * cpdef string print(self, SymbolTableView isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView osymbols=None, SymbolTableView ssymbols=None, * bool acceptor=False, bool show_weight_one=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_3Fst_32print(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTableView *__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_3Fst_print __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("print", 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->print(__pyx_v_self, 1, &__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1849, __pyx_L1_error) __pyx_t_3 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1849, __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.print", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":1896 * return _sstrm.str() * * def properties(self, mask, bool test): # <<<<<<<<<<<<<< * """ * properties(self, mask, test) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_35properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_34properties[] = "\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 FstProperties representing a 64-bit bitmask of the requested properties.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_35properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_mask = 0; bool __pyx_v_test; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_test)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("properties", 1, 2, 2, 1); __PYX_ERR(0, 1896, __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, 1896, __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 = values[0]; __pyx_v_test = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_test == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1896, __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, 1896, __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_3Fst_34properties(((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_3Fst_34properties(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, PyObject *__pyx_v_mask, bool __pyx_v_test) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; uint64 __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("properties", 0); /* "pywrapfst.pyx":1914 * A FstProperties representing a 64-bit bitmask of the requested properties. * """ * return FstProperties(self._fst.get().Properties(mask.value, test)) # <<<<<<<<<<<<<< * * @classmethod */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1914, __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"); __PYX_ERR(0, 1914, __pyx_L1_error) } __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_mask, __pyx_n_s_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_As_uint64_t(__pyx_t_3); if (unlikely((__pyx_t_4 == ((uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1914, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_fst.get()->Properties(__pyx_t_4, __pyx_v_test)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1914, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1896 * return _sstrm.str() * * def properties(self, 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_5); __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":1917 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * read(source) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_37read(PyObject *__pyx_v_cls, PyObject *__pyx_v_source); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_36read[] = "\n read(source)\n\n Reads an FST from a file.\n\n Args:\n source: The string location of the input file.\n\n Returns:\n An FST object.\n\n Raises:\n FstIOError: Read failed.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_37read(PyObject *__pyx_v_cls, PyObject *__pyx_v_source) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_36read(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_36read(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_source) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read", 0); /* "pywrapfst.pyx":1932 * FstIOError: Read failed. * """ * return _read_Fst(source) # <<<<<<<<<<<<<< * * @classmethod */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read_Fst(__pyx_v_source, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1932, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1917 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * read(source) */ /* 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":1935 * * @classmethod * def read_from_string(cls, state): # <<<<<<<<<<<<<< * """ * read_from_string(state) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_39read_from_string(PyObject *__pyx_v_cls, PyObject *__pyx_v_state); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_38read_from_string[] = "\n read_from_string(state)\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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_39read_from_string(PyObject *__pyx_v_cls, PyObject *__pyx_v_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("read_from_string (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_38read_from_string(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_38read_from_string(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("read_from_string", 0); /* "pywrapfst.pyx":1950 * FstIOError: Read failed. * """ * return _read_Fst_from_string(state) # <<<<<<<<<<<<<< * * cpdef int64 start(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_state); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1950, __pyx_L1_error) __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__read_Fst_from_string(__pyx_t_1, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1950, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1935 * * @classmethod * def read_from_string(cls, state): # <<<<<<<<<<<<<< * """ * read_from_string(state) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __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":1952 * return _read_Fst_from_string(state) * * cpdef int64 start(self): # <<<<<<<<<<<<<< * """ * start(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_41start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static int64 __pyx_f_9pywrapfst_3Fst_start(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch) { 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; int64 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1952, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_41start)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1952, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1952, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1958 * 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, 1958, __pyx_L1_error) } __pyx_r = __pyx_v_self->_fst.get()->Start(); goto __pyx_L0; /* "pywrapfst.pyx":1952 * return _read_Fst_from_string(state) * * 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_3Fst_41start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_40start[] = "\n start(self)\n\n Returns the start state.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_41start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("start (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_40start(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_40start(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("start", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_3Fst_start(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1952, __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":1960 * return self._fst.get().Start() * * cpdef StateIterator states(self): # <<<<<<<<<<<<<< * """ * states(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_43states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static struct __pyx_obj_9pywrapfst_StateIterator *__pyx_f_9pywrapfst_3Fst_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1960, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_43states)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1960, __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, 1960, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1969 * A StateIterator object for the FST. * """ * return StateIterator(self) # <<<<<<<<<<<<<< * * cpdef bool verify(self): */ __Pyx_XDECREF(((PyObject *)__pyx_r)); __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pywrapfst_StateIterator), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":1960 * 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_3Fst_43states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_42states[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_3Fst_43states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("states (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_42states(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_42states(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("states", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Fst_states(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1960, __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":1971 * return StateIterator(self) * * cpdef bool verify(self): # <<<<<<<<<<<<<< * """ * verify(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_45verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static bool __pyx_f_9pywrapfst_3Fst_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_verify); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_45verify)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1971, __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, 1971, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1980 * 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, 1980, __pyx_L1_error) } __pyx_r = fst::script::Verify((*__pyx_v_self->_fst)); goto __pyx_L0; /* "pywrapfst.pyx":1971 * return StateIterator(self) * * 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_3Fst_45verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_44verify[] = "\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_3Fst_45verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("verify (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_44verify(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_44verify(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("verify", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_3Fst_verify(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1971, __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":1982 * return fst.Verify(deref(self._fst)) * * cpdef string weight_type(self): # <<<<<<<<<<<<<< * """ * weight_type(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_47weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static std::string __pyx_f_9pywrapfst_3Fst_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1982, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_47weight_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1982, __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, 1982, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":1991 * A string representing the weight type. * """ * return self._fst.get().WeightType() # <<<<<<<<<<<<<< * * cpdef void write(self, source) except *: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 1991, __pyx_L1_error) } __pyx_r = __pyx_v_self->_fst.get()->WeightType(); goto __pyx_L0; /* "pywrapfst.pyx":1982 * 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_3Fst_47weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_46weight_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_3Fst_47weight_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_3Fst_46weight_type(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_46weight_type(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("weight_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_3Fst_weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1982, __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":1993 * return self._fst.get().WeightType() * * cpdef void write(self, source) except *: # <<<<<<<<<<<<<< * """ * write(self, source) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_49write(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static void __pyx_f_9pywrapfst_3Fst_write(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, PyObject *__pyx_v_source, 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; std::string __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_49write)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_source) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_source); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1993, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":2007 * FstIOError: Write failed. * """ * if not self._fst.get().Write(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2007, __pyx_L1_error) } __pyx_t_5 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2007, __pyx_L1_error) __pyx_t_6 = ((!(__pyx_v_self->_fst.get()->Write(__pyx_t_5) != 0)) != 0); if (unlikely(__pyx_t_6)) { /* "pywrapfst.pyx":2008 * """ * if not self._fst.get().Write(path_tostring(source)): * raise FstIOError(f"Write failed: {source!r}") # <<<<<<<<<<<<<< * * cpdef bytes write_to_string(self): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2008, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2008, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Write_failed, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2008, __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 && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2008, __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, 2008, __pyx_L1_error) /* "pywrapfst.pyx":2007 * FstIOError: Write failed. * """ * if not self._fst.get().Write(path_tostring(source)): # <<<<<<<<<<<<<< * raise FstIOError(f"Write failed: {source!r}") * */ } /* "pywrapfst.pyx":1993 * return self._fst.get().WeightType() * * cpdef void write(self, source) except *: # <<<<<<<<<<<<<< * """ * write(self, source) */ /* 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_AddTraceback("pywrapfst.Fst.write", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_3Fst_49write(PyObject *__pyx_v_self, PyObject *__pyx_v_source); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_48write[] = "\n write(self, source)\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 source: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_49write(PyObject *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("write (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_3Fst_48write(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self), ((PyObject *)__pyx_v_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_48write(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write", 0); __Pyx_XDECREF(__pyx_r); __pyx_f_9pywrapfst_3Fst_write(__pyx_v_self, __pyx_v_source, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1993, __pyx_L1_error) __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1993, __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":2010 * raise FstIOError(f"Write failed: {source!r}") * * cpdef bytes write_to_string(self): # <<<<<<<<<<<<<< * """ * write_to_string(self) */ static PyObject *__pyx_pw_9pywrapfst_3Fst_51write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_f_9pywrapfst_3Fst_write_to_string(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self, int __pyx_skip_dispatch) { std::stringstream __pyx_v__sstrm; 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; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write_to_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2010, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_3Fst_51write_to_string)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2010, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!(likely(PyBytes_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 2010, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":2023 * """ * cdef stringstream _sstrm * if not self._fst.get().Write(_sstrm, b""): # <<<<<<<<<<<<<< * 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, 2023, __pyx_L1_error) } __pyx_t_5 = ((!(__pyx_v_self->_fst.get()->Write(__pyx_v__sstrm, __pyx_k_pywrapfst) != 0)) != 0); if (unlikely(__pyx_t_5)) { /* "pywrapfst.pyx":2024 * cdef stringstream _sstrm * if not self._fst.get().Write(_sstrm, b""): * raise FstIOError("Write to string failed") # <<<<<<<<<<<<<< * return _sstrm.str() * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2024, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_Write_to_string_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_Write_to_string_failed); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2024, __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, 2024, __pyx_L1_error) /* "pywrapfst.pyx":2023 * """ * cdef stringstream _sstrm * if not self._fst.get().Write(_sstrm, b""): # <<<<<<<<<<<<<< * raise FstIOError("Write to string failed") * return _sstrm.str() */ } /* "pywrapfst.pyx":2025 * if not self._fst.get().Write(_sstrm, b""): * raise FstIOError("Write to string failed") * return _sstrm.str() # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v__sstrm.str()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":2010 * raise FstIOError(f"Write failed: {source!r}") * * cpdef bytes 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_AddTraceback("pywrapfst.Fst.write_to_string", __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_3Fst_51write_to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_3Fst_50write_to_string[] = "\n write_to_string(self)\n\n Serializes FST to a string.\n\n Returns:\n A bytestring.\n\n Raises:\n FstIOError: Write to string failed.\n "; static PyObject *__pyx_pw_9pywrapfst_3Fst_51write_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_3Fst_50write_to_string(((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_3Fst_50write_to_string(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("write_to_string", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_9pywrapfst_3Fst_write_to_string(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2010, __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":2038 * """ * * cdef void _check_mutating_imethod(self) except *: # <<<<<<<<<<<<<< * """Checks whether an operation mutating the FST has produced an error. * */ static void __pyx_f_9pywrapfst_10MutableFst__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; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_check_mutating_imethod", 0); /* "pywrapfst.pyx":2043 * 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 (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2043, __pyx_L1_error) } __pyx_t_1 = ((__pyx_v_self->__pyx_base._fst.get()->Properties(fst::kError, 1) == fst::kError) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2044 * """ * 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): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Operation_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Operation_failed); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2044, __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, 2044, __pyx_L1_error) /* "pywrapfst.pyx":2043 * 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 *: */ } /* "pywrapfst.pyx":2038 * """ * * 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_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.MutableFst._check_mutating_imethod", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2045 * 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") */ static void __pyx_f_9pywrapfst_10MutableFst__add_arc(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, 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; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_add_arc", 0); /* "pywrapfst.pyx":2046 * 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)): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2046, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_self->__pyx_base._fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2047 * 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2047, __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, 2047, __pyx_L1_error) /* "pywrapfst.pyx":2046 * 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)): */ } /* "pywrapfst.pyx":2048 * 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") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2048, __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, 2048, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->AddArc(__pyx_v_state, (*__pyx_v_arc->_arc)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2049 * raise FstIndexError("State index out of range") * if not self._mfst.get().AddArc(state, deref(arc._arc)): * raise FstOpError("Incompatible or invalid weight type") # <<<<<<<<<<<<<< * * def add_arc(self, int64 state, Arc arc): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Incompatible_or_invalid_weight_t) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Incompatible_or_invalid_weight_t); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2049, __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, 2049, __pyx_L1_error) /* "pywrapfst.pyx":2048 * 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") * */ } /* "pywrapfst.pyx":2045 * 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") */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.MutableFst._add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2051 * raise FstOpError("Incompatible or invalid weight type") * * def add_arc(self, int64 state, Arc arc): # <<<<<<<<<<<<<< * """ * add_arc(self, state, arc) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_1add_arc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_1add_arc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64 __pyx_v_state; struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arc)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("add_arc", 1, 2, 2, 1); __PYX_ERR(0, 2051, __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, 2051, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2051, __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, 2051, __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, 2051, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_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_10MutableFst_add_arc(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_arc", 0); /* "pywrapfst.pyx":2068 * FstOpdexError: Incompatible or invalid weight type. * """ * 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, 2068, __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, 2068, __pyx_L1_error) /* "pywrapfst.pyx":2069 * """ * self._add_arc(state, arc) * return self # <<<<<<<<<<<<<< * * cpdef int64 add_state(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2051 * raise FstOpError("Incompatible or invalid weight type") * * 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":2071 * return self * * cpdef int64 add_state(self): # <<<<<<<<<<<<<< * """ * add_state(self) */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static int64 __pyx_f_9pywrapfst_10MutableFst_add_state(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int __pyx_skip_dispatch) { 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; int64 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_10MutableFst_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2071, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2071, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":2080 * The integer index of the new state. * """ * return self._mfst.get().AddState() # <<<<<<<<<<<<<< * * cpdef void add_states(self, size_t n): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2080, __pyx_L1_error) } __pyx_r = __pyx_v_self->_mfst.get()->AddState(); goto __pyx_L0; /* "pywrapfst.pyx":2071 * return self * * cpdef int64 add_state(self): # <<<<<<<<<<<<<< * """ * 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_WriteUnraisable("pywrapfst.MutableFst.add_state", __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_10MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_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_10MutableFst_2add_state(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_2add_state(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_state", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_10MutableFst_add_state(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2071, __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.add_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":2082 * return self._mfst.get().AddState() * * cpdef void add_states(self, size_t n): # <<<<<<<<<<<<<< * """ * add_states(self, n) */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_5add_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n); /*proto*/ static void __pyx_f_9pywrapfst_10MutableFst_add_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, size_t __pyx_v_n, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_10MutableFst_5add_states)) { __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2082, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2082, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":2091 * n: The number of states to add. * """ * self._mfst.get().AddStates(n) # <<<<<<<<<<<<<< * * cdef void _arcsort(self, sort_type="ilabel") except *: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2091, __pyx_L1_error) } __pyx_v_self->_mfst.get()->AddStates(__pyx_v_n); /* "pywrapfst.pyx":2082 * return self._mfst.get().AddState() * * cpdef void add_states(self, size_t n): # <<<<<<<<<<<<<< * """ * add_states(self, n) */ /* 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.MutableFst.add_states", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_5add_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_4add_states[] = "\n add_states(self, n)\n\n Adds n new states to the FST.\n\n Args:\n n: The number of states to add.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_5add_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n) { size_t __pyx_v_n; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add_states (wrapper)", 0); assert(__pyx_arg_n); { __pyx_v_n = __Pyx_PyInt_As_size_t(__pyx_arg_n); if (unlikely((__pyx_v_n == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2082, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst.MutableFst.add_states", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_4add_states(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((size_t)__pyx_v_n)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_4add_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, size_t __pyx_v_n) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_states", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_10MutableFst_add_states(__pyx_v_self, __pyx_v_n, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2082, __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.add_states", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":2093 * self._mfst.get().AddStates(n) * * cdef void _arcsort(self, sort_type="ilabel") except *: # <<<<<<<<<<<<<< * cdef fst.ArcSortType _sort_type * if not fst.GetArcSortType(tostring(sort_type), addr(_sort_type)): */ static void __pyx_f_9pywrapfst_10MutableFst__arcsort(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__arcsort *__pyx_optional_args) { PyObject *__pyx_v_sort_type = ((PyObject *)__pyx_n_u_ilabel); enum fst::script::ArcSortType __pyx_v__sort_type; __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2095 * cdef void _arcsort(self, sort_type="ilabel") except *: * cdef fst.ArcSortType _sort_type * if not fst.GetArcSortType(tostring(sort_type), addr(_sort_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown sort type: {sort_type!r}") * fst.ArcSort(self._mfst.get(), _sort_type) */ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_sort_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2095, __pyx_L1_error) __pyx_t_2 = ((!(fst::script::GetArcSortType(__pyx_t_1, (&__pyx_v__sort_type)) != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":2096 * cdef fst.ArcSortType _sort_type * if not fst.GetArcSortType(tostring(sort_type), addr(_sort_type)): * raise FstArgError(f"Unknown sort type: {sort_type!r}") # <<<<<<<<<<<<<< * fst.ArcSort(self._mfst.get(), _sort_type) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_sort_type), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_sort_type, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2096, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 2096, __pyx_L1_error) /* "pywrapfst.pyx":2095 * cdef void _arcsort(self, sort_type="ilabel") except *: * cdef fst.ArcSortType _sort_type * if not fst.GetArcSortType(tostring(sort_type), addr(_sort_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown sort type: {sort_type!r}") * fst.ArcSort(self._mfst.get(), _sort_type) */ } /* "pywrapfst.pyx":2097 * if not fst.GetArcSortType(tostring(sort_type), addr(_sort_type)): * raise FstArgError(f"Unknown sort type: {sort_type!r}") * fst.ArcSort(self._mfst.get(), _sort_type) # <<<<<<<<<<<<<< * * def arcsort(self, sort_type="ilabel"): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2097, __pyx_L1_error) } fst::script::ArcSort(__pyx_v_self->_mfst.get(), __pyx_v__sort_type); /* "pywrapfst.pyx":2093 * self._mfst.get().AddStates(n) * * cdef void _arcsort(self, sort_type="ilabel") except *: # <<<<<<<<<<<<<< * cdef fst.ArcSortType _sort_type * if not fst.GetArcSortType(tostring(sort_type), addr(_sort_type)): */ /* 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_AddTraceback("pywrapfst.MutableFst._arcsort", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2099 * fst.ArcSort(self._mfst.get(), _sort_type) * * def arcsort(self, sort_type="ilabel"): # <<<<<<<<<<<<<< * """ * arcsort(self, sort_type="ilabel") */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_7arcsort(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_6arcsort[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_7arcsort(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_sort_type = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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_u_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 = __Pyx_PyDict_GetItemStr(__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, 2099, __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, 2099, __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_10MutableFst_6arcsort(((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_10MutableFst_6arcsort(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_sort_type) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst_10MutableFst__arcsort __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("arcsort", 0); /* "pywrapfst.pyx":2118 * FstArgError: Unknown sort type. * """ * 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, 2118, __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, 2118, __pyx_L1_error) /* "pywrapfst.pyx":2119 * """ * self._arcsort(sort_type) * return self # <<<<<<<<<<<<<< * * cdef void _closure(self, bool closure_plus=False): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2099 * fst.ArcSort(self._mfst.get(), _sort_type) * * def arcsort(self, sort_type="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":2121 * return self * * cdef void _closure(self, bool closure_plus=False): # <<<<<<<<<<<<<< * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) * */ static void __pyx_f_9pywrapfst_10MutableFst__closure(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__closure *__pyx_optional_args) { bool __pyx_v_closure_plus = ((bool)0); __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2122 * * cdef void _closure(self, bool closure_plus=False): * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) # <<<<<<<<<<<<<< * * 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'", "_mfst"); __PYX_ERR(0, 2122, __pyx_L1_error) } fst::script::Closure(__pyx_v_self->_mfst.get(), fst::script::GetClosureType(__pyx_v_closure_plus)); /* "pywrapfst.pyx":2121 * return self * * cdef void _closure(self, bool closure_plus=False): # <<<<<<<<<<<<<< * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst.MutableFst._closure", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2124 * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) * * def closure(self, bool closure_plus=False): # <<<<<<<<<<<<<< * """ * closure(self, closure_plus=False) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_9closure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_8closure[] = "\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_10MutableFst_9closure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { bool __pyx_v_closure_plus; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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 = __Pyx_PyDict_GetItemStr(__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, 2124, __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, 2124, __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, 2124, __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_10MutableFst_8closure(((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_10MutableFst_8closure(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, bool __pyx_v_closure_plus) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst_10MutableFst__closure __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("closure", 0); /* "pywrapfst.pyx":2142 * 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, 2142, __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); /* "pywrapfst.pyx":2143 * """ * self._closure(closure_plus) * return self # <<<<<<<<<<<<<< * * cdef void _concat(self, Fst fst2) except *: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2124 * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) * * 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":2145 * return self * * cdef void _concat(self, Fst fst2) except *: # <<<<<<<<<<<<<< * fst.Concat(self._mfst.get(), deref(fst2._fst)) * self._check_mutating_imethod() */ static void __pyx_f_9pywrapfst_10MutableFst__concat(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_fst2) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_concat", 0); /* "pywrapfst.pyx":2146 * * cdef void _concat(self, Fst fst2) except *: * fst.Concat(self._mfst.get(), deref(fst2._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, 2146, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_fst2) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2146, __pyx_L1_error) } fst::script::Concat(__pyx_v_self->_mfst.get(), (*__pyx_v_fst2->_fst)); /* "pywrapfst.pyx":2147 * cdef void _concat(self, Fst fst2) except *: * fst.Concat(self._mfst.get(), deref(fst2._fst)) * self._check_mutating_imethod() # <<<<<<<<<<<<<< * * def concat(self, Fst fst2): */ 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 * * cdef void _concat(self, Fst fst2) except *: # <<<<<<<<<<<<<< * fst.Concat(self._mfst.get(), deref(fst2._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":2149 * self._check_mutating_imethod() * * def concat(self, Fst fst2): # <<<<<<<<<<<<<< * """ * concat(self, fst2) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_11concat(PyObject *__pyx_v_self, PyObject *__pyx_v_fst2); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_10concat[] = "\n concat(self, fst2)\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 fst2: The second input FST.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_11concat(PyObject *__pyx_v_self, PyObject *__pyx_v_fst2) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("concat (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_fst2), __pyx_ptype_9pywrapfst_Fst, 1, "fst2", 0))) __PYX_ERR(0, 2149, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_10concat(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_Fst *)__pyx_v_fst2)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_10concat(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_fst2) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("concat", 0); /* "pywrapfst.pyx":2166 * self. * """ * self._concat(fst2) # <<<<<<<<<<<<<< * return self * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_concat"); __PYX_ERR(0, 2166, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_concat(__pyx_v_self, __pyx_v_fst2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2166, __pyx_L1_error) /* "pywrapfst.pyx":2167 * """ * self._concat(fst2) * return self # <<<<<<<<<<<<<< * * cdef void _connect(self): */ __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 concat(self, Fst fst2): # <<<<<<<<<<<<<< * """ * concat(self, fst2) */ /* 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":2169 * return self * * cdef void _connect(self): # <<<<<<<<<<<<<< * fst.Connect(self._mfst.get()) * */ static void __pyx_f_9pywrapfst_10MutableFst__connect(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_connect", 0); /* "pywrapfst.pyx":2170 * * cdef void _connect(self): * fst.Connect(self._mfst.get()) # <<<<<<<<<<<<<< * * def connect(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2170, __pyx_L1_error) } fst::script::Connect(__pyx_v_self->_mfst.get()); /* "pywrapfst.pyx":2169 * return self * * cdef void _connect(self): # <<<<<<<<<<<<<< * fst.Connect(self._mfst.get()) * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst.MutableFst._connect", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2172 * fst.Connect(self._mfst.get()) * * def connect(self): # <<<<<<<<<<<<<< * """ * connect(self) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_13connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_12connect[] = "\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_10MutableFst_13connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("connect (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_12connect(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_12connect(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("connect", 0); /* "pywrapfst.pyx":2184 * 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, 2184, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_connect(__pyx_v_self); /* "pywrapfst.pyx":2185 * """ * self._connect() * return self # <<<<<<<<<<<<<< * * cdef void _decode(self, EncodeMapper mapper) except *: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2172 * fst.Connect(self._mfst.get()) * * 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":2187 * return self * * cdef void _decode(self, EncodeMapper mapper) except *: # <<<<<<<<<<<<<< * fst.Decode(self._mfst.get(), deref(mapper._mapper)) * self._check_mutating_imethod() */ static void __pyx_f_9pywrapfst_10MutableFst__decode(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_mapper) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_decode", 0); /* "pywrapfst.pyx":2188 * * cdef void _decode(self, EncodeMapper mapper) except *: * fst.Decode(self._mfst.get(), deref(mapper._mapper)) # <<<<<<<<<<<<<< * 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, 2188, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_mapper) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 2188, __pyx_L1_error) } fst::script::Decode(__pyx_v_self->_mfst.get(), (*__pyx_v_mapper->_mapper)); /* "pywrapfst.pyx":2189 * cdef void _decode(self, EncodeMapper mapper) except *: * fst.Decode(self._mfst.get(), deref(mapper._mapper)) * self._check_mutating_imethod() # <<<<<<<<<<<<<< * * def decode(self, EncodeMapper mapper): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); __PYX_ERR(0, 2189, __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, 2189, __pyx_L1_error) /* "pywrapfst.pyx":2187 * return self * * cdef void _decode(self, EncodeMapper mapper) except *: # <<<<<<<<<<<<<< * fst.Decode(self._mfst.get(), deref(mapper._mapper)) * 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":2191 * self._check_mutating_imethod() * * def decode(self, EncodeMapper mapper): # <<<<<<<<<<<<<< * """ * decode(self, mapper) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_15decode(PyObject *__pyx_v_self, PyObject *__pyx_v_mapper); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_14decode[] = "\n decode(self, mapper)\n\n Decodes encoded labels and/or weights.\n\n This operation reverses the encoding performed by `encode`.\n\n Args:\n mapper: An EncodeMapper object used to encode the FST.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_15decode(PyObject *__pyx_v_self, PyObject *__pyx_v_mapper) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("decode (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mapper), __pyx_ptype_9pywrapfst_EncodeMapper, 1, "mapper", 0))) __PYX_ERR(0, 2191, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_14decode(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_mapper)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_14decode(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_mapper) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("decode", 0); /* "pywrapfst.pyx":2205 * self. * """ * self._decode(mapper) # <<<<<<<<<<<<<< * return self * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_decode"); __PYX_ERR(0, 2205, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_decode(__pyx_v_self, __pyx_v_mapper); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2205, __pyx_L1_error) /* "pywrapfst.pyx":2206 * """ * self._decode(mapper) * 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":2191 * self._check_mutating_imethod() * * def decode(self, EncodeMapper mapper): # <<<<<<<<<<<<<< * """ * decode(self, mapper) */ /* 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":2208 * 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_10MutableFst__delete_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_10MutableFst__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; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2209 * * 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, 2209, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_mfst.get()->DeleteArcs(__pyx_v_state, __pyx_v_n); } else { /* "pywrapfst.pyx":2210 * 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, 2210, __pyx_L1_error) } __pyx_t_1 = __pyx_v_self->_mfst.get()->DeleteArcs(__pyx_v_state); } /* "pywrapfst.pyx":2209 * * 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 (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":2211 * 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_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 2211, __pyx_L1_error) /* "pywrapfst.pyx":2209 * * 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":2212 * 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, 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":2208 * 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_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pywrapfst.MutableFst._delete_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2214 * 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_10MutableFst_17delete_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_16delete_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_17delete_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64 __pyx_v_state; size_t __pyx_v_n; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 2214, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2214, __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, 2214, __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, 2214, __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_10MutableFst_16delete_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_10MutableFst_16delete_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, size_t __pyx_v_n) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_arcs __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("delete_arcs", 0); /* "pywrapfst.pyx":2232 * FstIndexError: State index out of range. * """ * 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, 2232, __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, 2232, __pyx_L1_error) /* "pywrapfst.pyx":2233 * """ * 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":2214 * 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":2235 * 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_10MutableFst__delete_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_states *__pyx_optional_args) { PyObject *__pyx_v_states = ((PyObject *)Py_None); __Pyx_RefNannyDeclarations int __pyx_t_1; std::vector __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2237 * 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, 2237, __pyx_L1_error) if (__pyx_t_1) { /* "pywrapfst.pyx":2238 * # 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, 2238, __pyx_L1_error) } __pyx_t_2 = __pyx_convert_vector_from_py_int64(__pyx_v_states); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2238, __pyx_L1_error) __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->DeleteStates(((std::vector const )__pyx_t_2)) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2239 * if states: * if not self._mfst.get().DeleteStates( states): * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< * else: * self._mfst.get().DeleteStates() */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 2239, __pyx_L1_error) /* "pywrapfst.pyx":2238 * # 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":2237 * 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":2241 * 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, 2241, __pyx_L1_error) } __pyx_v_self->_mfst.get()->DeleteStates(); } __pyx_L3:; /* "pywrapfst.pyx":2242 * 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, 2242, __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, 2242, __pyx_L1_error) /* "pywrapfst.pyx":2235 * 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_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pywrapfst.MutableFst._delete_states", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2244 * self._check_mutating_imethod() * * def delete_states(self, states=None): # <<<<<<<<<<<<<< * """ * delete_states(self, states=None) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_19delete_states(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_18delete_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_19delete_states(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_states = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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 = __Pyx_PyDict_GetItemStr(__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, 2244, __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, 2244, __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_10MutableFst_18delete_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_10MutableFst_18delete_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_states) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_states __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("delete_states", 0); /* "pywrapfst.pyx":2260 * FstIndexError: State index out of range. * """ * 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, 2260, __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, 2260, __pyx_L1_error) /* "pywrapfst.pyx":2261 * """ * self._delete_states(states) * return self # <<<<<<<<<<<<<< * * cdef void _encode(self, EncodeMapper mapper) except *: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2244 * 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":2263 * return self * * cdef void _encode(self, EncodeMapper mapper) except *: # <<<<<<<<<<<<<< * fst.Encode(self._mfst.get(), mapper._mapper.get()) * self._check_mutating_imethod() */ static void __pyx_f_9pywrapfst_10MutableFst__encode(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_mapper) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_encode", 0); /* "pywrapfst.pyx":2264 * * cdef void _encode(self, EncodeMapper mapper) except *: * fst.Encode(self._mfst.get(), mapper._mapper.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, 2264, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_mapper) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mapper"); __PYX_ERR(0, 2264, __pyx_L1_error) } fst::script::Encode(__pyx_v_self->_mfst.get(), __pyx_v_mapper->_mapper.get()); /* "pywrapfst.pyx":2265 * cdef void _encode(self, EncodeMapper mapper) except *: * fst.Encode(self._mfst.get(), mapper._mapper.get()) * self._check_mutating_imethod() # <<<<<<<<<<<<<< * * def encode(self, EncodeMapper mapper): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_check_mutating_imethod"); __PYX_ERR(0, 2265, __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, 2265, __pyx_L1_error) /* "pywrapfst.pyx":2263 * return self * * cdef void _encode(self, EncodeMapper mapper) except *: # <<<<<<<<<<<<<< * fst.Encode(self._mfst.get(), mapper._mapper.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":2267 * self._check_mutating_imethod() * * def encode(self, EncodeMapper mapper): # <<<<<<<<<<<<<< * """ * encode(self, mapper) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_21encode(PyObject *__pyx_v_self, PyObject *__pyx_v_mapper); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_20encode[] = "\n encode(self, mapper)\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 mapper: An EncodeMapper object to be used as the mapper.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_21encode(PyObject *__pyx_v_self, PyObject *__pyx_v_mapper) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("encode (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mapper), __pyx_ptype_9pywrapfst_EncodeMapper, 1, "mapper", 0))) __PYX_ERR(0, 2267, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_20encode(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_mapper)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_20encode(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_mapper) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("encode", 0); /* "pywrapfst.pyx":2286 * self. * """ * self._encode(mapper) # <<<<<<<<<<<<<< * return self * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_encode"); __PYX_ERR(0, 2286, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_encode(__pyx_v_self, __pyx_v_mapper); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2286, __pyx_L1_error) /* "pywrapfst.pyx":2287 * """ * self._encode(mapper) * return self # <<<<<<<<<<<<<< * * cdef void _invert(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2267 * self._check_mutating_imethod() * * def encode(self, EncodeMapper mapper): # <<<<<<<<<<<<<< * """ * encode(self, mapper) */ /* 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":2289 * return self * * cdef void _invert(self): # <<<<<<<<<<<<<< * fst.Invert(self._mfst.get()) * */ static void __pyx_f_9pywrapfst_10MutableFst__invert(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_invert", 0); /* "pywrapfst.pyx":2290 * * cdef void _invert(self): * fst.Invert(self._mfst.get()) # <<<<<<<<<<<<<< * * def invert(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2290, __pyx_L1_error) } fst::script::Invert(__pyx_v_self->_mfst.get()); /* "pywrapfst.pyx":2289 * return self * * cdef void _invert(self): # <<<<<<<<<<<<<< * fst.Invert(self._mfst.get()) * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst.MutableFst._invert", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2292 * fst.Invert(self._mfst.get()) * * def invert(self): # <<<<<<<<<<<<<< * """ * invert(self) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_23invert(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_22invert[] = "\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_10MutableFst_23invert(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invert (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_22invert(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_22invert(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invert", 0); /* "pywrapfst.pyx":2304 * 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, 2304, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_invert(__pyx_v_self); /* "pywrapfst.pyx":2305 * """ * self._invert() * return self # <<<<<<<<<<<<<< * * cdef void _minimize(self, */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2292 * fst.Invert(self._mfst.get()) * * 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":2307 * return self * * cdef void _minimize(self, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * bool allow_nondet=False) except *: */ static void __pyx_f_9pywrapfst_10MutableFst__minimize(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__minimize *__pyx_optional_args) { float __pyx_v_delta = __pyx_k__12; /* "pywrapfst.pyx":2309 * 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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2311 * 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, 2311, __pyx_L1_error) } fst::script::Minimize(__pyx_v_self->_mfst.get(), NULL, __pyx_v_delta, __pyx_v_allow_nondet); /* "pywrapfst.pyx":2312 * # 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, 2312, __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, 2312, __pyx_L1_error) /* "pywrapfst.pyx":2307 * return self * * cdef void _minimize(self, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * bool allow_nondet=False) except *: */ /* 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":2314 * 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_10MutableFst_25minimize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_24minimize[] = "\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_10MutableFst_25minimize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { float __pyx_v_delta; bool __pyx_v_allow_nondet; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 2314, __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, 2314, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__13; } 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, 2314, __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, 2314, __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_10MutableFst_24minimize(((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_10MutableFst_24minimize(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_10MutableFst__minimize __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("minimize", 0); /* "pywrapfst.pyx":2340 * 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, 2340, __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, 2340, __pyx_L1_error) /* "pywrapfst.pyx":2341 * """ * 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":2314 * 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":2343 * return self * * cpdef MutableArcIterator mutable_arcs(self, int64 state): # <<<<<<<<<<<<<< * """ * mutable_arcs(self, state) */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_27mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_f_9pywrapfst_10MutableFst_mutable_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_mutable_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_10MutableFst_27mutable_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, 2343, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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, 2343, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":2355 * A MutableArcIterator. * """ * 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, 2355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2355, __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, 2355, __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":2343 * 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_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_10MutableFst_27mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_26mutable_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_27mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2343, __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_10MutableFst_26mutable_arcs(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((int64)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_26mutable_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("mutable_arcs", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_10MutableFst_mutable_arcs(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2343, __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":2357 * return MutableArcIterator(self, state) * * def mutable_input_symbols(self): # <<<<<<<<<<<<<< * """ * mutable_input_symbols(self) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_29mutable_input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_28mutable_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_10MutableFst_29mutable_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_10MutableFst_28mutable_input_symbols(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_28mutable_input_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("mutable_input_symbols", 0); /* "pywrapfst.pyx":2363 * Returns the FST's (mutable) input symbol table, or None if none is present. * """ * if self._mfst.get().MutableInputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_MutableFstSymbolTableView(self._mfst, input_side=True) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2363, __pyx_L1_error) } __pyx_t_1 = ((__pyx_v_self->_mfst.get()->MutableInputSymbols() == NULL) != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":2364 * """ * if self._mfst.get().MutableInputSymbols() == NULL: * return # <<<<<<<<<<<<<< * return _init_MutableFstSymbolTableView(self._mfst, input_side=True) * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "pywrapfst.pyx":2363 * Returns the FST's (mutable) input symbol table, or None if none is present. * """ * if self._mfst.get().MutableInputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_MutableFstSymbolTableView(self._mfst, input_side=True) */ } /* "pywrapfst.pyx":2365 * if self._mfst.get().MutableInputSymbols() == NULL: * return * return _init_MutableFstSymbolTableView(self._mfst, input_side=True) # <<<<<<<<<<<<<< * * 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, 2365, __pyx_L1_error) } __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFstSymbolTableView(__pyx_v_self->_mfst, 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":2357 * 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":2367 * return _init_MutableFstSymbolTableView(self._mfst, input_side=True) * * def mutable_output_symbols(self): # <<<<<<<<<<<<<< * """ * mutable_output_symbols(self) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_31mutable_output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_30mutable_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_10MutableFst_31mutable_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_10MutableFst_30mutable_output_symbols(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_30mutable_output_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("mutable_output_symbols", 0); /* "pywrapfst.pyx":2373 * Returns the FST's (mutable) output symbol table, or None if none is present. * """ * if self._mfst.get().MutableOutputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_MutableFstSymbolTableView(self._mfst, input_side=False) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2373, __pyx_L1_error) } __pyx_t_1 = ((__pyx_v_self->_mfst.get()->MutableOutputSymbols() == NULL) != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":2374 * """ * if self._mfst.get().MutableOutputSymbols() == NULL: * return # <<<<<<<<<<<<<< * return _init_MutableFstSymbolTableView(self._mfst, input_side=False) * */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "pywrapfst.pyx":2373 * Returns the FST's (mutable) output symbol table, or None if none is present. * """ * if self._mfst.get().MutableOutputSymbols() == NULL: # <<<<<<<<<<<<<< * return * return _init_MutableFstSymbolTableView(self._mfst, input_side=False) */ } /* "pywrapfst.pyx":2375 * if self._mfst.get().MutableOutputSymbols() == NULL: * return * return _init_MutableFstSymbolTableView(self._mfst, input_side=False) # <<<<<<<<<<<<<< * * 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, 2375, __pyx_L1_error) } __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFstSymbolTableView(__pyx_v_self->_mfst, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":2367 * return _init_MutableFstSymbolTableView(self._mfst, input_side=True) * * 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":2377 * return _init_MutableFstSymbolTableView(self._mfst, input_side=False) * * cpdef int64 num_states(self): # <<<<<<<<<<<<<< * """ * num_states(self) */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_33num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static int64 __pyx_f_9pywrapfst_10MutableFst_num_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int __pyx_skip_dispatch) { 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; int64 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_10MutableFst_33num_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2377, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2377, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":2383 * Returns the number of states. * """ * return self._mfst.get().NumStates() # <<<<<<<<<<<<<< * * cdef void _project(self, project_type) except *: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2383, __pyx_L1_error) } __pyx_r = __pyx_v_self->_mfst.get()->NumStates(); goto __pyx_L0; /* "pywrapfst.pyx":2377 * return _init_MutableFstSymbolTableView(self._mfst, input_side=False) * * 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_10MutableFst_33num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_32num_states[] = "\n num_states(self)\n\n Returns the number of states.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_33num_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_10MutableFst_32num_states(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_32num_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("num_states", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_10MutableFst_num_states(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2377, __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":2385 * return self._mfst.get().NumStates() * * cdef void _project(self, project_type) except *: # <<<<<<<<<<<<<< * fst.Project(self._mfst.get(), _get_project_type(tostring(project_type))) * */ static void __pyx_f_9pywrapfst_10MutableFst__project(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_project_type) { __Pyx_RefNannyDeclarations std::string __pyx_t_1; fst::ProjectType __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_project", 0); /* "pywrapfst.pyx":2386 * * cdef void _project(self, project_type) except *: * fst.Project(self._mfst.get(), _get_project_type(tostring(project_type))) # <<<<<<<<<<<<<< * * def project(self, project_type): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2386, __pyx_L1_error) } __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_project_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2386, __pyx_L1_error) __pyx_t_2 = __pyx_f_9pywrapfst__get_project_type(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2386, __pyx_L1_error) fst::script::Project(__pyx_v_self->_mfst.get(), __pyx_t_2); /* "pywrapfst.pyx":2385 * return self._mfst.get().NumStates() * * cdef void _project(self, project_type) except *: # <<<<<<<<<<<<<< * fst.Project(self._mfst.get(), _get_project_type(tostring(project_type))) * */ /* 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":2388 * fst.Project(self._mfst.get(), _get_project_type(tostring(project_type))) * * def project(self, project_type): # <<<<<<<<<<<<<< * """ * project(self, project_type) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_35project(PyObject *__pyx_v_self, PyObject *__pyx_v_project_type); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_34project[] = "\n project(self, project_type)\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_type: A string matching a known projection type; one of:\n \"input\", \"output\".\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_35project(PyObject *__pyx_v_self, PyObject *__pyx_v_project_type) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("project (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_34project(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((PyObject *)__pyx_v_project_type)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_34project(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_project_type) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("project", 0); /* "pywrapfst.pyx":2405 * self. * """ * self._project(project_type) # <<<<<<<<<<<<<< * return self * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_project"); __PYX_ERR(0, 2405, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_project(__pyx_v_self, __pyx_v_project_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2405, __pyx_L1_error) /* "pywrapfst.pyx":2406 * """ * self._project(project_type) * return self # <<<<<<<<<<<<<< * * cdef void _prune(self, */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2388 * fst.Project(self._mfst.get(), _get_project_type(tostring(project_type))) * * def project(self, project_type): # <<<<<<<<<<<<<< * """ * project(self, project_type) */ /* 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":2408 * return self * * cdef void _prune(self, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, */ static void __pyx_f_9pywrapfst_10MutableFst__prune(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__prune *__pyx_optional_args) { float __pyx_v_delta = __pyx_k__14; int64 __pyx_v_nstate = __pyx_k__15; /* "pywrapfst.pyx":2411 * 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 _weight = _get_WeightClass_or_zero(self.weight_type(), */ PyObject *__pyx_v_weight = ((PyObject *)Py_None); fst::script::WeightClass __pyx_v__weight; __Pyx_RefNannyDeclarations fst::script::WeightClass __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2413 * weight=None) except *: * # Threshold is set to semiring Zero (no pruning) if no weight is specified. * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(self.weight_type(), # <<<<<<<<<<<<<< * weight) * fst.Prune(self._mfst.get(), _weight, 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, 2413, __pyx_L1_error) } /* "pywrapfst.pyx":2414 * # Threshold is set to semiring Zero (no pruning) if no weight is specified. * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(self.weight_type(), * weight) # <<<<<<<<<<<<<< * fst.Prune(self._mfst.get(), _weight, 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, 2413, __pyx_L1_error) __pyx_v__weight = __pyx_t_1; /* "pywrapfst.pyx":2415 * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(self.weight_type(), * weight) * fst.Prune(self._mfst.get(), _weight, 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, 2415, __pyx_L1_error) } fst::script::Prune(__pyx_v_self->_mfst.get(), __pyx_v__weight, __pyx_v_nstate, __pyx_v_delta); /* "pywrapfst.pyx":2416 * weight) * fst.Prune(self._mfst.get(), _weight, 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, 2416, __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, 2416, __pyx_L1_error) /* "pywrapfst.pyx":2408 * return self * * cdef void _prune(self, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, */ /* 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":2418 * self._check_mutating_imethod() * * def prune(self, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_37prune(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_36prune[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_37prune(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { float __pyx_v_delta; int64 __pyx_v_nstate; PyObject *__pyx_v_weight = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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":2421 * 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nstate); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 2418, __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, 2419, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__16; } if (values[1]) { __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_nstate == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2420, __pyx_L3_error) } else { __pyx_v_nstate = __pyx_k__17; } __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, 2418, __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_10MutableFst_36prune(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_nstate, __pyx_v_weight); /* "pywrapfst.pyx":2418 * 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_10MutableFst_36prune(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, float __pyx_v_delta, int64 __pyx_v_nstate, PyObject *__pyx_v_weight) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst_10MutableFst__prune __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("prune", 0); /* "pywrapfst.pyx":2441 * self. * """ * 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, 2441, __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, 2441, __pyx_L1_error) /* "pywrapfst.pyx":2442 * """ * 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":2418 * 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":2444 * return self * * cdef void _push(self, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * bool remove_total_weight=False, */ static void __pyx_f_9pywrapfst_10MutableFst__push(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__push *__pyx_optional_args) { float __pyx_v_delta = __pyx_k__18; /* "pywrapfst.pyx":2446 * cdef void _push(self, * float delta=fst.kShortestDelta, * bool remove_total_weight=False, # <<<<<<<<<<<<<< * bool to_final=False): * fst.Push(self._mfst.get(), */ bool __pyx_v_remove_total_weight = ((bool)0); /* "pywrapfst.pyx":2447 * float delta=fst.kShortestDelta, * bool remove_total_weight=False, * bool to_final=False): # <<<<<<<<<<<<<< * fst.Push(self._mfst.get(), * fst.GetReweightType(to_final), */ bool __pyx_v_to_final = ((bool)0); __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2448 * bool remove_total_weight=False, * bool to_final=False): * fst.Push(self._mfst.get(), # <<<<<<<<<<<<<< * fst.GetReweightType(to_final), * delta, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2448, __pyx_L1_error) } /* "pywrapfst.pyx":2451 * fst.GetReweightType(to_final), * delta, * remove_total_weight) # <<<<<<<<<<<<<< * * def push(self, */ 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":2444 * return self * * cdef void _push(self, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * bool remove_total_weight=False, */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst.MutableFst._push", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2453 * remove_total_weight) * * def push(self, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * bool remove_total_weight=False, */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_39push(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_38push[] = "\n push(self, delta=1-e6, 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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_39push(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 2453, __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, 2454, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__19; } 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, 2455, __pyx_L3_error) } else { /* "pywrapfst.pyx":2455 * def push(self, * float delta=fst.kShortestDelta, * 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, 2456, __pyx_L3_error) } else { /* "pywrapfst.pyx":2456 * float delta=fst.kShortestDelta, * bool remove_total_weight=False, * bool to_final=False): # <<<<<<<<<<<<<< * """ * push(self, delta=1-e6, 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, 2453, __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_10MutableFst_38push(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_remove_total_weight, __pyx_v_to_final); /* "pywrapfst.pyx":2453 * remove_total_weight) * * def push(self, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * bool remove_total_weight=False, */ /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_38push(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_10MutableFst__push __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("push", 0); /* "pywrapfst.pyx":2480 * self. * """ * 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, 2480, __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); /* "pywrapfst.pyx":2481 * """ * 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":2453 * remove_total_weight) * * def push(self, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * 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":2483 * return self * * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: # <<<<<<<<<<<<<< * cdef vector[fst.LabelPair] _ipairs * cdef vector[fst.LabelPair] _opairs */ static void __pyx_f_9pywrapfst_10MutableFst__relabel_pairs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_pairs *__pyx_optional_args) { PyObject *__pyx_v_ipairs = ((PyObject *)Py_None); PyObject *__pyx_v_opairs = ((PyObject *)Py_None); std::vector<__pyx_t_10cpywrapfst_LabelPair> __pyx_v__ipairs; std::vector<__pyx_t_10cpywrapfst_LabelPair> __pyx_v__opairs; PyObject *__pyx_v_before = NULL; PyObject *__pyx_v_after = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; Py_ssize_t __pyx_t_3; PyObject *(*__pyx_t_4)(PyObject *); PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *(*__pyx_t_9)(PyObject *); int64 __pyx_t_10; int64 __pyx_t_11; __pyx_t_10cpywrapfst_LabelPair __pyx_t_12; int __pyx_t_13; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2486 * cdef vector[fst.LabelPair] _ipairs * cdef vector[fst.LabelPair] _opairs * if ipairs: # <<<<<<<<<<<<<< * for (before, after) in ipairs: * _ipairs.push_back(fst.LabelPair(before, after)) */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ipairs); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2486, __pyx_L1_error) if (__pyx_t_1) { /* "pywrapfst.pyx":2487 * cdef vector[fst.LabelPair] _opairs * if ipairs: * for (before, after) in ipairs: # <<<<<<<<<<<<<< * _ipairs.push_back(fst.LabelPair(before, after)) * if opairs: */ if (likely(PyList_CheckExact(__pyx_v_ipairs)) || PyTuple_CheckExact(__pyx_v_ipairs)) { __pyx_t_2 = __pyx_v_ipairs; __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_ipairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2487, __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, 2487, __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, 2487, __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, 2487, __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, 2487, __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, 2487, __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, 2487, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_5); } if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { PyObject* sequence = __pyx_t_5; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 2487, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_6 = PyList_GET_ITEM(sequence, 0); __pyx_t_7 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); #else __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { Py_ssize_t index = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext; index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(0, 2487, __pyx_L1_error) __pyx_t_9 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L7_unpacking_done; __pyx_L6_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 2487, __pyx_L1_error) __pyx_L7_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_before, __pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_after, __pyx_t_7); __pyx_t_7 = 0; /* "pywrapfst.pyx":2488 * if ipairs: * for (before, after) in ipairs: * _ipairs.push_back(fst.LabelPair(before, after)) # <<<<<<<<<<<<<< * if opairs: * for (before, after) in opairs: */ __pyx_t_10 = __Pyx_PyInt_As_int64_t(__pyx_v_before); if (unlikely((__pyx_t_10 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2488, __pyx_L1_error) __pyx_t_11 = __Pyx_PyInt_As_int64_t(__pyx_v_after); if (unlikely((__pyx_t_11 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2488, __pyx_L1_error) try { __pyx_t_12 = __pyx_t_10cpywrapfst_LabelPair(__pyx_t_10, __pyx_t_11); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 2488, __pyx_L1_error) } try { __pyx_v__ipairs.push_back(__pyx_t_12); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 2488, __pyx_L1_error) } /* "pywrapfst.pyx":2487 * cdef vector[fst.LabelPair] _opairs * if ipairs: * for (before, after) in ipairs: # <<<<<<<<<<<<<< * _ipairs.push_back(fst.LabelPair(before, after)) * if opairs: */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2486 * cdef vector[fst.LabelPair] _ipairs * cdef vector[fst.LabelPair] _opairs * if ipairs: # <<<<<<<<<<<<<< * for (before, after) in ipairs: * _ipairs.push_back(fst.LabelPair(before, after)) */ } /* "pywrapfst.pyx":2489 * for (before, after) in ipairs: * _ipairs.push_back(fst.LabelPair(before, after)) * if opairs: # <<<<<<<<<<<<<< * for (before, after) in opairs: * _opairs.push_back(fst.LabelPair(before, after)) */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_opairs); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2489, __pyx_L1_error) if (__pyx_t_1) { /* "pywrapfst.pyx":2490 * _ipairs.push_back(fst.LabelPair(before, after)) * if opairs: * for (before, after) in opairs: # <<<<<<<<<<<<<< * _opairs.push_back(fst.LabelPair(before, after)) * if _ipairs.empty() and _opairs.empty(): */ if (likely(PyList_CheckExact(__pyx_v_opairs)) || PyTuple_CheckExact(__pyx_v_opairs)) { __pyx_t_2 = __pyx_v_opairs; __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_opairs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2490, __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, 2490, __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, 2490, __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, 2490, __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, 2490, __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, 2490, __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, 2490, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_5); } if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { PyObject* sequence = __pyx_t_5; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 2490, __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_6 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_7 = PyList_GET_ITEM(sequence, 0); __pyx_t_6 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { Py_ssize_t index = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext; index = 0; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L11_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); index = 1; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L11_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(0, 2490, __pyx_L1_error) __pyx_t_9 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L12_unpacking_done; __pyx_L11_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_9 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 2490, __pyx_L1_error) __pyx_L12_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_before, __pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF_SET(__pyx_v_after, __pyx_t_6); __pyx_t_6 = 0; /* "pywrapfst.pyx":2491 * if opairs: * for (before, after) in opairs: * _opairs.push_back(fst.LabelPair(before, after)) # <<<<<<<<<<<<<< * if _ipairs.empty() and _opairs.empty(): * raise FstArgError("No relabeling pairs specified") */ __pyx_t_11 = __Pyx_PyInt_As_int64_t(__pyx_v_before); if (unlikely((__pyx_t_11 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2491, __pyx_L1_error) __pyx_t_10 = __Pyx_PyInt_As_int64_t(__pyx_v_after); if (unlikely((__pyx_t_10 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2491, __pyx_L1_error) try { __pyx_t_12 = __pyx_t_10cpywrapfst_LabelPair(__pyx_t_11, __pyx_t_10); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 2491, __pyx_L1_error) } try { __pyx_v__opairs.push_back(__pyx_t_12); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 2491, __pyx_L1_error) } /* "pywrapfst.pyx":2490 * _ipairs.push_back(fst.LabelPair(before, after)) * if opairs: * for (before, after) in opairs: # <<<<<<<<<<<<<< * _opairs.push_back(fst.LabelPair(before, after)) * if _ipairs.empty() and _opairs.empty(): */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2489 * for (before, after) in ipairs: * _ipairs.push_back(fst.LabelPair(before, after)) * if opairs: # <<<<<<<<<<<<<< * for (before, after) in opairs: * _opairs.push_back(fst.LabelPair(before, after)) */ } /* "pywrapfst.pyx":2492 * for (before, after) in opairs: * _opairs.push_back(fst.LabelPair(before, after)) * if _ipairs.empty() and _opairs.empty(): # <<<<<<<<<<<<<< * raise FstArgError("No relabeling pairs specified") * fst.Relabel(self._mfst.get(), _ipairs, _opairs) */ __pyx_t_13 = (__pyx_v__ipairs.empty() != 0); if (__pyx_t_13) { } else { __pyx_t_1 = __pyx_t_13; goto __pyx_L14_bool_binop_done; } __pyx_t_13 = (__pyx_v__opairs.empty() != 0); __pyx_t_1 = __pyx_t_13; __pyx_L14_bool_binop_done:; if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2493 * _opairs.push_back(fst.LabelPair(before, after)) * if _ipairs.empty() and _opairs.empty(): * raise FstArgError("No relabeling pairs specified") # <<<<<<<<<<<<<< * fst.Relabel(self._mfst.get(), _ipairs, _opairs) * self._check_mutating_imethod() */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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); } } __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_kp_u_No_relabeling_pairs_specified) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_u_No_relabeling_pairs_specified); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2493, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(0, 2493, __pyx_L1_error) /* "pywrapfst.pyx":2492 * for (before, after) in opairs: * _opairs.push_back(fst.LabelPair(before, after)) * if _ipairs.empty() and _opairs.empty(): # <<<<<<<<<<<<<< * raise FstArgError("No relabeling pairs specified") * fst.Relabel(self._mfst.get(), _ipairs, _opairs) */ } /* "pywrapfst.pyx":2494 * if _ipairs.empty() and _opairs.empty(): * raise FstArgError("No relabeling pairs specified") * fst.Relabel(self._mfst.get(), _ipairs, _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, 2494, __pyx_L1_error) } fst::script::Relabel(__pyx_v_self->_mfst.get(), __pyx_v__ipairs, __pyx_v__opairs); /* "pywrapfst.pyx":2495 * raise FstArgError("No relabeling pairs specified") * fst.Relabel(self._mfst.get(), _ipairs, _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, 2495, __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, 2495, __pyx_L1_error) /* "pywrapfst.pyx":2483 * return self * * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: # <<<<<<<<<<<<<< * cdef vector[fst.LabelPair] _ipairs * cdef vector[fst.LabelPair] _opairs */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("pywrapfst.MutableFst._relabel_pairs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_v_before); __Pyx_XDECREF(__pyx_v_after); __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2497 * 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_10MutableFst_41relabel_pairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_40relabel_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_41relabel_pairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_ipairs = 0; PyObject *__pyx_v_opairs = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ipairs); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 2497, __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, 2497, __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_10MutableFst_40relabel_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_10MutableFst_40relabel_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_10MutableFst__relabel_pairs __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("relabel_pairs", 0); /* "pywrapfst.pyx":2517 * FstArgError: No relabeling pairs specified. * """ * 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, 2517, __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, 2517, __pyx_L1_error) /* "pywrapfst.pyx":2518 * """ * 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":2497 * 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":2520 * return self * * cdef void _relabel_tables(self, # <<<<<<<<<<<<<< * SymbolTableView old_isymbols=None, * SymbolTableView new_isymbols=None, */ static void __pyx_f_9pywrapfst_10MutableFst__relabel_tables(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_tables *__pyx_optional_args) { /* "pywrapfst.pyx":2521 * * cdef void _relabel_tables(self, * SymbolTableView old_isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView new_isymbols=None, * unknown_isymbol="", */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_old_isymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":2522 * cdef void _relabel_tables(self, * SymbolTableView old_isymbols=None, * SymbolTableView new_isymbols=None, # <<<<<<<<<<<<<< * unknown_isymbol="", * bool attach_new_isymbols=True, */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_new_isymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); PyObject *__pyx_v_unknown_isymbol = ((PyObject *)__pyx_kp_u__11); /* "pywrapfst.pyx":2524 * SymbolTableView new_isymbols=None, * unknown_isymbol="", * bool attach_new_isymbols=True, # <<<<<<<<<<<<<< * SymbolTableView old_osymbols=None, * SymbolTableView new_osymbols=None, */ bool __pyx_v_attach_new_isymbols = ((bool)1); /* "pywrapfst.pyx":2525 * unknown_isymbol="", * bool attach_new_isymbols=True, * SymbolTableView old_osymbols=None, # <<<<<<<<<<<<<< * SymbolTableView new_osymbols=None, * unknown_osymbol="", */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_old_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":2526 * bool attach_new_isymbols=True, * SymbolTableView old_osymbols=None, * SymbolTableView new_osymbols=None, # <<<<<<<<<<<<<< * unknown_osymbol="", * bool attach_new_osymbols=True) except *: */ struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_new_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); PyObject *__pyx_v_unknown_osymbol = ((PyObject *)__pyx_kp_u__11); /* "pywrapfst.pyx":2528 * SymbolTableView new_osymbols=None, * unknown_osymbol="", * 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 const *__pyx_v__old_isymbols; fst::SymbolTable const *__pyx_v__old_osymbols; fst::SymbolTable const *__pyx_v__new_isymbols; fst::SymbolTable const *__pyx_v__new_osymbols; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; fst::SymbolTable const *__pyx_t_7; std::string __pyx_t_8; std::string __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2529 * unknown_osymbol="", * bool attach_new_osymbols=True) except *: * if new_isymbols is None and new_osymbols is None: # <<<<<<<<<<<<<< * raise FstArgError("No new SymbolTables specified") * cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() */ __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 (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2530 * bool attach_new_osymbols=True) except *: * if new_isymbols is None and new_osymbols is None: * raise FstArgError("No new SymbolTables specified") # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() * if old_isymbols is not None: */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __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); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_kp_u_No_new_SymbolTables_specified) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_u_No_new_SymbolTables_specified); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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, 2530, __pyx_L1_error) /* "pywrapfst.pyx":2529 * unknown_osymbol="", * bool attach_new_osymbols=True) except *: * if new_isymbols is None and new_osymbols is None: # <<<<<<<<<<<<<< * raise FstArgError("No new SymbolTables specified") * cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() */ } /* "pywrapfst.pyx":2531 * if new_isymbols is None and new_osymbols is None: * raise FstArgError("No new SymbolTables specified") * cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() # <<<<<<<<<<<<<< * if old_isymbols is not None: * _old_isymbols = old_isymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2531, __pyx_L1_error) } __pyx_v__old_isymbols = __pyx_v_self->__pyx_base._fst.get()->InputSymbols(); /* "pywrapfst.pyx":2532 * raise FstArgError("No new SymbolTables specified") * cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() * if old_isymbols is not None: # <<<<<<<<<<<<<< * _old_isymbols = old_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() */ __pyx_t_1 = (((PyObject *)__pyx_v_old_isymbols) != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":2533 * cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() * if old_isymbols is not None: * _old_isymbols = old_isymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() * if old_osymbols is not None: */ if (unlikely(((PyObject *)__pyx_v_old_isymbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 2533, __pyx_L1_error) } __pyx_t_7 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_old_isymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_old_isymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2533, __pyx_L1_error) __pyx_v__old_isymbols = __pyx_t_7; /* "pywrapfst.pyx":2532 * raise FstArgError("No new SymbolTables specified") * cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() * if old_isymbols is not None: # <<<<<<<<<<<<<< * _old_isymbols = old_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() */ } /* "pywrapfst.pyx":2534 * if old_isymbols is not None: * _old_isymbols = old_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() # <<<<<<<<<<<<<< * if old_osymbols is not None: * _old_osymbols = old_osymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2534, __pyx_L1_error) } __pyx_v__old_osymbols = __pyx_v_self->__pyx_base._fst.get()->OutputSymbols(); /* "pywrapfst.pyx":2535 * _old_isymbols = old_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() * if old_osymbols is not None: # <<<<<<<<<<<<<< * _old_osymbols = old_osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_isymbols = NULL */ __pyx_t_2 = (((PyObject *)__pyx_v_old_osymbols) != Py_None); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":2536 * cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() * if old_osymbols is not None: * _old_osymbols = old_osymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_new_isymbols = NULL * if new_isymbols is not None: */ if (unlikely(((PyObject *)__pyx_v_old_osymbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 2536, __pyx_L1_error) } __pyx_t_7 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_old_osymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_old_osymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2536, __pyx_L1_error) __pyx_v__old_osymbols = __pyx_t_7; /* "pywrapfst.pyx":2535 * _old_isymbols = old_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() * if old_osymbols is not None: # <<<<<<<<<<<<<< * _old_osymbols = old_osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_isymbols = NULL */ } /* "pywrapfst.pyx":2537 * if old_osymbols is not None: * _old_osymbols = old_osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_isymbols = NULL # <<<<<<<<<<<<<< * if new_isymbols is not None: * _new_isymbols = new_isymbols._raw_ptr_or_raise() */ __pyx_v__new_isymbols = NULL; /* "pywrapfst.pyx":2538 * _old_osymbols = old_osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_isymbols = NULL * if new_isymbols is not None: # <<<<<<<<<<<<<< * _new_isymbols = new_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_osymbols = NULL */ __pyx_t_1 = (((PyObject *)__pyx_v_new_isymbols) != Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":2539 * cdef const fst.SymbolTable *_new_isymbols = NULL * if new_isymbols is not None: * _new_isymbols = new_isymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * cdef const fst.SymbolTable *_new_osymbols = 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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 2539, __pyx_L1_error) } __pyx_t_7 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_new_isymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_new_isymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2539, __pyx_L1_error) __pyx_v__new_isymbols = __pyx_t_7; /* "pywrapfst.pyx":2538 * _old_osymbols = old_osymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_isymbols = NULL * if new_isymbols is not None: # <<<<<<<<<<<<<< * _new_isymbols = new_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_osymbols = NULL */ } /* "pywrapfst.pyx":2540 * if new_isymbols is not None: * _new_isymbols = new_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_osymbols = NULL # <<<<<<<<<<<<<< * if new_osymbols is not None: * _new_osymbols = new_osymbols._raw_ptr_or_raise() */ __pyx_v__new_osymbols = NULL; /* "pywrapfst.pyx":2541 * _new_isymbols = new_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_osymbols = NULL * if new_osymbols is not None: # <<<<<<<<<<<<<< * _new_osymbols = new_osymbols._raw_ptr_or_raise() * 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":2542 * cdef const fst.SymbolTable *_new_osymbols = NULL * if new_osymbols is not None: * _new_osymbols = new_osymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * fst.Relabel(self._mfst.get(), * _old_isymbols, */ if (unlikely(((PyObject *)__pyx_v_new_osymbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 2542, __pyx_L1_error) } __pyx_t_7 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_new_osymbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_new_osymbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2542, __pyx_L1_error) __pyx_v__new_osymbols = __pyx_t_7; /* "pywrapfst.pyx":2541 * _new_isymbols = new_isymbols._raw_ptr_or_raise() * cdef const fst.SymbolTable *_new_osymbols = NULL * if new_osymbols is not None: # <<<<<<<<<<<<<< * _new_osymbols = new_osymbols._raw_ptr_or_raise() * fst.Relabel(self._mfst.get(), */ } /* "pywrapfst.pyx":2543 * if new_osymbols is not None: * _new_osymbols = new_osymbols._raw_ptr_or_raise() * fst.Relabel(self._mfst.get(), # <<<<<<<<<<<<<< * _old_isymbols, * _new_isymbols, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2543, __pyx_L1_error) } /* "pywrapfst.pyx":2546 * _old_isymbols, * _new_isymbols, * tostring(unknown_isymbol), # <<<<<<<<<<<<<< * attach_new_isymbols, * _old_osymbols, */ __pyx_t_8 = __pyx_f_9pywrapfst_tostring(__pyx_v_unknown_isymbol); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2546, __pyx_L1_error) /* "pywrapfst.pyx":2550 * _old_osymbols, * _new_osymbols, * tostring(unknown_osymbol), # <<<<<<<<<<<<<< * attach_new_osymbols) * self._check_mutating_imethod() */ __pyx_t_9 = __pyx_f_9pywrapfst_tostring(__pyx_v_unknown_osymbol); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2550, __pyx_L1_error) /* "pywrapfst.pyx":2543 * if new_osymbols is not None: * _new_osymbols = new_osymbols._raw_ptr_or_raise() * fst.Relabel(self._mfst.get(), # <<<<<<<<<<<<<< * _old_isymbols, * _new_isymbols, */ fst::script::Relabel(__pyx_v_self->_mfst.get(), __pyx_v__old_isymbols, __pyx_v__new_isymbols, __pyx_t_8, __pyx_v_attach_new_isymbols, __pyx_v__old_osymbols, __pyx_v__new_osymbols, __pyx_t_9, __pyx_v_attach_new_osymbols); /* "pywrapfst.pyx":2552 * 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, 2552, __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, 2552, __pyx_L1_error) /* "pywrapfst.pyx":2520 * return self * * cdef void _relabel_tables(self, # <<<<<<<<<<<<<< * SymbolTableView old_isymbols=None, * SymbolTableView new_isymbols=None, */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pywrapfst.MutableFst._relabel_tables", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2554 * self._check_mutating_imethod() * * def relabel_tables(self, # <<<<<<<<<<<<<< * SymbolTableView old_isymbols=None, * SymbolTableView new_isymbols=None, */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_43relabel_tables(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_42relabel_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_43relabel_tables(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_old_isymbols = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_new_isymbols = 0; PyObject *__pyx_v_unknown_isymbol = 0; bool __pyx_v_attach_new_isymbols; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_old_osymbols = 0; struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_new_osymbols = 0; PyObject *__pyx_v_unknown_osymbol = 0; bool __pyx_v_attach_new_osymbols; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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":2555 * * def relabel_tables(self, * SymbolTableView old_isymbols=None, # <<<<<<<<<<<<<< * SymbolTableView new_isymbols=None, * unknown_isymbol="", */ values[0] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":2556 * def relabel_tables(self, * SymbolTableView old_isymbols=None, * SymbolTableView new_isymbols=None, # <<<<<<<<<<<<<< * unknown_isymbol="", * bool attach_new_isymbols=True, */ values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); values[2] = ((PyObject *)__pyx_kp_u__11); /* "pywrapfst.pyx":2559 * unknown_isymbol="", * bool attach_new_isymbols=True, * SymbolTableView old_osymbols=None, # <<<<<<<<<<<<<< * SymbolTableView new_osymbols=None, * unknown_osymbol="", */ values[4] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); /* "pywrapfst.pyx":2560 * bool attach_new_isymbols=True, * SymbolTableView old_osymbols=None, * SymbolTableView new_osymbols=None, # <<<<<<<<<<<<<< * unknown_osymbol="", * bool attach_new_osymbols=True): */ values[5] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); values[6] = ((PyObject *)__pyx_kp_u__11); 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_old_isymbols); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_new_isymbols); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_unknown_isymbol); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_old_osymbols); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_new_osymbols); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_unknown_osymbol); if (value) { values[6] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 2554, __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_SymbolTableView *)values[0]); __pyx_v_new_isymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)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, 2558, __pyx_L3_error) } else { /* "pywrapfst.pyx":2558 * SymbolTableView new_isymbols=None, * unknown_isymbol="", * bool attach_new_isymbols=True, # <<<<<<<<<<<<<< * SymbolTableView old_osymbols=None, * SymbolTableView new_osymbols=None, */ __pyx_v_attach_new_isymbols = ((bool)1); } __pyx_v_old_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)values[4]); __pyx_v_new_osymbols = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)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, 2562, __pyx_L3_error) } else { /* "pywrapfst.pyx":2562 * SymbolTableView new_osymbols=None, * unknown_osymbol="", * 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, 2554, __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_SymbolTableView, 1, "old_isymbols", 0))) __PYX_ERR(0, 2555, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_new_isymbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "new_isymbols", 0))) __PYX_ERR(0, 2556, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_old_osymbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "old_osymbols", 0))) __PYX_ERR(0, 2559, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_new_osymbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "new_osymbols", 0))) __PYX_ERR(0, 2560, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_42relabel_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":2554 * self._check_mutating_imethod() * * def relabel_tables(self, # <<<<<<<<<<<<<< * SymbolTableView old_isymbols=None, * SymbolTableView 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_10MutableFst_42relabel_tables(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_old_isymbols, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_new_isymbols, PyObject *__pyx_v_unknown_isymbol, bool __pyx_v_attach_new_isymbols, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_old_osymbols, struct __pyx_obj_9pywrapfst_SymbolTableView *__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_10MutableFst__relabel_tables __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("relabel_tables", 0); /* "pywrapfst.pyx":2596 * FstArgError: No SymbolTable specified. * """ * self._relabel_tables(old_isymbols, # <<<<<<<<<<<<<< * new_isymbols, * unknown_isymbol, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_relabel_tables"); __PYX_ERR(0, 2596, __pyx_L1_error) } /* "pywrapfst.pyx":2603 * 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, 2596, __pyx_L1_error) /* "pywrapfst.pyx":2604 * 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":2554 * self._check_mutating_imethod() * * def relabel_tables(self, # <<<<<<<<<<<<<< * SymbolTableView old_isymbols=None, * SymbolTableView 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":2606 * 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_10MutableFst__reserve_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, 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; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_reserve_arcs", 0); /* "pywrapfst.pyx":2607 * * 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, 2607, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->ReserveArcs(__pyx_v_state, __pyx_v_n) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2608 * 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2608, __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, 2608, __pyx_L1_error) /* "pywrapfst.pyx":2607 * * 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":2609 * 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, 2609, __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, 2609, __pyx_L1_error) /* "pywrapfst.pyx":2606 * 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_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.MutableFst._reserve_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2611 * 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_10MutableFst_45reserve_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_44reserve_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_45reserve_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64 __pyx_v_state; size_t __pyx_v_n; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("reserve_arcs", 1, 2, 2, 1); __PYX_ERR(0, 2611, __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, 2611, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2611, __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, 2611, __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, 2611, __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_10MutableFst_44reserve_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_10MutableFst_44reserve_arcs(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, size_t __pyx_v_n) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reserve_arcs", 0); /* "pywrapfst.pyx":2627 * FstIndexError: State index out of range. * """ * 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, 2627, __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, 2627, __pyx_L1_error) /* "pywrapfst.pyx":2628 * """ * self._reserve_arcs(state, n) * return self # <<<<<<<<<<<<<< * * cdef void _reserve_states(self, int64 n): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2611 * 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":2630 * return self * * cdef void _reserve_states(self, int64 n): # <<<<<<<<<<<<<< * self._mfst.get().ReserveStates(n) * */ static void __pyx_f_9pywrapfst_10MutableFst__reserve_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_n) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_reserve_states", 0); /* "pywrapfst.pyx":2631 * * cdef void _reserve_states(self, int64 n): * self._mfst.get().ReserveStates(n) # <<<<<<<<<<<<<< * * def reserve_states(self, int64 n): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2631, __pyx_L1_error) } __pyx_v_self->_mfst.get()->ReserveStates(__pyx_v_n); /* "pywrapfst.pyx":2630 * return self * * cdef void _reserve_states(self, int64 n): # <<<<<<<<<<<<<< * self._mfst.get().ReserveStates(n) * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst.MutableFst._reserve_states", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2633 * self._mfst.get().ReserveStates(n) * * def reserve_states(self, int64 n): # <<<<<<<<<<<<<< * """ * reserve_states(self, n) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_47reserve_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_46reserve_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_47reserve_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n) { int64 __pyx_v_n; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2633, __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_10MutableFst_46reserve_states(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((int64)__pyx_v_n)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_46reserve_states(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_n) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reserve_states", 0); /* "pywrapfst.pyx":2645 * self. * """ * 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, 2645, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_reserve_states(__pyx_v_self, __pyx_v_n); /* "pywrapfst.pyx":2646 * """ * 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":2633 * self._mfst.get().ReserveStates(n) * * 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":2648 * return self * * cdef void _reweight(self, potentials, bool to_final=False) except *: # <<<<<<<<<<<<<< * cdef string _weight_type = self.weight_type() * cdef vector[fst.WeightClass] _potentials */ static void __pyx_f_9pywrapfst_10MutableFst__reweight(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, struct __pyx_opt_args_9pywrapfst_10MutableFst__reweight *__pyx_optional_args) { bool __pyx_v_to_final = ((bool)0); std::string __pyx_v__weight_type; std::vector __pyx_v__potentials; PyObject *__pyx_v_weight = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *(*__pyx_t_3)(PyObject *); PyObject *__pyx_t_4 = NULL; fst::script::WeightClass __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2649 * * cdef void _reweight(self, potentials, bool to_final=False) except *: * cdef string _weight_type = self.weight_type() # <<<<<<<<<<<<<< * cdef vector[fst.WeightClass] _potentials * for weight in potentials: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); __PYX_ERR(0, 2649, __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":2651 * cdef string _weight_type = self.weight_type() * cdef vector[fst.WeightClass] _potentials * for weight in potentials: # <<<<<<<<<<<<<< * _potentials.push_back(_get_WeightClass_or_one(_weight_type, weight)) * fst.Reweight(self._mfst.get(), _potentials, fst.GetReweightType(to_final)) */ if (likely(PyList_CheckExact(__pyx_v_potentials)) || PyTuple_CheckExact(__pyx_v_potentials)) { __pyx_t_1 = __pyx_v_potentials; __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_potentials); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2651, __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(0, 2651, __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(0, 2651, __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(0, 2651, __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(0, 2651, __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(0, 2651, __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(0, 2651, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_4); } __Pyx_XDECREF_SET(__pyx_v_weight, __pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2652 * cdef vector[fst.WeightClass] _potentials * for weight in potentials: * _potentials.push_back(_get_WeightClass_or_one(_weight_type, weight)) # <<<<<<<<<<<<<< * fst.Reweight(self._mfst.get(), _potentials, fst.GetReweightType(to_final)) * self._check_mutating_imethod() */ __pyx_t_5 = __pyx_f_9pywrapfst__get_WeightClass_or_one(__pyx_v__weight_type, __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2652, __pyx_L1_error) try { __pyx_v__potentials.push_back(__pyx_t_5); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 2652, __pyx_L1_error) } /* "pywrapfst.pyx":2651 * cdef string _weight_type = self.weight_type() * cdef vector[fst.WeightClass] _potentials * for weight in potentials: # <<<<<<<<<<<<<< * _potentials.push_back(_get_WeightClass_or_one(_weight_type, weight)) * fst.Reweight(self._mfst.get(), _potentials, fst.GetReweightType(to_final)) */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":2653 * for weight in potentials: * _potentials.push_back(_get_WeightClass_or_one(_weight_type, weight)) * fst.Reweight(self._mfst.get(), _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, 2653, __pyx_L1_error) } fst::script::Reweight(__pyx_v_self->_mfst.get(), __pyx_v__potentials, fst::script::GetReweightType(__pyx_v_to_final)); /* "pywrapfst.pyx":2654 * _potentials.push_back(_get_WeightClass_or_one(_weight_type, weight)) * fst.Reweight(self._mfst.get(), _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, 2654, __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, 2654, __pyx_L1_error) /* "pywrapfst.pyx":2648 * return self * * cdef void _reweight(self, potentials, bool to_final=False) except *: # <<<<<<<<<<<<<< * cdef string _weight_type = self.weight_type() * cdef vector[fst.WeightClass] _potentials */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.MutableFst._reweight", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_v_weight); __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2656 * 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_10MutableFst_49reweight(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_48reweight[] = "\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_10MutableFst_49reweight(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_potentials = 0; bool __pyx_v_to_final; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 2656, __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, 2656, __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, 2656, __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_10MutableFst_48reweight(((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_10MutableFst_48reweight(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_10MutableFst__reweight __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reweight", 0); /* "pywrapfst.pyx":2678 * 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, 2678, __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, 2678, __pyx_L1_error) /* "pywrapfst.pyx":2679 * """ * 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":2656 * 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":2681 * return self * * cdef void _rmepsilon(self, # <<<<<<<<<<<<<< * queue_type="auto", * bool connect=True, */ static void __pyx_f_9pywrapfst_10MutableFst__rmepsilon(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_10MutableFst__rmepsilon *__pyx_optional_args) { PyObject *__pyx_v_queue_type = ((PyObject *)__pyx_n_u_auto); /* "pywrapfst.pyx":2683 * cdef void _rmepsilon(self, * queue_type="auto", * bool connect=True, # <<<<<<<<<<<<<< * weight=None, * int64 nstate=fst.kNoStateId, */ bool __pyx_v_connect = ((bool)1); /* "pywrapfst.pyx":2684 * queue_type="auto", * bool connect=True, * weight=None, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * float delta=fst.kShortestDelta) except *: */ PyObject *__pyx_v_weight = ((PyObject *)Py_None); int64 __pyx_v_nstate = __pyx_k__20; float __pyx_v_delta = __pyx_k__21; fst::script::WeightClass __pyx_v__weight; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2687 * int64 nstate=fst.kNoStateId, * float delta=fst.kShortestDelta) except *: * cdef fst.WeightClass _weight = _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, 2687, __pyx_L1_error) } /* "pywrapfst.pyx":2688 * float delta=fst.kShortestDelta) except *: * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(self.weight_type(), * weight) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.RmEpsilonOptions] _opts * _opts.reset( */ __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, 2687, __pyx_L1_error) __pyx_v__weight = __pyx_t_1; /* "pywrapfst.pyx":2691 * cdef unique_ptr[fst.RmEpsilonOptions] _opts * _opts.reset( * new fst.RmEpsilonOptions(_get_queue_type(tostring(queue_type)), # <<<<<<<<<<<<<< * connect, * _weight, */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_queue_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2691, __pyx_L1_error) __pyx_t_3 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2691, __pyx_L1_error) /* "pywrapfst.pyx":2690 * weight) * cdef unique_ptr[fst.RmEpsilonOptions] _opts * _opts.reset( # <<<<<<<<<<<<<< * new fst.RmEpsilonOptions(_get_queue_type(tostring(queue_type)), * connect, */ __pyx_v__opts.reset(new fst::script::RmEpsilonOptions(__pyx_t_3, __pyx_v_connect, __pyx_v__weight, __pyx_v_nstate, __pyx_v_delta)); /* "pywrapfst.pyx":2696 * 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, 2696, __pyx_L1_error) } fst::script::RmEpsilon(__pyx_v_self->_mfst.get(), (*__pyx_v__opts)); /* "pywrapfst.pyx":2697 * 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, 2697, __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, 2697, __pyx_L1_error) /* "pywrapfst.pyx":2681 * return self * * cdef void _rmepsilon(self, # <<<<<<<<<<<<<< * queue_type="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":2699 * self._check_mutating_imethod() * * def rmepsilon(self, # <<<<<<<<<<<<<< * queue_type="auto", * bool connect=True, */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_51rmepsilon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_50rmepsilon[] = "\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_10MutableFst_51rmepsilon(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; int64 __pyx_v_nstate; float __pyx_v_delta; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_auto); /* "pywrapfst.pyx":2702 * queue_type="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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_queue_type); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_connect); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weight); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nstate); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 2699, __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, 2701, __pyx_L3_error) } else { /* "pywrapfst.pyx":2701 * def rmepsilon(self, * queue_type="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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2703, __pyx_L3_error) } else { __pyx_v_nstate = __pyx_k__22; } if (values[4]) { __pyx_v_delta = __pyx_PyFloat_AsFloat(values[4]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2704, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__23; } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("rmepsilon", 0, 0, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2699, __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_10MutableFst_50rmepsilon(((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":2699 * self._check_mutating_imethod() * * def rmepsilon(self, # <<<<<<<<<<<<<< * queue_type="auto", * bool connect=True, */ /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_50rmepsilon(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_queue_type, bool __pyx_v_connect, PyObject *__pyx_v_weight, int64 __pyx_v_nstate, float __pyx_v_delta) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst_10MutableFst__rmepsilon __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("rmepsilon", 0); /* "pywrapfst.pyx":2726 * 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, 2726, __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, 2726, __pyx_L1_error) /* "pywrapfst.pyx":2727 * """ * 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":2699 * self._check_mutating_imethod() * * def rmepsilon(self, # <<<<<<<<<<<<<< * queue_type="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":2729 * 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_10MutableFst__set_final(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_10MutableFst__set_final *__pyx_optional_args) { PyObject *__pyx_v_weight = ((PyObject *)Py_None); fst::script::WeightClass __pyx_v__weight; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; fst::script::WeightClass __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":2730 * * 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 _weight = _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, 2730, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2731 * 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 _weight = _get_WeightClass_or_one(self.weight_type(), * weight) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2731, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2731, __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, 2731, __pyx_L1_error) /* "pywrapfst.pyx":2730 * * 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 _weight = _get_WeightClass_or_one(self.weight_type(), */ } /* "pywrapfst.pyx":2732 * if not self._mfst.get().ValidStateId(state): * raise FstIndexError("State index out of range") * cdef fst.WeightClass _weight = _get_WeightClass_or_one(self.weight_type(), # <<<<<<<<<<<<<< * weight) * if not self._mfst.get().SetFinal(state, _weight): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); __PYX_ERR(0, 2732, __pyx_L1_error) } /* "pywrapfst.pyx":2733 * raise FstIndexError("State index out of range") * cdef fst.WeightClass _weight = _get_WeightClass_or_one(self.weight_type(), * weight) # <<<<<<<<<<<<<< * if not self._mfst.get().SetFinal(state, _weight): * raise FstOpError("Incompatible or invalid weight") */ __pyx_t_5 = __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, 2732, __pyx_L1_error) __pyx_v__weight = __pyx_t_5; /* "pywrapfst.pyx":2734 * cdef fst.WeightClass _weight = _get_WeightClass_or_one(self.weight_type(), * weight) * if not self._mfst.get().SetFinal(state, _weight): # <<<<<<<<<<<<<< * 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, 2734, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->SetFinal(__pyx_v_state, __pyx_v__weight) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2735 * weight) * if not self._mfst.get().SetFinal(state, _weight): * raise FstOpError("Incompatible or invalid weight") # <<<<<<<<<<<<<< * self._check_mutating_imethod() * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Incompatible_or_invalid_weight) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Incompatible_or_invalid_weight); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2735, __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, 2735, __pyx_L1_error) /* "pywrapfst.pyx":2734 * cdef fst.WeightClass _weight = _get_WeightClass_or_one(self.weight_type(), * weight) * if not self._mfst.get().SetFinal(state, _weight): # <<<<<<<<<<<<<< * raise FstOpError("Incompatible or invalid weight") * self._check_mutating_imethod() */ } /* "pywrapfst.pyx":2736 * if not self._mfst.get().SetFinal(state, _weight): * 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, 2736, __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, 2736, __pyx_L1_error) /* "pywrapfst.pyx":2729 * 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_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.MutableFst._set_final", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2738 * self._check_mutating_imethod() * * def set_final(self, int64 state, weight=None): # <<<<<<<<<<<<<< * """ * set_final(self, state, weight) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_53set_final(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_52set_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_53set_final(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64 __pyx_v_state; PyObject *__pyx_v_weight = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 2738, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2738, __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, 2738, __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_10MutableFst_52set_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_10MutableFst_52set_final(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state, PyObject *__pyx_v_weight) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst_10MutableFst__set_final __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_final", 0); /* "pywrapfst.pyx":2756 * FstOpError: Incompatible or invalid weight. * """ * 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, 2756, __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, 2756, __pyx_L1_error) /* "pywrapfst.pyx":2757 * """ * self._set_final(state, weight) * return self # <<<<<<<<<<<<<< * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2738 * 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":2759 * return self * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols is None: * self._mfst.get().SetInputSymbols(NULL) */ static void __pyx_f_9pywrapfst_10MutableFst__set_input_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; fst::SymbolTable const *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_set_input_symbols", 0); /* "pywrapfst.pyx":2760 * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mfst.get().SetInputSymbols(NULL) * return */ __pyx_t_1 = (((PyObject *)__pyx_v_symbols) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":2761 * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: * if symbols is None: * self._mfst.get().SetInputSymbols(NULL) # <<<<<<<<<<<<<< * return * self._mfst.get().SetInputSymbols(symbols._raw_ptr_or_raise()) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2761, __pyx_L1_error) } __pyx_v_self->_mfst.get()->SetInputSymbols(NULL); /* "pywrapfst.pyx":2762 * if symbols is None: * self._mfst.get().SetInputSymbols(NULL) * return # <<<<<<<<<<<<<< * self._mfst.get().SetInputSymbols(symbols._raw_ptr_or_raise()) * */ goto __pyx_L0; /* "pywrapfst.pyx":2760 * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mfst.get().SetInputSymbols(NULL) * return */ } /* "pywrapfst.pyx":2763 * self._mfst.get().SetInputSymbols(NULL) * return * self._mfst.get().SetInputSymbols(symbols._raw_ptr_or_raise()) # <<<<<<<<<<<<<< * * def set_input_symbols(self, SymbolTableView symbols): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2763, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 2763, __pyx_L1_error) } __pyx_t_3 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_symbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2763, __pyx_L1_error) __pyx_v_self->_mfst.get()->SetInputSymbols(__pyx_t_3); /* "pywrapfst.pyx":2759 * return self * * cdef void _set_input_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols 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":2765 * self._mfst.get().SetInputSymbols(symbols._raw_ptr_or_raise()) * * def set_input_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_input_symbols(self, symbols) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_55set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_54set_input_symbols[] = "\n set_input_symbols(self, symbols)\n\n Sets the input symbol table.\n\n Passing None as a value will delete the input symbol table.\n\n Args:\n symbols: A SymbolTable.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_55set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_input_symbols (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_symbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "symbols", 0))) __PYX_ERR(0, 2765, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_54set_input_symbols(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_symbols)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_54set_input_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_input_symbols", 0); /* "pywrapfst.pyx":2779 * self. * """ * self._set_input_symbols(symbols) # <<<<<<<<<<<<<< * 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, 2779, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_input_symbols(__pyx_v_self, __pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) /* "pywrapfst.pyx":2780 * """ * self._set_input_symbols(symbols) * return self # <<<<<<<<<<<<<< * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2765 * self._mfst.get().SetInputSymbols(symbols._raw_ptr_or_raise()) * * def set_input_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_input_symbols(self, symbols) */ /* 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":2782 * return self * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols is None: * self._mfst.get().SetOutputSymbols(NULL) */ static void __pyx_f_9pywrapfst_10MutableFst__set_output_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; fst::SymbolTable const *__pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_set_output_symbols", 0); /* "pywrapfst.pyx":2783 * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mfst.get().SetOutputSymbols(NULL) * return */ __pyx_t_1 = (((PyObject *)__pyx_v_symbols) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":2784 * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: * if symbols is None: * self._mfst.get().SetOutputSymbols(NULL) # <<<<<<<<<<<<<< * return * self._mfst.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2784, __pyx_L1_error) } __pyx_v_self->_mfst.get()->SetOutputSymbols(NULL); /* "pywrapfst.pyx":2785 * if symbols is None: * self._mfst.get().SetOutputSymbols(NULL) * return # <<<<<<<<<<<<<< * self._mfst.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) * */ goto __pyx_L0; /* "pywrapfst.pyx":2783 * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: * if symbols is None: # <<<<<<<<<<<<<< * self._mfst.get().SetOutputSymbols(NULL) * return */ } /* "pywrapfst.pyx":2786 * self._mfst.get().SetOutputSymbols(NULL) * return * self._mfst.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) # <<<<<<<<<<<<<< * * def set_output_symbols(self, SymbolTableView symbols): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2786, __pyx_L1_error) } if (unlikely(((PyObject *)__pyx_v_symbols) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_raw_ptr_or_raise"); __PYX_ERR(0, 2786, __pyx_L1_error) } __pyx_t_3 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableView *)__pyx_v_symbols->__pyx_vtab)->_raw_ptr_or_raise(__pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2786, __pyx_L1_error) __pyx_v_self->_mfst.get()->SetOutputSymbols(__pyx_t_3); /* "pywrapfst.pyx":2782 * return self * * cdef void _set_output_symbols(self, SymbolTableView symbols) except *: # <<<<<<<<<<<<<< * if symbols 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":2788 * self._mfst.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) * * def set_output_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_output_symbols(self, symbols) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_57set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_56set_output_symbols[] = "\n set_output_symbols(self, symbols)\n\n Sets the output symbol table.\n\n Passing None as a value will delete the output symbol table.\n\n Args:\n symbols: A SymbolTable.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_57set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_symbols) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_output_symbols (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_symbols), __pyx_ptype_9pywrapfst_SymbolTableView, 1, "symbols", 0))) __PYX_ERR(0, 2788, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_56set_output_symbols(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_symbols)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_56set_output_symbols(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_SymbolTableView *__pyx_v_symbols) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_output_symbols", 0); /* "pywrapfst.pyx":2802 * self. * """ * self._set_output_symbols(symbols) # <<<<<<<<<<<<<< * 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, 2802, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_output_symbols(__pyx_v_self, __pyx_v_symbols); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2802, __pyx_L1_error) /* "pywrapfst.pyx":2803 * """ * self._set_output_symbols(symbols) * return self # <<<<<<<<<<<<<< * * def set_properties(self, props, mask): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2788 * self._mfst.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) * * def set_output_symbols(self, SymbolTableView symbols): # <<<<<<<<<<<<<< * """ * set_output_symbols(self, symbols) */ /* 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":2805 * return self * * def set_properties(self, props, mask): # <<<<<<<<<<<<<< * """ * set_properties(self, props, mask) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_59set_properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_58set_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_10MutableFst_59set_properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_props = 0; PyObject *__pyx_v_mask = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_props)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("set_properties", 1, 2, 2, 1); __PYX_ERR(0, 2805, __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, 2805, __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 = values[0]; __pyx_v_mask = values[1]; } 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, 2805, __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_10MutableFst_58set_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_10MutableFst_58set_properties(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_props, PyObject *__pyx_v_mask) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64 __pyx_t_2; uint64 __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_properties", 0); /* "pywrapfst.pyx":2819 * self. * """ * self._mfst.get().SetProperties(props.value, mask.value) # <<<<<<<<<<<<<< * return self * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2819, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_props, __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_uint64_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2819, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_mask, __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_uint64_t(__pyx_t_1); if (unlikely((__pyx_t_3 == ((uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2819, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_self->_mfst.get()->SetProperties(__pyx_t_2, __pyx_t_3); /* "pywrapfst.pyx":2820 * """ * self._mfst.get().SetProperties(props.value, mask.value) * 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":2805 * return self * * def set_properties(self, props, mask): # <<<<<<<<<<<<<< * """ * set_properties(self, props, mask) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":2822 * 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_10MutableFst__set_start(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state) { __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_set_start", 0); /* "pywrapfst.pyx":2823 * * cdef void _set_start(self, int64 state) except *: * if not self._mfst.get().SetStart(state): # <<<<<<<<<<<<<< * 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'", "_mfst"); __PYX_ERR(0, 2823, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->SetStart(__pyx_v_state) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2824 * cdef void _set_start(self, int64 state) except *: * if not self._mfst.get().SetStart(state): * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<< * * def set_start(self, int64 state): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2824, __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, 2824, __pyx_L1_error) /* "pywrapfst.pyx":2823 * * cdef void _set_start(self, int64 state) except *: * if not self._mfst.get().SetStart(state): # <<<<<<<<<<<<<< * raise FstIndexError("State index out of range") * */ } /* "pywrapfst.pyx":2822 * 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_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.MutableFst._set_start", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2826 * raise FstIndexError("State index out of range") * * def set_start(self, int64 state): # <<<<<<<<<<<<<< * """ * set_start(self, state) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_61set_start(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_60set_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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_61set_start(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) { int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2826, __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_10MutableFst_60set_start(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), ((int64)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_60set_start(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, int64 __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_start", 0); /* "pywrapfst.pyx":2841 * FstIndexError: State index out of range. * """ * 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, 2841, __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, 2841, __pyx_L1_error) /* "pywrapfst.pyx":2842 * """ * self._set_start(state) * return self # <<<<<<<<<<<<<< * * cdef void _topsort(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2826 * raise FstIndexError("State index out of range") * * 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":2844 * return self * * cdef void _topsort(self): # <<<<<<<<<<<<<< * # 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_10MutableFst__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; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_topsort", 0); /* "pywrapfst.pyx":2846 * cdef void _topsort(self): * # 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") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2846, __pyx_L1_error) } __pyx_t_1 = ((!(fst::script::TopSort(__pyx_v_self->_mfst.get()) != 0)) != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":2847 * # 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") # <<<<<<<<<<<<<< * * def topsort(self): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_logging); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2847, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_warning); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2847, __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 && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_kp_u_Cannot_topsort_cyclic_FST) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_Cannot_topsort_cyclic_FST); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2847, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2846 * cdef void _topsort(self): * # 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") * */ } /* "pywrapfst.pyx":2844 * return self * * cdef void _topsort(self): # <<<<<<<<<<<<<< * # 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_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pywrapfst.MutableFst._topsort", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":2849 * logging.warning("Cannot topsort cyclic FST") * * def topsort(self): # <<<<<<<<<<<<<< * """ * topsort(self) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_63topsort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_62topsort[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_63topsort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("topsort (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_62topsort(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_62topsort(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("topsort", 0); /* "pywrapfst.pyx":2862 * self. * """ * 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, 2862, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_topsort(__pyx_v_self); /* "pywrapfst.pyx":2863 * """ * self._topsort() * return self # <<<<<<<<<<<<<< * * def union(self, *fsts2): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2849 * logging.warning("Cannot topsort cyclic FST") * * 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":2865 * return self * * def union(self, *fsts2): # <<<<<<<<<<<<<< * """ * union(self, *fsts2) */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_10MutableFst_65union(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_10MutableFst_64union[] = "\n union(self, *fsts2)\n\n Computes the union (sum) of two or more FSTs.\n\n This operation computes the union of two or more FSTs. If A transduces\n string x to y with weight a and B transduces string w to v with weight b,\n then their union transduces x to y with weight a and w to v with weight b.\n\n Args:\n *fsts2: One or more input FSTs.\n\n Returns:\n self.\n "; static PyObject *__pyx_pw_9pywrapfst_10MutableFst_65union(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_fsts2 = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("union (wrapper)", 0); if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "union", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_fsts2 = __pyx_args; __pyx_r = __pyx_pf_9pywrapfst_10MutableFst_64union(((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_v_self), __pyx_v_fsts2); /* function exit code */ __Pyx_XDECREF(__pyx_v_fsts2); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_10MutableFst_64union(struct __pyx_obj_9pywrapfst_MutableFst *__pyx_v_self, PyObject *__pyx_v_fsts2) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v__fst2 = 0; std::vector<__pyx_t_9pywrapfst_const_FstClass_ptr> __pyx_v__fsts2; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("union", 0); /* "pywrapfst.pyx":2883 * cdef Fst _fst2 * cdef vector[const_FstClass_ptr] _fsts2 * for _fst2 in fsts2: # <<<<<<<<<<<<<< * _fsts2.push_back(_fst2._fst.get()) * fst.Union(self._mfst.get(), _fsts2) */ __pyx_t_1 = __pyx_v_fsts2; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= 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_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 2883, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2883, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pywrapfst_Fst))))) __PYX_ERR(0, 2883, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v__fst2, ((struct __pyx_obj_9pywrapfst_Fst *)__pyx_t_3)); __pyx_t_3 = 0; /* "pywrapfst.pyx":2884 * cdef vector[const_FstClass_ptr] _fsts2 * for _fst2 in fsts2: * _fsts2.push_back(_fst2._fst.get()) # <<<<<<<<<<<<<< * fst.Union(self._mfst.get(), _fsts2) * self._check_mutating_imethod() */ if (unlikely(((PyObject *)__pyx_v__fst2) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2884, __pyx_L1_error) } try { __pyx_v__fsts2.push_back(__pyx_v__fst2->_fst.get()); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 2884, __pyx_L1_error) } /* "pywrapfst.pyx":2883 * cdef Fst _fst2 * cdef vector[const_FstClass_ptr] _fsts2 * for _fst2 in fsts2: # <<<<<<<<<<<<<< * _fsts2.push_back(_fst2._fst.get()) * fst.Union(self._mfst.get(), _fsts2) */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":2885 * for _fst2 in fsts2: * _fsts2.push_back(_fst2._fst.get()) * fst.Union(self._mfst.get(), _fsts2) # <<<<<<<<<<<<<< * self._check_mutating_imethod() * return self */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2885, __pyx_L1_error) } fst::script::Union(__pyx_v_self->_mfst.get(), __pyx_v__fsts2); /* "pywrapfst.pyx":2886 * _fsts2.push_back(_fst2._fst.get()) * fst.Union(self._mfst.get(), _fsts2) * self._check_mutating_imethod() # <<<<<<<<<<<<<< * return 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, 2886, __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, 2886, __pyx_L1_error) /* "pywrapfst.pyx":2887 * fst.Union(self._mfst.get(), _fsts2) * self._check_mutating_imethod() * return self # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":2865 * return self * * def union(self, *fsts2): # <<<<<<<<<<<<<< * """ * union(self, *fsts2) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pywrapfst.MutableFst.union", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v__fst2); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":2903 * """ * * def __init__(self, arc_type="standard"): # <<<<<<<<<<<<<< * cdef unique_ptr[fst.MutableFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(tostring(arc_type))) */ /* Python wrapper */ static int __pyx_pw_9pywrapfst_9VectorFst_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_9pywrapfst_9VectorFst_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_arc_type = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arc_type,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)__pyx_n_u_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 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arc_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, "__init__") < 0)) __PYX_ERR(0, 2903, __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_arc_type = 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, 2903, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst.VectorFst.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_9pywrapfst_9VectorFst___init__(((struct __pyx_obj_9pywrapfst_VectorFst *)__pyx_v_self), __pyx_v_arc_type); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_9pywrapfst_9VectorFst___init__(struct __pyx_obj_9pywrapfst_VectorFst *__pyx_v_self, PyObject *__pyx_v_arc_type) { std::unique_ptr __pyx_v__tfst; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":2905 * def __init__(self, arc_type="standard"): * cdef unique_ptr[fst.MutableFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(tostring(arc_type))) # <<<<<<<<<<<<<< * if _tfst.get().Properties(fst.kError, True) == fst.kError: * raise FstOpError(f"Unknown arc type: {arc_type!r}") */ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2905, __pyx_L1_error) __pyx_v__tfst.reset(new fst::script::VectorFstClass(__pyx_t_1)); /* "pywrapfst.pyx":2906 * cdef unique_ptr[fst.MutableFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(tostring(arc_type))) * if _tfst.get().Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< * raise FstOpError(f"Unknown arc type: {arc_type!r}") * self._fst.reset(_tfst.release()) */ __pyx_t_2 = ((__pyx_v__tfst.get()->Properties(fst::kError, 1) == fst::kError) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":2907 * _tfst.reset(new fst.VectorFstClass(tostring(arc_type))) * if _tfst.get().Properties(fst.kError, True) == fst.kError: * raise FstOpError(f"Unknown arc type: {arc_type!r}") # <<<<<<<<<<<<<< * self._fst.reset(_tfst.release()) * self._mfst = static_pointer_cast[fst.MutableFstClass, */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_arc_type), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_arc_type, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2907, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 2907, __pyx_L1_error) /* "pywrapfst.pyx":2906 * cdef unique_ptr[fst.MutableFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(tostring(arc_type))) * if _tfst.get().Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< * raise FstOpError(f"Unknown arc type: {arc_type!r}") * self._fst.reset(_tfst.release()) */ } /* "pywrapfst.pyx":2908 * if _tfst.get().Properties(fst.kError, True) == fst.kError: * raise FstOpError(f"Unknown arc type: {arc_type!r}") * self._fst.reset(_tfst.release()) # <<<<<<<<<<<<<< * self._mfst = static_pointer_cast[fst.MutableFstClass, * fst.FstClass](self._fst) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2908, __pyx_L1_error) } __pyx_v_self->__pyx_base.__pyx_base._fst.reset(__pyx_v__tfst.release()); /* "pywrapfst.pyx":2910 * self._fst.reset(_tfst.release()) * self._mfst = static_pointer_cast[fst.MutableFstClass, * fst.FstClass](self._fst) # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2910, __pyx_L1_error) } /* "pywrapfst.pyx":2909 * raise FstOpError(f"Unknown arc type: {arc_type!r}") * self._fst.reset(_tfst.release()) * self._mfst = static_pointer_cast[fst.MutableFstClass, # <<<<<<<<<<<<<< * fst.FstClass](self._fst) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_mfst"); __PYX_ERR(0, 2909, __pyx_L1_error) } __pyx_v_self->__pyx_base._mfst = std::static_pointer_cast(__pyx_v_self->__pyx_base.__pyx_base._fst); /* "pywrapfst.pyx":2903 * """ * * def __init__(self, arc_type="standard"): # <<<<<<<<<<<<<< * cdef unique_ptr[fst.MutableFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(tostring(arc_type))) */ /* 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_AddTraceback("pywrapfst.VectorFst.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":2929 * * * cdef Fst _init_Fst(FstClass_ptr tfst): # <<<<<<<<<<<<<< * if tfst.Properties(fst.kError, True) == fst.kError: * 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; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_Fst", 0); /* "pywrapfst.pyx":2930 * * cdef Fst _init_Fst(FstClass_ptr tfst): * if tfst.Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< * raise FstOpError("Operation failed") * cdef Fst _ofst = Fst.__new__(Fst) */ __pyx_t_1 = ((__pyx_v_tfst->Properties(fst::kError, 1) == fst::kError) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2931 * cdef Fst _init_Fst(FstClass_ptr tfst): * if tfst.Properties(fst.kError, True) == fst.kError: * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< * cdef Fst _ofst = Fst.__new__(Fst) * _ofst._fst.reset(tfst) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2931, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Operation_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Operation_failed); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2931, __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, 2931, __pyx_L1_error) /* "pywrapfst.pyx":2930 * * cdef Fst _init_Fst(FstClass_ptr tfst): * if tfst.Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< * raise FstOpError("Operation failed") * cdef Fst _ofst = Fst.__new__(Fst) */ } /* "pywrapfst.pyx":2932 * if tfst.Properties(fst.kError, True) == fst.kError: * raise FstOpError("Operation failed") * cdef Fst _ofst = Fst.__new__(Fst) # <<<<<<<<<<<<<< * _ofst._fst.reset(tfst) * return _ofst */ __pyx_t_2 = ((PyObject *)__pyx_tp_new_9pywrapfst_Fst(((PyTypeObject *)__pyx_ptype_9pywrapfst_Fst), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2932, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_2)); __pyx_v__ofst = ((struct __pyx_obj_9pywrapfst_Fst *)__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2933 * 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, 2933, __pyx_L1_error) } __pyx_v__ofst->_fst.reset(__pyx_v_tfst); /* "pywrapfst.pyx":2934 * 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":2929 * * * cdef Fst _init_Fst(FstClass_ptr tfst): # <<<<<<<<<<<<<< * if tfst.Properties(fst.kError, True) == fst.kError: * raise FstOpError("Operation failed") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __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":2937 * * * cdef MutableFst _init_MutableFst(MutableFstClass_ptr tfst): # <<<<<<<<<<<<<< * if tfst.Properties(fst.kError, True) == fst.kError: * 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; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_MutableFst", 0); /* "pywrapfst.pyx":2938 * * cdef MutableFst _init_MutableFst(MutableFstClass_ptr tfst): * if tfst.Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< * raise FstOpError("Operation failed") * cdef MutableFst _ofst = MutableFst.__new__(MutableFst) */ __pyx_t_1 = ((__pyx_v_tfst->Properties(fst::kError, 1) == fst::kError) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2939 * cdef MutableFst _init_MutableFst(MutableFstClass_ptr tfst): * if tfst.Properties(fst.kError, True) == fst.kError: * raise FstOpError("Operation failed") # <<<<<<<<<<<<<< * cdef MutableFst _ofst = MutableFst.__new__(MutableFst) * _ofst._fst.reset(tfst) */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2939, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Operation_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Operation_failed); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2939, __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, 2939, __pyx_L1_error) /* "pywrapfst.pyx":2938 * * cdef MutableFst _init_MutableFst(MutableFstClass_ptr tfst): * if tfst.Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<< * raise FstOpError("Operation failed") * cdef MutableFst _ofst = MutableFst.__new__(MutableFst) */ } /* "pywrapfst.pyx":2940 * if tfst.Properties(fst.kError, True) == fst.kError: * 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_2 = ((PyObject *)__pyx_tp_new_9pywrapfst_MutableFst(((PyTypeObject *)__pyx_ptype_9pywrapfst_MutableFst), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2940, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_2)); __pyx_v__ofst = ((struct __pyx_obj_9pywrapfst_MutableFst *)__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2941 * 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, */ if (unlikely(((PyObject *)__pyx_v__ofst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 2941, __pyx_L1_error) } __pyx_v__ofst->__pyx_base._fst.reset(__pyx_v_tfst); /* "pywrapfst.pyx":2944 * # 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, 2944, __pyx_L1_error) } /* "pywrapfst.pyx":2943 * _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'", "_mfst"); __PYX_ERR(0, 2943, __pyx_L1_error) } __pyx_v__ofst->_mfst = std::static_pointer_cast(__pyx_v__ofst->__pyx_base._fst); /* "pywrapfst.pyx":2945 * _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":2937 * * * cdef MutableFst _init_MutableFst(MutableFstClass_ptr tfst): # <<<<<<<<<<<<<< * if tfst.Properties(fst.kError, True) == fst.kError: * raise FstOpError("Operation failed") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __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":2948 * * * cdef Fst _init_XFst(FstClass_ptr tfst): # <<<<<<<<<<<<<< * if tfst.Properties(fst.kMutable, True) == fst.kMutable: * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_XFst", 0); /* "pywrapfst.pyx":2949 * * cdef Fst _init_XFst(FstClass_ptr tfst): * if tfst.Properties(fst.kMutable, True) == fst.kMutable: # <<<<<<<<<<<<<< * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) * else: */ __pyx_t_1 = ((__pyx_v_tfst->Properties(fst::kMutable, 1) == fst::kMutable) != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":2950 * cdef Fst _init_XFst(FstClass_ptr tfst): * if tfst.Properties(fst.kMutable, True) == fst.kMutable: * 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, 2950, __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":2949 * * cdef Fst _init_XFst(FstClass_ptr tfst): * if tfst.Properties(fst.kMutable, True) == fst.kMutable: # <<<<<<<<<<<<<< * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) * else: */ } /* "pywrapfst.pyx":2952 * 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, 2952, __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":2948 * * * cdef Fst _init_XFst(FstClass_ptr tfst): # <<<<<<<<<<<<<< * if tfst.Properties(fst.kMutable, True) == fst.kMutable: * 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":2955 * * * cpdef Fst _read_Fst(source): # <<<<<<<<<<<<<< * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.Read(path_tostring(source))) */ static PyObject *__pyx_pw_9pywrapfst_17_read_Fst(PyObject *__pyx_self, PyObject *__pyx_v_source); /*proto*/ static struct __pyx_obj_9pywrapfst_Fst *__pyx_f_9pywrapfst__read_Fst(PyObject *__pyx_v_source, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_Fst", 0); /* "pywrapfst.pyx":2957 * cpdef Fst _read_Fst(source): * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.Read(path_tostring(source))) # <<<<<<<<<<<<<< * if _tfst.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") */ __pyx_t_1 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2957, __pyx_L1_error) __pyx_v__tfst.reset(fst::script::FstClass::Read(__pyx_t_1)); /* "pywrapfst.pyx":2958 * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.Read(path_tostring(source))) * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_XFst(_tfst.release()) */ __pyx_t_2 = ((__pyx_v__tfst.get() == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":2959 * _tfst.reset(fst.FstClass.Read(path_tostring(source))) * if _tfst.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") # <<<<<<<<<<<<<< * return _init_XFst(_tfst.release()) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Read_failed, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2959, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 2959, __pyx_L1_error) /* "pywrapfst.pyx":2958 * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.Read(path_tostring(source))) * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {source!r}") * return _init_XFst(_tfst.release()) */ } /* "pywrapfst.pyx":2960 * if _tfst.get() == NULL: * raise FstIOError(f"Read failed: {source!r}") * 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, 2960, __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":2955 * * * cpdef Fst _read_Fst(source): # <<<<<<<<<<<<<< * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.Read(path_tostring(source))) */ /* 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_AddTraceback("pywrapfst._read_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_17_read_Fst(PyObject *__pyx_self, PyObject *__pyx_v_source); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_17_read_Fst(PyObject *__pyx_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_read_Fst (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_16_read_Fst(__pyx_self, ((PyObject *)__pyx_v_source)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_16_read_Fst(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_source) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_Fst", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read_Fst(__pyx_v_source, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2955, __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_Fst", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":2963 * * * cpdef Fst _read_Fst_from_string(string state): # <<<<<<<<<<<<<< * cdef stringstream _sstrm * _sstrm << state */ static PyObject *__pyx_pw_9pywrapfst_19_read_Fst_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state); /*proto*/ static struct __pyx_obj_9pywrapfst_Fst *__pyx_f_9pywrapfst__read_Fst_from_string(std::string __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 int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_Fst_from_string", 0); /* "pywrapfst.pyx":2965 * cpdef Fst _read_Fst_from_string(string state): * cdef stringstream _sstrm * _sstrm << state # <<<<<<<<<<<<<< * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.ReadStream(_sstrm, b"")) */ (void)((__pyx_v__sstrm << __pyx_v_state)); /* "pywrapfst.pyx":2967 * _sstrm << state * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.ReadStream(_sstrm, b"")) # <<<<<<<<<<<<<< * if _tfst.get() == NULL: * raise FstIOError("Read from string failed") */ __pyx_v__tfst.reset(fst::script::FstClass::Read(__pyx_v__sstrm, __pyx_k_pywrapfst)); /* "pywrapfst.pyx":2968 * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.ReadStream(_sstrm, b"")) * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError("Read from string failed") * return _init_XFst(_tfst.release()) */ __pyx_t_1 = ((__pyx_v__tfst.get() == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":2969 * _tfst.reset(fst.FstClass.ReadStream(_sstrm, b"")) * if _tfst.get() == NULL: * raise FstIOError("Read from string failed") # <<<<<<<<<<<<<< * return _init_XFst(_tfst.release()) * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Read_from_string_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Read_from_string_failed); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2969, __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, 2969, __pyx_L1_error) /* "pywrapfst.pyx":2968 * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.FstClass.ReadStream(_sstrm, b"")) * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError("Read from string failed") * return _init_XFst(_tfst.release()) */ } /* "pywrapfst.pyx":2970 * if _tfst.get() == NULL: * raise FstIOError("Read from string failed") * return _init_XFst(_tfst.release()) # <<<<<<<<<<<<<< * * */ __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, 2970, __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":2963 * * * cpdef Fst _read_Fst_from_string(string state): # <<<<<<<<<<<<<< * cdef stringstream _sstrm * _sstrm << state */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst._read_Fst_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_19_read_Fst_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_19_read_Fst_from_string(PyObject *__pyx_self, PyObject *__pyx_arg_state) { std::string __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_read_Fst_from_string (wrapper)", 0); assert(__pyx_arg_state); { __pyx_v_state = __pyx_convert_string_from_py_std__in_string(__pyx_arg_state); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2963, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("pywrapfst._read_Fst_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_9pywrapfst_18_read_Fst_from_string(__pyx_self, ((std::string)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18_read_Fst_from_string(CYTHON_UNUSED PyObject *__pyx_self, std::string __pyx_v_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_read_Fst_from_string", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__read_Fst_from_string(__pyx_v_state, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2963, __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_Fst_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":3089 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":3090 * * def __repr__(self): * return f"" # <<<<<<<<<<<<<< * * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3090, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_Arc_at_0x); __pyx_t_2 += 10; __Pyx_GIVEREF(__pyx_kp_u_Arc_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Arc_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3090, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3090, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3090, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3089 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":3092 * return f"" * * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): # <<<<<<<<<<<<<< * cdef fst.WeightClass _weight = _get_WeightClass_or_one(b"tropical", weight) * self._arc.reset(new fst.ArcClass(ilabel, olabel, _weight, 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) { int64 __pyx_v_ilabel; int64 __pyx_v_olabel; PyObject *__pyx_v_weight = 0; int64 __pyx_v_nextstate; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ilabel)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_olabel)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(0, 3092, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weight)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(0, 3092, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nextstate)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(0, 3092, __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, 3092, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3092, __pyx_L3_error) __pyx_v_olabel = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_olabel == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3092, __pyx_L3_error) __pyx_v_weight = values[2]; __pyx_v_nextstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nextstate == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3092, __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, 3092, __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, int64 __pyx_v_ilabel, int64 __pyx_v_olabel, PyObject *__pyx_v_weight, int64 __pyx_v_nextstate) { fst::script::WeightClass __pyx_v__weight; int __pyx_r; __Pyx_RefNannyDeclarations fst::script::WeightClass __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":3093 * * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): * cdef fst.WeightClass _weight = _get_WeightClass_or_one(b"tropical", weight) # <<<<<<<<<<<<<< * self._arc.reset(new fst.ArcClass(ilabel, olabel, _weight, nextstate)) * */ __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_one(__pyx_k_tropical, __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3093, __pyx_L1_error) __pyx_v__weight = __pyx_t_1; /* "pywrapfst.pyx":3094 * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): * cdef fst.WeightClass _weight = _get_WeightClass_or_one(b"tropical", weight) * self._arc.reset(new fst.ArcClass(ilabel, olabel, _weight, 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, 3094, __pyx_L1_error) } __pyx_v_self->_arc.reset(new fst::script::ArcClass(__pyx_v_ilabel, __pyx_v_olabel, __pyx_v__weight, __pyx_v_nextstate)); /* "pywrapfst.pyx":3092 * return f"" * * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): # <<<<<<<<<<<<<< * cdef fst.WeightClass _weight = _get_WeightClass_or_one(b"tropical", weight) * self._arc.reset(new fst.ArcClass(ilabel, olabel, _weight, 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":3096 * self._arc.reset(new fst.ArcClass(ilabel, olabel, _weight, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3096, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3096, __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, 3096, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3097 * * 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, 3097, __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, 3097, __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, 3097, __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, 3097, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3097, __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, 3097, __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":3096 * self._arc.reset(new fst.ArcClass(ilabel, olabel, _weight, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3096, __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":3101 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pywrapfst.pyx":3102 * * 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, 3102, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).ilabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3101 * 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":3104 * 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) { int64 __pyx_v_value; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3104, __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), ((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, int64 __pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pywrapfst.pyx":3105 * * 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, 3105, __pyx_L1_error) } (*__pyx_v_self->_arc).ilabel = __pyx_v_value; /* "pywrapfst.pyx":3104 * 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":3109 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pywrapfst.pyx":3110 * * 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, 3110, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).olabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3109 * 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":3112 * 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) { int64 __pyx_v_value; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3112, __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), ((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, int64 __pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pywrapfst.pyx":3113 * * 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, 3113, __pyx_L1_error) } (*__pyx_v_self->_arc).olabel = __pyx_v_value; /* "pywrapfst.pyx":3112 * 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":3117 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pywrapfst.pyx":3118 * * def __get__(self): * cdef Weight _weight = Weight.__new__(Weight) # <<<<<<<<<<<<<< * _weight._weight.reset(new fst.WeightClass(deref(self._arc).weight)) * return _weight */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3118, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":3119 * 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, 3119, __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, 3119, __pyx_L1_error) } __pyx_v__weight->_weight.reset(new fst::script::WeightClass((*__pyx_v_self->_arc).weight)); /* "pywrapfst.pyx":3120 * 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":3117 * 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":3122 * 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 fst::script::WeightClass __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pywrapfst.pyx":3123 * * def __set__(self, weight): * deref(self._arc).weight = _get_WeightClass_or_one(b"tropical", weight) # <<<<<<<<<<<<<< * * property nextstate: */ __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_one(__pyx_k_tropical, __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3123, __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, 3123, __pyx_L1_error) } (*__pyx_v_self->_arc).weight = __pyx_t_1; /* "pywrapfst.pyx":3122 * 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":3127 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pywrapfst.pyx":3128 * * 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, 3128, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).nextstate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3127 * 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":3130 * 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) { int64 __pyx_v_value; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3130, __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), ((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, int64 __pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pywrapfst.pyx":3131 * * 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, 3131, __pyx_L1_error) } (*__pyx_v_self->_arc).nextstate = __pyx_v_value; /* "pywrapfst.pyx":3130 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__24, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__25, 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":3134 * * * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_init_Arc", 0); /* "pywrapfst.pyx":3135 * * 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 = ((PyObject *)__pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3135, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v__weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":3136 * 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, 3136, __pyx_L1_error) } __pyx_v__weight->_weight.reset(new fst::script::WeightClass(__pyx_v_arc.weight)); /* "pywrapfst.pyx":3137 * 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, 3137, __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, 3137, __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, 3137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3137, __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, 3137, __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":3134 * * * 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":3148 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":3149 * * def __repr__(self): * return f"" # <<<<<<<<<<<<<< * * def __init__(self, Fst ifst, int64 state): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_ArcIterator_at_0x); __pyx_t_2 += 18; __Pyx_GIVEREF(__pyx_kp_u_ArcIterator_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_ArcIterator_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3148 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":3151 * return f"" * * 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; int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 3151, __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, 3151, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3151, __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, 3151, __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, 3151, __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, int64 __pyx_v_state) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; std::shared_ptr __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":3152 * * 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, 3152, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_ifst->_fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":3153 * 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3153, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3153, __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, 3153, __pyx_L1_error) /* "pywrapfst.pyx":3152 * * 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":3155 * 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, 3155, __pyx_L1_error) } __pyx_t_5 = __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, 3155, __pyx_L1_error) } __pyx_v_self->_fst = __pyx_t_5; /* "pywrapfst.pyx":3156 * # 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, 3156, __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, 3156, __pyx_L1_error) } __pyx_v_self->_aiter.reset(new fst::script::ArcIteratorClass((*__pyx_v_self->_fst), __pyx_v_state)); /* "pywrapfst.pyx":3151 * return f"" * * 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_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.ArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":3159 * * # 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":3160 * # 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":3159 * * # 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":3163 * * # 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__next__", 0); /* "pywrapfst.pyx":3164 * # 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, 3164, __pyx_L1_error) } __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_ArcIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":3165 * def __next__(self): * if self.done(): * raise StopIteration # <<<<<<<<<<<<<< * result = self.value() * self.next() */ __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); __PYX_ERR(0, 3165, __pyx_L1_error) /* "pywrapfst.pyx":3164 * # 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":3166 * 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, 3166, __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, 3166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_result = __pyx_t_2; __pyx_t_2 = 0; /* "pywrapfst.pyx":3167 * 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, 3167, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_ArcIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0); /* "pywrapfst.pyx":3168 * 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":3163 * * # 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":3170 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3170, __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, 3170, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3179 * True if the iterator is exhausted, False otherwise. * """ * return self._aiter.get().Done() # <<<<<<<<<<<<<< * * cpdef uint8 flags(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); __PYX_ERR(0, 3179, __pyx_L1_error) } __pyx_r = __pyx_v_self->_aiter.get()->Done(); goto __pyx_L0; /* "pywrapfst.pyx":3170 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3170, __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":3181 * return self._aiter.get().Done() * * cpdef uint8 flags(self): # <<<<<<<<<<<<<< * """ * flags(self) */ static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static uint8 __pyx_f_9pywrapfst_11ArcIterator_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { uint8 __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; uint8 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyInt_As_uint8_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3181, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3190 * 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, 3190, __pyx_L1_error) } __pyx_r = __pyx_v_self->_aiter.get()->Flags(); goto __pyx_L0; /* "pywrapfst.pyx":3181 * return self._aiter.get().Done() * * cpdef uint8 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("flags", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_uint8_t(__pyx_f_9pywrapfst_11ArcIterator_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3181, __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":3192 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3192, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3192, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3198 * 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, 3198, __pyx_L1_error) } __pyx_v_self->_aiter.get()->Next(); /* "pywrapfst.pyx":3192 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3192, __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":3200 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3200, __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, 3200, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3209 * 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, 3209, __pyx_L1_error) } __pyx_r = __pyx_v_self->_aiter.get()->Position(); goto __pyx_L0; /* "pywrapfst.pyx":3200 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3200, __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":3211 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3211, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3211, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3217 * 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, 3217, __pyx_L1_error) } __pyx_v_self->_aiter.get()->Reset(); /* "pywrapfst.pyx":3211 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3211, __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":3219 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_seek); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_11ArcIterator_19seek)) { __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3219, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3219, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3228 * a: The position to seek to. * """ * self._aiter.get().Seek(a) # <<<<<<<<<<<<<< * * cpdef void set_flags(self, uint8 flags, uint8 mask): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); __PYX_ERR(0, 3228, __pyx_L1_error) } __pyx_v_self->_aiter.get()->Seek(__pyx_v_a); /* "pywrapfst.pyx":3219 * 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_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 3219, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3219, __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":3230 * self._aiter.get().Seek(a) * * cpdef void set_flags(self, uint8 flags, uint8 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, uint8 __pyx_v_flags, uint8 __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_11ArcIterator_21set_flags)) { __pyx_t_3 = __Pyx_PyInt_From_uint8_t(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_uint8_t(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3230, __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, 3230, __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, 3230, __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, 3230, __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, 3230, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3240 * 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, 3240, __pyx_L1_error) } __pyx_v_self->_aiter.get()->SetFlags(__pyx_v_flags, __pyx_v_mask); /* "pywrapfst.pyx":3230 * self._aiter.get().Seek(a) * * cpdef void set_flags(self, uint8 flags, uint8 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) { uint8 __pyx_v_flags; uint8 __pyx_v_mask; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, 1); __PYX_ERR(0, 3230, __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, 3230, __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_uint8_t(values[0]); if (unlikely((__pyx_v_flags == ((uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3230, __pyx_L3_error) __pyx_v_mask = __Pyx_PyInt_As_uint8_t(values[1]); if (unlikely((__pyx_v_mask == ((uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3230, __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, 3230, __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, uint8 __pyx_v_flags, uint8 __pyx_v_mask) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3230, __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":3242 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3242, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3248 * 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, 3248, __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, 3248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3242 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3242, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__26, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__27, 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":3260 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":3261 * * def __repr__(self): * return f"" # <<<<<<<<<<<<<< * * def __init__(self, MutableFst ifst, int64 state): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_MutableArcIterator_at_0x); __pyx_t_2 += 25; __Pyx_GIVEREF(__pyx_kp_u_MutableArcIterator_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_MutableArcIterator_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3260 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":3263 * return f"" * * 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; int64 __pyx_v_state; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 3263, __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, 3263, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3263, __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, 3263, __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, 3263, __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, int64 __pyx_v_state) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; std::shared_ptr __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":3264 * * 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, 3264, __pyx_L1_error) } __pyx_t_1 = ((!(__pyx_v_ifst->__pyx_base._fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":3265 * 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_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_State_index_out_of_range) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_State_index_out_of_range); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3265, __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, 3265, __pyx_L1_error) /* "pywrapfst.pyx":3264 * * 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":3267 * 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, 3267, __pyx_L1_error) } __pyx_t_5 = __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, 3267, __pyx_L1_error) } __pyx_v_self->_mfst = __pyx_t_5; /* "pywrapfst.pyx":3268 * # 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)) # <<<<<<<<<<<<<< * * # Magic method used to get a Pythonic Iterator API out of the C++ API. */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); __PYX_ERR(0, 3268, __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, 3268, __pyx_L1_error) } __pyx_v_self->_aiter.reset(new fst::script::MutableArcIteratorClass(__pyx_v_ifst->_mfst.get(), __pyx_v_state)); /* "pywrapfst.pyx":3263 * return f"" * * 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_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_9pywrapfst_18MutableArcIterator_6generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "pywrapfst.pyx":3271 * * # Magic method used to get a Pythonic Iterator API out of the C++ API. * def __iter__(self): # <<<<<<<<<<<<<< * while not self.done(): * yield self.value() */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_5__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_5__iter__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_4__iter__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_4__iter__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__iter__", 0); __pyx_cur_scope = (struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *)__pyx_tp_new_9pywrapfst___pyx_scope_struct____iter__(__pyx_ptype_9pywrapfst___pyx_scope_struct____iter__, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(0, 3271, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_self = __pyx_v_self; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); { __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9pywrapfst_18MutableArcIterator_6generator, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_iter, __pyx_n_s_MutableArcIterator___iter, __pyx_n_s_pywrapfst_2); if (unlikely(!gen)) __PYX_ERR(0, 3271, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_9pywrapfst_18MutableArcIterator_6generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *__pyx_cur_scope = ((struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *)__pyx_generator->closure); PyObject *__pyx_r = NULL; int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L6_resume_from_yield; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3271, __pyx_L1_error) /* "pywrapfst.pyx":3272 * # Magic method used to get a Pythonic Iterator API out of the C++ API. * def __iter__(self): * while not self.done(): # <<<<<<<<<<<<<< * yield self.value() * self.next() */ while (1) { if (unlikely(((PyObject *)__pyx_cur_scope->__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "done"); __PYX_ERR(0, 3272, __pyx_L1_error) } __pyx_t_1 = ((!(((struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->done(__pyx_cur_scope->__pyx_v_self, 0) != 0)) != 0); if (!__pyx_t_1) break; /* "pywrapfst.pyx":3273 * def __iter__(self): * while not self.done(): * yield self.value() # <<<<<<<<<<<<<< * self.next() * */ if (unlikely(((PyObject *)__pyx_cur_scope->__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "value"); __PYX_ERR(0, 3273, __pyx_L1_error) } __pyx_t_2 = ((struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->value(__pyx_cur_scope->__pyx_v_self, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, yielding value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L6_resume_from_yield:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 3273, __pyx_L1_error) /* "pywrapfst.pyx":3274 * while not self.done(): * yield self.value() * self.next() # <<<<<<<<<<<<<< * * cpdef bool done(self): */ if (unlikely(((PyObject *)__pyx_cur_scope->__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "next"); __PYX_ERR(0, 3274, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->next(__pyx_cur_scope->__pyx_v_self, 0); } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "pywrapfst.pyx":3271 * * # Magic method used to get a Pythonic Iterator API out of the C++ API. * def __iter__(self): # <<<<<<<<<<<<<< * while not self.done(): * yield self.value() */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":3276 * self.next() * * cpdef bool done(self): # <<<<<<<<<<<<<< * """ * done(self) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_8done(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_8done)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3276, __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, 3276, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3285 * True if the iterator is exhausted, False otherwise. * """ * return self._aiter.get().Done() # <<<<<<<<<<<<<< * * cpdef uint8 flags(self): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); __PYX_ERR(0, 3285, __pyx_L1_error) } __pyx_r = __pyx_v_self->_aiter.get()->Done(); goto __pyx_L0; /* "pywrapfst.pyx":3276 * self.next() * * 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_8done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_7done[] = "\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_8done(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_7done(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_7done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3276, __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":3287 * return self._aiter.get().Done() * * cpdef uint8 flags(self): # <<<<<<<<<<<<<< * """ * flags(self) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_10flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static uint8 __pyx_f_9pywrapfst_18MutableArcIterator_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) { uint8 __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; uint8 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_10flags)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyInt_As_uint8_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3287, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3296 * 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, 3296, __pyx_L1_error) } __pyx_r = __pyx_v_self->_aiter.get()->Flags(); goto __pyx_L0; /* "pywrapfst.pyx":3287 * return self._aiter.get().Done() * * cpdef uint8 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_10flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_9flags[] = "\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_10flags(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_9flags(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_9flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("flags", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_uint8_t(__pyx_f_9pywrapfst_18MutableArcIterator_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3287, __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":3298 * return self._aiter.get().Flags() * * cpdef void next(self): # <<<<<<<<<<<<<< * """ * next(self) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_12next(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_12next)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3298, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3304 * 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, 3304, __pyx_L1_error) } __pyx_v_self->_aiter.get()->Next(); /* "pywrapfst.pyx":3298 * 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_12next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_11next[] = "\n next(self)\n\n Advances the iterator.\n "; static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_12next(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_11next(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_11next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3298, __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":3306 * self._aiter.get().Next() * * cpdef size_t position(self): # <<<<<<<<<<<<<< * """ * position(self) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_14position(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_14position)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3306, __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, 3306, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3315 * 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, 3315, __pyx_L1_error) } __pyx_r = __pyx_v_self->_aiter.get()->Position(); goto __pyx_L0; /* "pywrapfst.pyx":3306 * 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_14position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_13position[] = "\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_14position(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_13position(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_13position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3306, __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":3317 * return self._aiter.get().Position() * * cpdef void reset(self): # <<<<<<<<<<<<<< * """ * reset(self) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_16reset(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_16reset)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3317, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3323 * 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, 3323, __pyx_L1_error) } __pyx_v_self->_aiter.get()->Reset(); /* "pywrapfst.pyx":3317 * 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_16reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_15reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n "; static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_16reset(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_15reset(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_15reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3317, __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":3325 * self._aiter.get().Reset() * * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<< * """ * seek(self, a) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_18seek(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_seek); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_18seek)) { __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3325, __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); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3334 * a: The position to seek to. * """ * self._aiter.get().Seek(a) # <<<<<<<<<<<<<< * * cpdef void set_flags(self, uint8 flags, uint8 mask): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_aiter"); __PYX_ERR(0, 3334, __pyx_L1_error) } __pyx_v_self->_aiter.get()->Seek(__pyx_v_a); /* "pywrapfst.pyx":3325 * 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_WriteUnraisable("pywrapfst.MutableArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_18seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_17seek[] = "\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_18seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a) { size_t __pyx_v_a; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 3325, __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_17seek(((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_17seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3325, __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":3336 * self._aiter.get().Seek(a) * * cpdef void set_flags(self, uint8 flags, uint8 mask): # <<<<<<<<<<<<<< * """ * set_flags(self, flags, mask) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_20set_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, uint8 __pyx_v_flags, uint8 __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_20set_flags)) { __pyx_t_3 = __Pyx_PyInt_From_uint8_t(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3336, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_uint8_t(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3336, __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, 3336, __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, 3336, __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, 3336, __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, 3336, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3346 * 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, 3346, __pyx_L1_error) } __pyx_v_self->_aiter.get()->SetFlags(__pyx_v_flags, __pyx_v_mask); /* "pywrapfst.pyx":3336 * self._aiter.get().Seek(a) * * cpdef void set_flags(self, uint8 flags, uint8 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_20set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_19set_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_20set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { uint8 __pyx_v_flags; uint8 __pyx_v_mask; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, 1); __PYX_ERR(0, 3336, __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, 3336, __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_uint8_t(values[0]); if (unlikely((__pyx_v_flags == ((uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3336, __pyx_L3_error) __pyx_v_mask = __Pyx_PyInt_As_uint8_t(values[1]); if (unlikely((__pyx_v_mask == ((uint8)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3336, __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, 3336, __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_19set_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_19set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, uint8 __pyx_v_flags, uint8 __pyx_v_mask) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3336, __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":3348 * self._aiter.get().SetFlags(flags, mask) * * cpdef void set_value(self, Arc arc): # <<<<<<<<<<<<<< * """ * set_value(self, arc) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_22set_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_22set_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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_arc)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_arc)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3348, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3357 * 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, 3357, __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, 3357, __pyx_L1_error) } __pyx_v_self->_aiter.get()->SetValue((*__pyx_v_arc->_arc)); /* "pywrapfst.pyx":3348 * 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_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_22set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_21set_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_22set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 3348, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_21set_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_21set_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3348, __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":3359 * self._aiter.get().SetValue(deref(arc._arc)) * * cpdef object value(self): # <<<<<<<<<<<<<< * """ * value(self) */ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_24value(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3359, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_9pywrapfst_18MutableArcIterator_24value)) { __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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3359, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3365 * 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, 3365, __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, 3365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3359 * 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_24value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_9pywrapfst_18MutableArcIterator_23value[] = "\n value(self)\n\n Returns the current arc.\n "; static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_24value(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_23value(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_23value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3359, __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_26__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_26__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_25__reduce_cython__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_25__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__28, 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_28__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_28__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_27__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_27__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__29, 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":3379 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":3380 * * def __repr__(self): * return f"" # <<<<<<<<<<<<<< * * def __init__(self, Fst ifst): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u_StateIterator_at_0x); __pyx_t_2 += 20; __Pyx_GIVEREF(__pyx_kp_u_StateIterator_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_StateIterator_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3380, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3379 * """ * * def __repr__(self): # <<<<<<<<<<<<<< * return f"" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __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":3382 * return f"" * * 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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__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, 3382, __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, 3382, __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, 3382, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":3384 * 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, 3384, __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, 3384, __pyx_L1_error) } __pyx_v_self->_fst = __pyx_t_1; /* "pywrapfst.pyx":3385 * # 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, 3385, __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, 3385, __pyx_L1_error) } __pyx_v_self->_siter.reset(new fst::script::StateIteratorClass((*__pyx_v_self->_fst))); /* "pywrapfst.pyx":3382 * return f"" * * 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":3388 * * # 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":3389 * # 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":3388 * * # 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":3392 * * # 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) { int64 __pyx_v_result; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__next__", 0); /* "pywrapfst.pyx":3393 * # 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, 3393, __pyx_L1_error) } __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":3394 * 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, 3394, __pyx_L1_error) /* "pywrapfst.pyx":3393 * # 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":3395 * 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, 3395, __pyx_L1_error) } __pyx_v_result = ((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->value(__pyx_v_self, 0); /* "pywrapfst.pyx":3396 * 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, 3396, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0); /* "pywrapfst.pyx":3397 * 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, 3397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":3392 * * # 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":3399 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3399, __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, 3399, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3408 * 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, 3408, __pyx_L1_error) } __pyx_r = __pyx_v_self->_siter.get()->Done(); goto __pyx_L0; /* "pywrapfst.pyx":3399 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3399, __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":3410 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3410, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3410, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3416 * 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, 3416, __pyx_L1_error) } __pyx_v_self->_siter.get()->Next(); /* "pywrapfst.pyx":3410 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3410, __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":3418 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3418, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3424 * 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, 3424, __pyx_L1_error) } __pyx_v_self->_siter.get()->Reset(); /* "pywrapfst.pyx":3418 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3418, __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":3426 * 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 int64 __pyx_f_9pywrapfst_13StateIterator_value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) { 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; int64 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3426, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3426, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":3432 * 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, 3432, __pyx_L1_error) } __pyx_r = __pyx_v_self->_siter.get()->Value(); goto __pyx_L0; /* "pywrapfst.pyx":3426 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3426, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__30, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__31, 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":3438 * * * cdef Fst _map(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * map_type="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__32; PyObject *__pyx_v_map_type = ((PyObject *)__pyx_n_u_identity); double __pyx_v_power = ((double)1.); /* "pywrapfst.pyx":3442 * map_type="identity", * double power=1., * weight=None): # <<<<<<<<<<<<<< * cdef fst.MapType _map_type * if not fst.GetMapType(tostring(map_type), addr(_map_type)): */ PyObject *__pyx_v_weight = ((PyObject *)Py_None); enum fst::script::MapType __pyx_v__map_type; fst::script::WeightClass __pyx_v__weight; 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; fst::script::WeightClass __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3444 * weight=None): * cdef fst.MapType _map_type * if not fst.GetMapType(tostring(map_type), addr(_map_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown map type: {map_type!r}") * cdef fst.WeightClass _weight */ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_map_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3444, __pyx_L1_error) __pyx_t_2 = ((!(fst::script::GetMapType(__pyx_t_1, (&__pyx_v__map_type)) != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":3445 * cdef fst.MapType _map_type * if not fst.GetMapType(tostring(map_type), addr(_map_type)): * raise FstArgError(f"Unknown map type: {map_type!r}") # <<<<<<<<<<<<<< * cdef fst.WeightClass _weight * if _map_type == fst.TIMES_MAPPER: */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_map_type), __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_map_type, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3445, __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 && 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_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 3445, __pyx_L1_error) /* "pywrapfst.pyx":3444 * weight=None): * cdef fst.MapType _map_type * if not fst.GetMapType(tostring(map_type), addr(_map_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown map type: {map_type!r}") * cdef fst.WeightClass _weight */ } /* "pywrapfst.pyx":3447 * raise FstArgError(f"Unknown map type: {map_type!r}") * cdef fst.WeightClass _weight * if _map_type == fst.TIMES_MAPPER: # <<<<<<<<<<<<<< * _weight = _get_WeightClass_or_one(ifst.weight_type(), weight) * else: */ __pyx_t_2 = ((__pyx_v__map_type == fst::script::TIMES_MAPPER) != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":3448 * cdef fst.WeightClass _weight * if _map_type == fst.TIMES_MAPPER: * _weight = _get_WeightClass_or_one(ifst.weight_type(), weight) # <<<<<<<<<<<<<< * else: * _weight = _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, 3448, __pyx_L1_error) } __pyx_t_7 = __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, 3448, __pyx_L1_error) __pyx_v__weight = __pyx_t_7; /* "pywrapfst.pyx":3447 * raise FstArgError(f"Unknown map type: {map_type!r}") * cdef fst.WeightClass _weight * if _map_type == fst.TIMES_MAPPER: # <<<<<<<<<<<<<< * _weight = _get_WeightClass_or_one(ifst.weight_type(), weight) * else: */ goto __pyx_L4; } /* "pywrapfst.pyx":3450 * _weight = _get_WeightClass_or_one(ifst.weight_type(), weight) * else: * _weight = _get_WeightClass_or_zero(ifst.weight_type(), weight) # <<<<<<<<<<<<<< * return _init_XFst(fst.Map(deref(ifst._fst), _map_type, delta, power, _weight)) * */ /*else*/ { if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); __PYX_ERR(0, 3450, __pyx_L1_error) } __pyx_t_7 = __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, 3450, __pyx_L1_error) __pyx_v__weight = __pyx_t_7; } __pyx_L4:; /* "pywrapfst.pyx":3451 * else: * _weight = _get_WeightClass_or_zero(ifst.weight_type(), weight) * return _init_XFst(fst.Map(deref(ifst._fst), _map_type, delta, power, _weight)) # <<<<<<<<<<<<<< * * */ __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, 3451, __pyx_L1_error) } __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(fst::script::Map((*__pyx_v_ifst->_fst), __pyx_v__map_type, __pyx_v_delta, __pyx_v_power, __pyx_v__weight))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3451, __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":3438 * * * cdef Fst _map(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * map_type="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_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":3454 * * * cpdef Fst arcmap(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * map_type="identity", */ static PyObject *__pyx_pw_9pywrapfst_21arcmap(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__33; PyObject *__pyx_v_map_type = ((PyObject *)__pyx_n_u_identity); double __pyx_v_power = ((double)1.); /* "pywrapfst.pyx":3458 * map_type="identity", * double power=1., * weight=None): # <<<<<<<<<<<<<< * """ * arcmap(ifst, delta=0.0009765625, map_type="identity", power=1., 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3498 * FstArgError: Unknown map type. * """ * 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, 3498, __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":3454 * * * cpdef Fst arcmap(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * map_type="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_21arcmap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_20arcmap[] = "\n arcmap(ifst, delta=0.0009765625, map_type=\"identity\", power=1., 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 * 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 a 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 by all weights.\n * to_log: converts weights to the log semiring.\n * to_log64: converts weights to the log64 semiring.\n * to_std: converts weights to the tropical 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 `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 "; static PyObject *__pyx_pw_9pywrapfst_21arcmap(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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_u_identity); /* "pywrapfst.pyx":3458 * map_type="identity", * double power=1., * weight=None): # <<<<<<<<<<<<<< * """ * arcmap(ifst, delta=0.0009765625, map_type="identity", power=1., 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_map_type); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_power); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3454, __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, 3455, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__33; } __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, 3457, __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, 3454, __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, 3454, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_20arcmap(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_map_type, __pyx_v_power, __pyx_v_weight); /* "pywrapfst.pyx":3454 * * * cpdef Fst arcmap(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * map_type="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_20arcmap(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3454, __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":3501 * * * cpdef MutableFst compose(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="auto", */ static PyObject *__pyx_pw_9pywrapfst_23compose(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_u_auto); /* "pywrapfst.pyx":3504 * Fst ifst2, * compose_filter="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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3528 * """ * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.ComposeOptions] _opts * _opts.reset( */ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); __PYX_ERR(0, 3528, __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":3532 * _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); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3532, __pyx_L1_error) __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3532, __pyx_L1_error) /* "pywrapfst.pyx":3530 * _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)))) */ __pyx_v__opts.reset(new fst::ComposeOptions(__pyx_v_connect, __pyx_t_2)); /* "pywrapfst.pyx":3533 * 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, 3533, __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, 3533, __pyx_L1_error) } fst::script::Compose((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v__tfst.get(), (*__pyx_v__opts)); /* "pywrapfst.pyx":3534 * _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, 3534, __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":3501 * * * cpdef MutableFst compose(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="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_23compose(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_22compose[] = "\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\", \"no_match\", \"null\", \"sequence\",\n \"trivial\".\n connect: Should output be trimmed?\n\n Returns:\n An FST.\n "; static PyObject *__pyx_pw_9pywrapfst_23compose(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("compose", 0, 2, 4, 1); __PYX_ERR(0, 3501, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_compose_filter); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3501, __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, 3504, __pyx_L3_error) } else { /* "pywrapfst.pyx":3504 * Fst ifst2, * compose_filter="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, 3501, __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, 3501, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst_Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3502, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_22compose(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_compose_filter, __pyx_v_connect); /* "pywrapfst.pyx":3501 * * * cpdef MutableFst compose(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="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_22compose(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3501, __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":3537 * * * cpdef Fst convert(Fst ifst, fst_type=""): # <<<<<<<<<<<<<< * """ * convert(ifst, fst_type="") */ static PyObject *__pyx_pw_9pywrapfst_25convert(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 *)__pyx_kp_u__11); std::string __pyx_v__fst_type; 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; Py_ssize_t __pyx_t_6; Py_UCS4 __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3554 * FstOpError: Conversion failed. * """ * cdef string _fst_type = tostring(fst_type) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.Convert(deref(ifst._fst), _fst_type)) */ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_fst_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3554, __pyx_L1_error) __pyx_v__fst_type = __pyx_t_1; /* "pywrapfst.pyx":3556 * cdef string _fst_type = tostring(fst_type) * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.Convert(deref(ifst._fst), _fst_type)) # <<<<<<<<<<<<<< * # 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, 3556, __pyx_L1_error) } __pyx_v__tfst.reset(fst::script::Convert((*__pyx_v_ifst->_fst), __pyx_v__fst_type)); /* "pywrapfst.pyx":3558 * _tfst.reset(fst.Convert(deref(ifst._fst), _fst_type)) * # Script-land Convert returns a null pointer to signal failure. * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstOpError(f"Conversion to {fst_type!r} failed") * return _init_XFst(_tfst.release()) */ __pyx_t_2 = ((__pyx_v__tfst.get() == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pywrapfst.pyx":3559 * # Script-land Convert returns a null pointer to signal failure. * if _tfst.get() == NULL: * raise FstOpError(f"Conversion to {fst_type!r} failed") # <<<<<<<<<<<<<< * return _init_XFst(_tfst.release()) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = 0; __pyx_t_7 = 127; __Pyx_INCREF(__pyx_kp_u_Conversion_to); __pyx_t_6 += 14; __Pyx_GIVEREF(__pyx_kp_u_Conversion_to); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_kp_u_Conversion_to); __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_fst_type), __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_7) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_7; __pyx_t_6 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_8); __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_failed); __pyx_t_6 += 7; __Pyx_GIVEREF(__pyx_kp_u_failed); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_kp_u_failed); __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_5, 3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __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); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3559, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __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, 3559, __pyx_L1_error) /* "pywrapfst.pyx":3558 * _tfst.reset(fst.Convert(deref(ifst._fst), _fst_type)) * # Script-land Convert returns a null pointer to signal failure. * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstOpError(f"Conversion to {fst_type!r} failed") * return _init_XFst(_tfst.release()) */ } /* "pywrapfst.pyx":3560 * if _tfst.get() == NULL: * raise FstOpError(f"Conversion to {fst_type!r} failed") * 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, 3560, __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":3537 * * * cpdef Fst convert(Fst ifst, fst_type=""): # <<<<<<<<<<<<<< * """ * convert(ifst, fst_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_8); __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_25convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_24convert[] = "\n convert(ifst, fst_type=\"\")\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 an empty string\n if no conversion is desired.\n\n Returns:\n The input FST converted to the desired FST type.\n\n Raises:\n FstOpError: Conversion failed.\n "; static PyObject *__pyx_pw_9pywrapfst_25convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; PyObject *__pyx_v_fst_type = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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 *)__pyx_kp_u__11); 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 3537, __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, 3537, __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, 3537, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_24convert(__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_24convert(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3537, __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":3563 * * * cpdef MutableFst determinize(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * det_type="functional", */ static PyObject *__pyx_pw_9pywrapfst_27determinize(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__34; PyObject *__pyx_v_det_type = ((PyObject *)__pyx_n_u_functional); int64 __pyx_v_nstate = __pyx_k__35; int64 __pyx_v_subsequential_label = ((int64)0); /* "pywrapfst.pyx":3568 * int64 nstate=fst.kNoStateId, * int64 subsequential_label=0, * weight=None, # <<<<<<<<<<<<<< * bool increment_subsequential_label=False): * """ */ PyObject *__pyx_v_weight = ((PyObject *)Py_None); /* "pywrapfst.pyx":3569 * 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__weight; enum fst::DeterminizeType __pyx_v__det_type; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3603 * """ * 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 _weight = _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, 3603, __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":3605 * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * # Threshold is set to semiring Zero (no pruning) if weight unspecified. * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), # <<<<<<<<<<<<<< * weight) * cdef fst.DeterminizeType _det_type */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); __PYX_ERR(0, 3605, __pyx_L1_error) } /* "pywrapfst.pyx":3606 * # Threshold is set to semiring Zero (no pruning) if weight unspecified. * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), * weight) # <<<<<<<<<<<<<< * cdef fst.DeterminizeType _det_type * if not fst.GetDeterminizeType(tostring(det_type), addr(_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, 3605, __pyx_L1_error) __pyx_v__weight = __pyx_t_1; /* "pywrapfst.pyx":3608 * weight) * cdef fst.DeterminizeType _det_type * if not fst.GetDeterminizeType(tostring(det_type), addr(_det_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown determinization type: {det_type!r}") * cdef unique_ptr[fst.DeterminizeOptions] _opts */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_det_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3608, __pyx_L1_error) __pyx_t_3 = ((!(fst::script::GetDeterminizeType(__pyx_t_2, (&__pyx_v__det_type)) != 0)) != 0); if (unlikely(__pyx_t_3)) { /* "pywrapfst.pyx":3609 * cdef fst.DeterminizeType _det_type * if not fst.GetDeterminizeType(tostring(det_type), addr(_det_type)): * raise FstArgError(f"Unknown determinization type: {det_type!r}") # <<<<<<<<<<<<<< * cdef unique_ptr[fst.DeterminizeOptions] _opts * _opts.reset( */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_det_type), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Unknown_determinization_type, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __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); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __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, 3609, __pyx_L1_error) /* "pywrapfst.pyx":3608 * weight) * cdef fst.DeterminizeType _det_type * if not fst.GetDeterminizeType(tostring(det_type), addr(_det_type)): # <<<<<<<<<<<<<< * raise FstArgError(f"Unknown determinization type: {det_type!r}") * cdef unique_ptr[fst.DeterminizeOptions] _opts */ } /* "pywrapfst.pyx":3611 * raise FstArgError(f"Unknown determinization type: {det_type!r}") * cdef unique_ptr[fst.DeterminizeOptions] _opts * _opts.reset( # <<<<<<<<<<<<<< * new fst.DeterminizeOptions(delta, * _weight, */ __pyx_v__opts.reset(new fst::script::DeterminizeOptions(__pyx_v_delta, __pyx_v__weight, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v__det_type, __pyx_v_increment_subsequential_label)); /* "pywrapfst.pyx":3618 * _det_type, * 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, 3618, __pyx_L1_error) } fst::script::Determinize((*__pyx_v_ifst->_fst), __pyx_v__tfst.get(), (*__pyx_v__opts)); /* "pywrapfst.pyx":3619 * 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, 3619, __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":3563 * * * cpdef MutableFst determinize(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * det_type="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_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_27determinize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_26determinize[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_27determinize(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; int64 __pyx_v_nstate; int64 __pyx_v_subsequential_label; PyObject *__pyx_v_weight = 0; bool __pyx_v_increment_subsequential_label; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_functional); /* "pywrapfst.pyx":3568 * 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_det_type); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nstate); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_subsequential_label); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weight); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3563, __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, 3564, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__34; } __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3566, __pyx_L3_error) } else { __pyx_v_nstate = __pyx_k__35; } if (values[4]) { __pyx_v_subsequential_label = __Pyx_PyInt_As_int64_t(values[4]); if (unlikely((__pyx_v_subsequential_label == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3567, __pyx_L3_error) } else { __pyx_v_subsequential_label = ((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, 3569, __pyx_L3_error) } else { /* "pywrapfst.pyx":3569 * 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, 3563, __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, 3563, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_26determinize(__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":3563 * * * cpdef MutableFst determinize(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * det_type="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_26determinize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_det_type, int64 __pyx_v_nstate, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3563, __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":3622 * * * cpdef MutableFst difference(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="auto", */ static PyObject *__pyx_pw_9pywrapfst_29difference(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_u_auto); /* "pywrapfst.pyx":3625 * Fst ifst2, * compose_filter="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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3650 * """ * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.ComposeOptions] _opts * _opts.reset( */ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); __PYX_ERR(0, 3650, __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":3654 * _opts.reset( * new fst.ComposeOptions(connect, * _get_compose_filter(tostring(compose_filter)))) # <<<<<<<<<<<<<< * fst.Difference(deref(ifst1._fst), * deref(ifst2._fst), */ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_compose_filter); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3654, __pyx_L1_error) __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3654, __pyx_L1_error) /* "pywrapfst.pyx":3652 * _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)))) */ __pyx_v__opts.reset(new fst::ComposeOptions(__pyx_v_connect, __pyx_t_2)); /* "pywrapfst.pyx":3655 * new fst.ComposeOptions(connect, * _get_compose_filter(tostring(compose_filter)))) * fst.Difference(deref(ifst1._fst), # <<<<<<<<<<<<<< * deref(ifst2._fst), * _tfst.get(), */ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 3655, __pyx_L1_error) } /* "pywrapfst.pyx":3656 * _get_compose_filter(tostring(compose_filter)))) * fst.Difference(deref(ifst1._fst), * deref(ifst2._fst), # <<<<<<<<<<<<<< * _tfst.get(), * deref(_opts)) */ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 3656, __pyx_L1_error) } /* "pywrapfst.pyx":3655 * new fst.ComposeOptions(connect, * _get_compose_filter(tostring(compose_filter)))) * fst.Difference(deref(ifst1._fst), # <<<<<<<<<<<<<< * deref(ifst2._fst), * _tfst.get(), */ fst::script::Difference((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v__tfst.get(), (*__pyx_v__opts)); /* "pywrapfst.pyx":3659 * _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, 3659, __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":3622 * * * cpdef MutableFst difference(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="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_29difference(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_28difference[] = "\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\", \"no_match\", \"null\", \"sequence\",\n \"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_29difference(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("difference", 0, 2, 4, 1); __PYX_ERR(0, 3622, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_compose_filter); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3622, __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, 3625, __pyx_L3_error) } else { /* "pywrapfst.pyx":3625 * Fst ifst2, * compose_filter="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, 3622, __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, 3622, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst_Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3623, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_28difference(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_compose_filter, __pyx_v_connect); /* "pywrapfst.pyx":3622 * * * cpdef MutableFst difference(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="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_28difference(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3622, __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":3662 * * * cpdef MutableFst disambiguate(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, */ static PyObject *__pyx_pw_9pywrapfst_31disambiguate(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__36; int64 __pyx_v_nstate = __pyx_k__37; int64 __pyx_v_subsequential_label = ((int64)0); /* "pywrapfst.pyx":3666 * 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__weight; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3691 * """ * 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 _weight = _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, 3691, __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":3693 * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * # Threshold is set to semiring Zero (no pruning) if no weight is specified. * cdef fst.WeightClass _weight = _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, 3693, __pyx_L1_error) } /* "pywrapfst.pyx":3694 * # Threshold is set to semiring Zero (no pruning) if no weight is specified. * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), * weight) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.DisambiguateOptions] _opts * _opts.reset( */ __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, 3693, __pyx_L1_error) __pyx_v__weight = __pyx_t_1; /* "pywrapfst.pyx":3696 * weight) * cdef unique_ptr[fst.DisambiguateOptions] _opts * _opts.reset( # <<<<<<<<<<<<<< * new fst.DisambiguateOptions(delta, * _weight, */ __pyx_v__opts.reset(new fst::script::DisambiguateOptions(__pyx_v_delta, __pyx_v__weight, __pyx_v_nstate, __pyx_v_subsequential_label)); /* "pywrapfst.pyx":3701 * 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, 3701, __pyx_L1_error) } fst::script::Disambiguate((*__pyx_v_ifst->_fst), __pyx_v__tfst.get(), (*__pyx_v__opts)); /* "pywrapfst.pyx":3702 * 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, 3702, __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":3662 * * * 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_31disambiguate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_30disambiguate[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_31disambiguate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; float __pyx_v_delta; int64 __pyx_v_nstate; int64 __pyx_v_subsequential_label; PyObject *__pyx_v_weight = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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":3666 * 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nstate); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_subsequential_label); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3662, __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, 3663, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__36; } if (values[2]) { __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3664, __pyx_L3_error) } else { __pyx_v_nstate = __pyx_k__37; } if (values[3]) { __pyx_v_subsequential_label = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_subsequential_label == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3665, __pyx_L3_error) } else { __pyx_v_subsequential_label = ((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, 3662, __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, 3662, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_30disambiguate(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v_weight); /* "pywrapfst.pyx":3662 * * * 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_30disambiguate(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst, float __pyx_v_delta, int64 __pyx_v_nstate, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3662, __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":3705 * * * cpdef MutableFst epsnormalize(Fst ifst, bool eps_norm_output=False): # <<<<<<<<<<<<<< * """ * epsnormalize(ifst, eps_norm_output=False) */ static PyObject *__pyx_pw_9pywrapfst_33epsnormalize(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3726 * """ * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< * fst.EpsNormalize( * deref(ifst._fst), */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); __PYX_ERR(0, 3726, __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":3728 * _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, 3728, __pyx_L1_error) } /* "pywrapfst.pyx":3730 * 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)) { __pyx_t_1 = fst::EPS_NORM_OUTPUT; } else { __pyx_t_1 = fst::EPS_NORM_INPUT; } /* "pywrapfst.pyx":3727 * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * fst.EpsNormalize( # <<<<<<<<<<<<<< * deref(ifst._fst), * _tfst.get(), */ fst::script::EpsNormalize((*__pyx_v_ifst->_fst), __pyx_v__tfst.get(), __pyx_t_1); /* "pywrapfst.pyx":3731 * _tfst.get(), * fst.EPS_NORM_OUTPUT if 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, 3731, __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":3705 * * * 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_33epsnormalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_32epsnormalize[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_33epsnormalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; bool __pyx_v_eps_norm_output; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 3705, __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, 3705, __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, 3705, __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, 3705, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_32epsnormalize(__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_32epsnormalize(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3705, __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":3734 * * * cpdef bool equal(Fst ifst1, Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< * """ * equal(ifst1, ifst2, delta=0.0009765625) */ static PyObject *__pyx_pw_9pywrapfst_35equal(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__38; bool __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("equal", 0); if (__pyx_optional_args) { if (__pyx_optional_args->__pyx_n > 0) { __pyx_v_delta = __pyx_optional_args->delta; } } /* "pywrapfst.pyx":3752 * True if the FSTs satisfy the above condition, else False. * """ * 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, 3752, __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, 3752, __pyx_L1_error) } __pyx_r = fst::script::Equal((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta); goto __pyx_L0; /* "pywrapfst.pyx":3734 * * * 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_35equal(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_34equal[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_35equal(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("equal", 0, 2, 3, 1); __PYX_ERR(0, 3734, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3734, __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, 3734, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__38; } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("equal", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3734, __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, 3734, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst_Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3734, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_34equal(__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_34equal(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3734, __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":3755 * * * cpdef bool equivalent(Fst ifst1, Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< * """ * equivalent(ifst1, ifst2, delta=0.0009765625) */ static PyObject *__pyx_pw_9pywrapfst_37equivalent(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__39; bool __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("equivalent", 0); if (__pyx_optional_args) { if (__pyx_optional_args->__pyx_n > 0) { __pyx_v_delta = __pyx_optional_args->delta; } } /* "pywrapfst.pyx":3773 * True if the FSTs satisfy the above condition, else False. * """ * 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, 3773, __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, 3773, __pyx_L1_error) } __pyx_r = fst::script::Equivalent((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta); goto __pyx_L0; /* "pywrapfst.pyx":3755 * * * cpdef bool equivalent(Fst ifst1, Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< * """ * equivalent(ifst1, ifst2, delta=0.0009765625) */ /* function exit code */ __pyx_L1_error:; __Pyx_WriteUnraisable("pywrapfst.equivalent", __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_37equivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_36equivalent[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_37equivalent(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("equivalent", 0, 2, 3, 1); __PYX_ERR(0, 3755, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3755, __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, 3755, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__39; } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("equivalent", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3755, __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, 3755, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst_Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3755, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_36equivalent(__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_36equivalent(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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); __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3755, __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":3776 * * * cpdef MutableFst intersect(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="auto", */ static PyObject *__pyx_pw_9pywrapfst_39intersect(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_u_auto); /* "pywrapfst.pyx":3779 * Fst ifst2, * compose_filter="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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3802 * """ * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst1.arc_type())) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.ComposeOptions] _opts * _opts.reset( */ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); __PYX_ERR(0, 3802, __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":3806 * _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); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3806, __pyx_L1_error) __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3806, __pyx_L1_error) /* "pywrapfst.pyx":3804 * _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)))) */ __pyx_v__opts.reset(new fst::ComposeOptions(__pyx_v_connect, __pyx_t_2)); /* "pywrapfst.pyx":3807 * 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, 3807, __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, 3807, __pyx_L1_error) } fst::script::Intersect((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v__tfst.get(), (*__pyx_v__opts)); /* "pywrapfst.pyx":3808 * _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, 3808, __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":3776 * * * cpdef MutableFst intersect(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="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_39intersect(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_38intersect[] = "\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\", \"no_match\", \"null\", \"sequence\",\n \"trivial\".\n connect: Should output be trimmed?\n\n Returns:\n An intersected FST.\n "; static PyObject *__pyx_pw_9pywrapfst_39intersect(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("intersect", 0, 2, 4, 1); __PYX_ERR(0, 3776, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_compose_filter); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3776, __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, 3779, __pyx_L3_error) } else { /* "pywrapfst.pyx":3779 * Fst ifst2, * compose_filter="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, 3776, __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, 3776, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst_Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3777, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_38intersect(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_compose_filter, __pyx_v_connect); /* "pywrapfst.pyx":3776 * * * cpdef MutableFst intersect(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * compose_filter="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_38intersect(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3776, __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":3811 * * * cpdef bool isomorphic(Fst ifst1, Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< * """ * isomorphic(ifst1, ifst2, delta=0.0009765625) */ static PyObject *__pyx_pw_9pywrapfst_41isomorphic(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__40; bool __pyx_r; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("isomorphic", 0); if (__pyx_optional_args) { if (__pyx_optional_args->__pyx_n > 0) { __pyx_v_delta = __pyx_optional_args->delta; } } /* "pywrapfst.pyx":3832 * True if the two transducers satisfy the above condition, else False. * """ * 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, 3832, __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, 3832, __pyx_L1_error) } __pyx_r = fst::script::Isomorphic((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta); goto __pyx_L0; /* "pywrapfst.pyx":3811 * * * 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_41isomorphic(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_40isomorphic[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_41isomorphic(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("isomorphic", 0, 2, 3, 1); __PYX_ERR(0, 3811, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3811, __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, 3811, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__40; } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("isomorphic", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3811, __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, 3811, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst_Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3811, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_40isomorphic(__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_40isomorphic(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3811, __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":3835 * * * cpdef MutableFst prune(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, */ static PyObject *__pyx_pw_9pywrapfst_43prune(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__41; int64 __pyx_v_nstate = __pyx_k__42; /* "pywrapfst.pyx":3838 * 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__weight; struct __pyx_obj_9pywrapfst_MutableFst *__pyx_r = NULL; __Pyx_RefNannyDeclarations fst::script::WeightClass __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3860 * """ * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< * cdef fst.WeightClass _weight = _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, 3860, __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":3861 * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), # <<<<<<<<<<<<<< * weight) * fst.Prune(deref(ifst._fst), _tfst.get(), _weight, nstate, delta) */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); __PYX_ERR(0, 3861, __pyx_L1_error) } /* "pywrapfst.pyx":3862 * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), * weight) # <<<<<<<<<<<<<< * fst.Prune(deref(ifst._fst), _tfst.get(), _weight, nstate, delta) * return _init_MutableFst(_tfst.release()) */ __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, 3861, __pyx_L1_error) __pyx_v__weight = __pyx_t_1; /* "pywrapfst.pyx":3863 * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), * weight) * fst.Prune(deref(ifst._fst), _tfst.get(), _weight, 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, 3863, __pyx_L1_error) } fst::script::Prune((*__pyx_v_ifst->_fst), __pyx_v__tfst.get(), __pyx_v__weight, __pyx_v_nstate, __pyx_v_delta); /* "pywrapfst.pyx":3864 * weight) * fst.Prune(deref(ifst._fst), _tfst.get(), _weight, 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, 3864, __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":3835 * * * 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_43prune(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_42prune[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_43prune(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; float __pyx_v_delta; int64 __pyx_v_nstate; PyObject *__pyx_v_weight = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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":3838 * 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nstate); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 3835, __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, 3836, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__41; } if (values[2]) { __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3837, __pyx_L3_error) } else { __pyx_v_nstate = __pyx_k__42; } __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, 3835, __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, 3835, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_42prune(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_weight); /* "pywrapfst.pyx":3835 * * * 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_42prune(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst, float __pyx_v_delta, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3835, __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":3867 * * * cpdef MutableFst push(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * bool push_weights=False, */ static PyObject *__pyx_pw_9pywrapfst_45push(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__43; /* "pywrapfst.pyx":3869 * 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":3870 * 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":3871 * 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":3872 * 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":3873 * 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; uint8 __pyx_v_flags; struct __pyx_obj_9pywrapfst_MutableFst *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":3910 * """ * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< * cdef uint8 flags = fst.GetPushFlags(push_weights, * push_labels, */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); __PYX_ERR(0, 3910, __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":3911 * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * cdef uint8 flags = fst.GetPushFlags(push_weights, # <<<<<<<<<<<<<< * push_labels, * remove_common_affix, */ __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":3915 * remove_common_affix, * remove_total_weight) * fst.Push(deref(ifst._fst), # <<<<<<<<<<<<<< * _tfst.get(), * flags, */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 3915, __pyx_L1_error) } /* "pywrapfst.pyx":3919 * 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":3920 * 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, 3920, __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":3867 * * * 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_45push(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_44push[] = "\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 "; static PyObject *__pyx_pw_9pywrapfst_45push(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_push_weights); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_push_labels); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 3867, __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, 3868, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__43; } 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, 3869, __pyx_L3_error) } else { /* "pywrapfst.pyx":3869 * 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, 3870, __pyx_L3_error) } else { /* "pywrapfst.pyx":3870 * 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, 3871, __pyx_L3_error) } else { /* "pywrapfst.pyx":3871 * 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, 3872, __pyx_L3_error) } else { /* "pywrapfst.pyx":3872 * 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, 3873, __pyx_L3_error) } else { /* "pywrapfst.pyx":3873 * 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, 3867, __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, 3867, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_44push(__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":3867 * * * 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_44push(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 3867, __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":3923 * * * cpdef bool randequivalent(Fst ifst1, # <<<<<<<<<<<<<< * Fst ifst2, * int32 npath=1, */ static PyObject *__pyx_pw_9pywrapfst_47randequivalent(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) { int32 __pyx_v_npath = ((int32)1); float __pyx_v_delta = __pyx_k__44; PyObject *__pyx_v_select = ((PyObject *)__pyx_n_u_uniform); int32 __pyx_v_max_length = __pyx_k__45; uint64 __pyx_v_seed = ((uint64)0); enum fst::script::RandArcSelection __pyx_v__select; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_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_seed = __pyx_optional_args->seed; } } } } } } /* "pywrapfst.pyx":3956 * True if the two transducers satisfy the above condition, else False. * """ * cdef fst.RandArcSelection _select = _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); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3956, __pyx_L1_error) __pyx_t_2 = __pyx_f_9pywrapfst__get_rand_arc_selection(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3956, __pyx_L1_error) __pyx_v__select = __pyx_t_2; /* "pywrapfst.pyx":3959 * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] _opts * # The three trailing options will be ignored by RandEquivalent. * _opts.reset( # <<<<<<<<<<<<<< * new fst.RandGenOptions[fst.RandArcSelection](_select, * max_length, */ __pyx_v__opts.reset(new fst::RandGenOptions (__pyx_v__select, __pyx_v_max_length, 1, 0, 0)); /* "pywrapfst.pyx":3965 * False, * False)) * if seed == 0: # <<<<<<<<<<<<<< * seed = time(NULL) * return fst.RandEquivalent(deref(ifst1._fst), */ __pyx_t_3 = ((__pyx_v_seed == 0) != 0); if (__pyx_t_3) { /* "pywrapfst.pyx":3966 * False)) * if seed == 0: * seed = time(NULL) # <<<<<<<<<<<<<< * return fst.RandEquivalent(deref(ifst1._fst), * deref(ifst2._fst), */ __pyx_v_seed = time(NULL); /* "pywrapfst.pyx":3965 * False, * False)) * if seed == 0: # <<<<<<<<<<<<<< * seed = time(NULL) * return fst.RandEquivalent(deref(ifst1._fst), */ } /* "pywrapfst.pyx":3967 * if seed == 0: * seed = time(NULL) * return fst.RandEquivalent(deref(ifst1._fst), # <<<<<<<<<<<<<< * deref(ifst2._fst), * npath, */ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 3967, __pyx_L1_error) } /* "pywrapfst.pyx":3968 * seed = time(NULL) * return fst.RandEquivalent(deref(ifst1._fst), * deref(ifst2._fst), # <<<<<<<<<<<<<< * npath, * deref(_opts), */ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 3968, __pyx_L1_error) } /* "pywrapfst.pyx":3967 * if seed == 0: * seed = time(NULL) * return fst.RandEquivalent(deref(ifst1._fst), # <<<<<<<<<<<<<< * deref(ifst2._fst), * npath, */ __pyx_r = fst::script::RandEquivalent((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_npath, (*__pyx_v__opts), __pyx_v_delta, __pyx_v_seed); goto __pyx_L0; /* "pywrapfst.pyx":3923 * * * 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_47randequivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_46randequivalent[] = "\n randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, select=\"uniform\",\n max_length=2147483647, seed=0)\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 "; static PyObject *__pyx_pw_9pywrapfst_47randequivalent(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; int32 __pyx_v_npath; float __pyx_v_delta; PyObject *__pyx_v_select = 0; int32 __pyx_v_max_length; uint64 __pyx_v_seed; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_select,&__pyx_n_s_max_length,&__pyx_n_s_seed,0}; PyObject* values[7] = {0,0,0,0,0,0,0}; values[4] = ((PyObject *)__pyx_n_u_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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("randequivalent", 0, 2, 7, 1); __PYX_ERR(0, 3923, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npath); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_select); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_length); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_seed); 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, 3923, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3925, __pyx_L3_error) } else { __pyx_v_npath = ((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, 3926, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__44; } __pyx_v_select = values[4]; if (values[5]) { __pyx_v_max_length = __Pyx_PyInt_As_int32_t(values[5]); if (unlikely((__pyx_v_max_length == ((int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3928, __pyx_L3_error) } else { __pyx_v_max_length = __pyx_k__45; } if (values[6]) { __pyx_v_seed = __Pyx_PyInt_As_uint64_t(values[6]); if (unlikely((__pyx_v_seed == ((uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3929, __pyx_L3_error) } else { __pyx_v_seed = ((uint64)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("randequivalent", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3923, __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, 3923, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst_Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3924, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_46randequivalent(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_npath, __pyx_v_delta, __pyx_v_select, __pyx_v_max_length, __pyx_v_seed); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_46randequivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst2, int32 __pyx_v_npath, float __pyx_v_delta, PyObject *__pyx_v_select, int32 __pyx_v_max_length, uint64 __pyx_v_seed) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations bool __pyx_t_1; struct __pyx_opt_args_9pywrapfst_randequivalent __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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.select = __pyx_v_select; __pyx_t_2.max_length = __pyx_v_max_length; __pyx_t_2.seed = __pyx_v_seed; __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, 3923, __pyx_L1_error) __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3923, __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":3975 * * * cpdef MutableFst randgen(Fst ifst, # <<<<<<<<<<<<<< * int32 npath=1, * select="uniform", */ static PyObject *__pyx_pw_9pywrapfst_49randgen(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) { int32 __pyx_v_npath = ((int32)1); PyObject *__pyx_v_select = ((PyObject *)__pyx_n_u_uniform); int32 __pyx_v_max_length = __pyx_k__46; /* "pywrapfst.pyx":3979 * select="uniform", * int32 max_length=INT32_MAX, * bool weighted=False, # <<<<<<<<<<<<<< * bool remove_total_weight=False, * uint64 seed=0): */ bool __pyx_v_weighted = ((bool)0); /* "pywrapfst.pyx":3980 * int32 max_length=INT32_MAX, * bool weighted=False, * bool remove_total_weight=False, # <<<<<<<<<<<<<< * uint64 seed=0): * """ */ bool __pyx_v_remove_total_weight = ((bool)0); uint64 __pyx_v_seed = ((uint64)0); enum fst::script::RandArcSelection __pyx_v__select; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_select = __pyx_optional_args->select; if (__pyx_optional_args->__pyx_n > 2) { __pyx_v_max_length = __pyx_optional_args->max_length; if (__pyx_optional_args->__pyx_n > 3) { __pyx_v_weighted = __pyx_optional_args->weighted; 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_seed = __pyx_optional_args->seed; } } } } } } } /* "pywrapfst.pyx":4011 * An FST containing one or more random paths. * """ * cdef fst.RandArcSelection _select = _get_rand_arc_selection(tostring(select)) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] _opts * _opts.reset( */ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_select); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4011, __pyx_L1_error) __pyx_t_2 = __pyx_f_9pywrapfst__get_rand_arc_selection(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4011, __pyx_L1_error) __pyx_v__select = __pyx_t_2; /* "pywrapfst.pyx":4013 * cdef fst.RandArcSelection _select = _get_rand_arc_selection(tostring(select)) * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] _opts * _opts.reset( # <<<<<<<<<<<<<< * new fst.RandGenOptions[fst.RandArcSelection](_select, * max_length, */ __pyx_v__opts.reset(new fst::RandGenOptions (__pyx_v__select, __pyx_v_max_length, __pyx_v_npath, __pyx_v_weighted, __pyx_v_remove_total_weight)); /* "pywrapfst.pyx":4020 * remove_total_weight)) * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) # <<<<<<<<<<<<<< * if seed == 0: * seed = time(NULL) */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "arc_type"); __PYX_ERR(0, 4020, __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":4021 * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * if seed == 0: # <<<<<<<<<<<<<< * seed = time(NULL) * fst.RandGen(deref(ifst._fst), _tfst.get(), deref(_opts), seed) */ __pyx_t_3 = ((__pyx_v_seed == 0) != 0); if (__pyx_t_3) { /* "pywrapfst.pyx":4022 * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * if seed == 0: * seed = time(NULL) # <<<<<<<<<<<<<< * fst.RandGen(deref(ifst._fst), _tfst.get(), deref(_opts), seed) * return _init_MutableFst(_tfst.release()) */ __pyx_v_seed = time(NULL); /* "pywrapfst.pyx":4021 * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * if seed == 0: # <<<<<<<<<<<<<< * seed = time(NULL) * fst.RandGen(deref(ifst._fst), _tfst.get(), deref(_opts), seed) */ } /* "pywrapfst.pyx":4023 * if seed == 0: * seed = time(NULL) * fst.RandGen(deref(ifst._fst), _tfst.get(), deref(_opts), seed) # <<<<<<<<<<<<<< * 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, 4023, __pyx_L1_error) } fst::script::RandGen((*__pyx_v_ifst->_fst), __pyx_v__tfst.get(), (*__pyx_v__opts), __pyx_v_seed); /* "pywrapfst.pyx":4024 * seed = time(NULL) * fst.RandGen(deref(ifst._fst), _tfst.get(), deref(_opts), seed) * 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, 4024, __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":3975 * * * cpdef MutableFst randgen(Fst ifst, # <<<<<<<<<<<<<< * int32 npath=1, * select="uniform", */ /* 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_49randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_48randgen[] = "\n randgen(ifst, npath=1, seed=0, select=\"uniform\", max_length=2147483647,\n weighted=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 "; static PyObject *__pyx_pw_9pywrapfst_49randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; int32 __pyx_v_npath; PyObject *__pyx_v_select = 0; int32 __pyx_v_max_length; bool __pyx_v_weighted; bool __pyx_v_remove_total_weight; uint64 __pyx_v_seed; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_select,&__pyx_n_s_max_length,&__pyx_n_s_weighted,&__pyx_n_s_remove_total_weight,&__pyx_n_s_seed,0}; PyObject* values[7] = {0,0,0,0,0,0,0}; values[2] = ((PyObject *)__pyx_n_u_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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_npath); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_select); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_length); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weighted); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_seed); 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, 3975, __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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3976, __pyx_L3_error) } else { __pyx_v_npath = ((int32)1); } __pyx_v_select = values[2]; if (values[3]) { __pyx_v_max_length = __Pyx_PyInt_As_int32_t(values[3]); if (unlikely((__pyx_v_max_length == ((int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3978, __pyx_L3_error) } else { __pyx_v_max_length = __pyx_k__46; } if (values[4]) { __pyx_v_weighted = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_weighted == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3979, __pyx_L3_error) } else { /* "pywrapfst.pyx":3979 * select="uniform", * int32 max_length=INT32_MAX, * bool weighted=False, # <<<<<<<<<<<<<< * bool remove_total_weight=False, * uint64 seed=0): */ __pyx_v_weighted = ((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, 3980, __pyx_L3_error) } else { /* "pywrapfst.pyx":3980 * int32 max_length=INT32_MAX, * bool weighted=False, * bool remove_total_weight=False, # <<<<<<<<<<<<<< * uint64 seed=0): * """ */ __pyx_v_remove_total_weight = ((bool)0); } if (values[6]) { __pyx_v_seed = __Pyx_PyInt_As_uint64_t(values[6]); if (unlikely((__pyx_v_seed == ((uint64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3981, __pyx_L3_error) } else { __pyx_v_seed = ((uint64)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, 3975, __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, 3975, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_48randgen(__pyx_self, __pyx_v_ifst, __pyx_v_npath, __pyx_v_select, __pyx_v_max_length, __pyx_v_weighted, __pyx_v_remove_total_weight, __pyx_v_seed); /* "pywrapfst.pyx":3975 * * * cpdef MutableFst randgen(Fst ifst, # <<<<<<<<<<<<<< * int32 npath=1, * select="uniform", */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_48randgen(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst, int32 __pyx_v_npath, PyObject *__pyx_v_select, int32 __pyx_v_max_length, bool __pyx_v_weighted, bool __pyx_v_remove_total_weight, uint64 __pyx_v_seed) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; struct __pyx_opt_args_9pywrapfst_randgen __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("randgen", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_2.__pyx_n = 6; __pyx_t_2.npath = __pyx_v_npath; __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_2.seed = __pyx_v_seed; __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_randgen(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3975, __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":4027 * * * cpdef MutableFst replace(pairs, # <<<<<<<<<<<<<< * call_arc_labeling="input", * return_arc_labeling="neither", */ static PyObject *__pyx_pw_9pywrapfst_51replace(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_u_input); PyObject *__pyx_v_return_arc_labeling = ((PyObject *)__pyx_n_u_neither); /* "pywrapfst.pyx":4030 * call_arc_labeling="input", * return_arc_labeling="neither", * bool epsilon_on_replace=False, # <<<<<<<<<<<<<< * int64 return_label=0): * """ */ bool __pyx_v_epsilon_on_replace = ((bool)0); int64 __pyx_v_return_label = ((int64)0); int64 __pyx_v__label; struct __pyx_obj_9pywrapfst_Fst *__pyx_v__pfst = 0; std::vector<__pyx_t_10cpywrapfst_LabelFstClassPair> __pyx_v__pairs; 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; Py_ssize_t __pyx_t_2; PyObject *(*__pyx_t_3)(PyObject *); PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *(*__pyx_t_8)(PyObject *); int64 __pyx_t_9; __pyx_t_10cpywrapfst_LabelFstClassPair __pyx_t_10; std::string __pyx_t_11; enum fst::ReplaceLabelType __pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":4071 * cdef Fst _pfst * cdef vector[fst.LabelFstClassPair] _pairs * for (_label, _pfst) in pairs: # <<<<<<<<<<<<<< * _pairs.push_back(fst.LabelFstClassPair(_label, _pfst._fst.get())) * cdef unique_ptr[fst.VectorFstClass] _tfst */ if (likely(PyList_CheckExact(__pyx_v_pairs)) || PyTuple_CheckExact(__pyx_v_pairs)) { __pyx_t_1 = __pyx_v_pairs; __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_pairs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4071, __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(0, 4071, __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(0, 4071, __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(0, 4071, __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(0, 4071, __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(0, 4071, __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(0, 4071, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_4); } if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { PyObject* sequence = __pyx_t_4; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(0, 4071, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_5 = PyList_GET_ITEM(sequence, 0); __pyx_t_6 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { Py_ssize_t index = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4071, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_5); index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 4071, __pyx_L1_error) __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L6_unpacking_done; __pyx_L5_unpacking_failed:; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(0, 4071, __pyx_L1_error) __pyx_L6_unpacking_done:; } __pyx_t_9 = __Pyx_PyInt_As_int64_t(__pyx_t_5); if (unlikely((__pyx_t_9 == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4071, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_9pywrapfst_Fst))))) __PYX_ERR(0, 4071, __pyx_L1_error) __pyx_v__label = __pyx_t_9; __Pyx_XDECREF_SET(__pyx_v__pfst, ((struct __pyx_obj_9pywrapfst_Fst *)__pyx_t_6)); __pyx_t_6 = 0; /* "pywrapfst.pyx":4072 * cdef vector[fst.LabelFstClassPair] _pairs * for (_label, _pfst) in pairs: * _pairs.push_back(fst.LabelFstClassPair(_label, _pfst._fst.get())) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(_pairs[0].second.ArcType())) */ if (unlikely(((PyObject *)__pyx_v__pfst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 4072, __pyx_L1_error) } try { __pyx_t_10 = __pyx_t_10cpywrapfst_LabelFstClassPair(__pyx_v__label, __pyx_v__pfst->_fst.get()); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 4072, __pyx_L1_error) } try { __pyx_v__pairs.push_back(__pyx_t_10); } catch(...) { __Pyx_CppExn2PyErr(); __PYX_ERR(0, 4072, __pyx_L1_error) } /* "pywrapfst.pyx":4071 * cdef Fst _pfst * cdef vector[fst.LabelFstClassPair] _pairs * for (_label, _pfst) in pairs: # <<<<<<<<<<<<<< * _pairs.push_back(fst.LabelFstClassPair(_label, _pfst._fst.get())) * cdef unique_ptr[fst.VectorFstClass] _tfst */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":4074 * _pairs.push_back(fst.LabelFstClassPair(_label, _pfst._fst.get())) * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(_pairs[0].second.ArcType())) # <<<<<<<<<<<<<< * cdef fst.ReplaceLabelType _cal = _get_replace_label_type( * tostring(call_arc_labeling), */ __pyx_v__tfst.reset(new fst::script::VectorFstClass((__pyx_v__pairs[0]).second->ArcType())); /* "pywrapfst.pyx":4076 * _tfst.reset(new fst.VectorFstClass(_pairs[0].second.ArcType())) * 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_11 = __pyx_f_9pywrapfst_tostring(__pyx_v_call_arc_labeling); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4076, __pyx_L1_error) /* "pywrapfst.pyx":4075 * cdef unique_ptr[fst.VectorFstClass] _tfst * _tfst.reset(new fst.VectorFstClass(_pairs[0].second.ArcType())) * cdef fst.ReplaceLabelType _cal = _get_replace_label_type( # <<<<<<<<<<<<<< * tostring(call_arc_labeling), * epsilon_on_replace) */ __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, 4075, __pyx_L1_error) __pyx_v__cal = __pyx_t_12; /* "pywrapfst.pyx":4079 * 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_11 = __pyx_f_9pywrapfst_tostring(__pyx_v_return_arc_labeling); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4079, __pyx_L1_error) /* "pywrapfst.pyx":4078 * tostring(call_arc_labeling), * epsilon_on_replace) * cdef fst.ReplaceLabelType _ral = _get_replace_label_type( # <<<<<<<<<<<<<< * tostring(return_arc_labeling), * epsilon_on_replace) */ __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, 4078, __pyx_L1_error) __pyx_v__ral = __pyx_t_12; /* "pywrapfst.pyx":4082 * epsilon_on_replace) * cdef unique_ptr[fst.ReplaceOptions] _opts * _opts.reset(new fst.ReplaceOptions(_pairs[0].first, _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__pairs[0]).first, __pyx_v__cal, __pyx_v__ral, __pyx_v_return_label)); /* "pywrapfst.pyx":4083 * cdef unique_ptr[fst.ReplaceOptions] _opts * _opts.reset(new fst.ReplaceOptions(_pairs[0].first, _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":4084 * _opts.reset(new fst.ReplaceOptions(_pairs[0].first, _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, 4084, __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":4027 * * * cpdef MutableFst replace(pairs, # <<<<<<<<<<<<<< * call_arc_labeling="input", * return_arc_labeling="neither", */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("pywrapfst.replace", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v__pfst); __Pyx_XGIVEREF((PyObject *)__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_51replace(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_50replace[] = "\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_51replace(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; int64 __pyx_v_return_label; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_input); values[2] = ((PyObject *)__pyx_n_u_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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 4027, __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, 4030, __pyx_L3_error) } else { /* "pywrapfst.pyx":4030 * call_arc_labeling="input", * return_arc_labeling="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)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4031, __pyx_L3_error) } else { __pyx_v_return_label = ((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, 4027, __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_50replace(__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":4027 * * * cpdef MutableFst replace(pairs, # <<<<<<<<<<<<<< * call_arc_labeling="input", * return_arc_labeling="neither", */ /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_50replace(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, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4027, __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":4087 * * * cpdef MutableFst reverse(Fst ifst, bool require_superinitial=True): # <<<<<<<<<<<<<< * """ * reverse(ifst, require_superinitial=True) */ static PyObject *__pyx_pw_9pywrapfst_53reverse(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":4107 * """ * 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, 4107, __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":4108 * 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, 4108, __pyx_L1_error) } fst::script::Reverse((*__pyx_v_ifst->_fst), __pyx_v__tfst.get(), __pyx_v_require_superinitial); /* "pywrapfst.pyx":4109 * _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, 4109, __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":4087 * * * 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_53reverse(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_52reverse[] = "\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_53reverse(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; bool __pyx_v_require_superinitial; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 4087, __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, 4087, __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, 4087, __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, 4087, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_52reverse(__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_52reverse(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4087, __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":4115 * * * cdef void _shortestdistance(Fst ifst, # <<<<<<<<<<<<<< * vector[fst.WeightClass] *distance, * float delta=fst.kShortestDelta, */ static void __pyx_f_9pywrapfst__shortestdistance(struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst, std::vector *__pyx_v_distance, struct __pyx_opt_args_9pywrapfst__shortestdistance *__pyx_optional_args) { float __pyx_v_delta = __pyx_k__47; int64 __pyx_v_nstate = __pyx_k__48; PyObject *__pyx_v_queue_type = ((PyObject *)__pyx_n_u_auto); /* "pywrapfst.pyx":4120 * int64 nstate=fst.kNoStateId, * queue_type="auto", * bool reverse=False) except *: # <<<<<<<<<<<<<< * cdef unique_ptr[fst.ShortestDistanceOptions] _opts * if reverse: */ bool __pyx_v_reverse = ((bool)0); std::unique_ptr __pyx_v__opts; __Pyx_RefNannyDeclarations int __pyx_t_1; std::string __pyx_t_2; enum fst::QueueType __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":4122 * bool reverse=False) except *: * 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_1 = (__pyx_v_reverse != 0); if (__pyx_t_1) { /* "pywrapfst.pyx":4125 * # Only the simpler signature supports shortest distance to final states; * # `nstate` and `queue_type` arguments are ignored. * fst.ShortestDistance(deref(ifst._fst), distance, True, delta) # <<<<<<<<<<<<<< * else: * _opts.reset( */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 4125, __pyx_L1_error) } fst::script::ShortestDistance((*__pyx_v_ifst->_fst), __pyx_v_distance, 1, __pyx_v_delta); /* "pywrapfst.pyx":4122 * bool reverse=False) except *: * 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":4127 * fst.ShortestDistance(deref(ifst._fst), distance, True, delta) * else: * _opts.reset( # <<<<<<<<<<<<<< * new fst.ShortestDistanceOptions(_get_queue_type(tostring(queue_type)), * fst.ANY_ARC_FILTER, */ /*else*/ { /* "pywrapfst.pyx":4128 * else: * _opts.reset( * new fst.ShortestDistanceOptions(_get_queue_type(tostring(queue_type)), # <<<<<<<<<<<<<< * fst.ANY_ARC_FILTER, * nstate, */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_queue_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4128, __pyx_L1_error) __pyx_t_3 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4128, __pyx_L1_error) /* "pywrapfst.pyx":4127 * fst.ShortestDistance(deref(ifst._fst), distance, True, delta) * else: * _opts.reset( # <<<<<<<<<<<<<< * new fst.ShortestDistanceOptions(_get_queue_type(tostring(queue_type)), * fst.ANY_ARC_FILTER, */ __pyx_v__opts.reset(new fst::script::ShortestDistanceOptions(__pyx_t_3, fst::script::ANY_ARC_FILTER, __pyx_v_nstate, __pyx_v_delta)); /* "pywrapfst.pyx":4132 * nstate, * delta)) * fst.ShortestDistance(deref(ifst._fst), distance, deref(_opts)) # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 4132, __pyx_L1_error) } fst::script::ShortestDistance((*__pyx_v_ifst->_fst), __pyx_v_distance, (*__pyx_v__opts)); } __pyx_L3:; /* "pywrapfst.pyx":4115 * * * cdef void _shortestdistance(Fst ifst, # <<<<<<<<<<<<<< * vector[fst.WeightClass] *distance, * float delta=fst.kShortestDelta, */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pywrapfst._shortestdistance", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "pywrapfst.pyx":4135 * * * def shortestdistance(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * int64 nstate=fst.kNoStateId, */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_55shortestdistance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_54shortestdistance[] = "\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_55shortestdistance = {"shortestdistance", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_55shortestdistance, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_54shortestdistance}; static PyObject *__pyx_pw_9pywrapfst_55shortestdistance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; float __pyx_v_delta; int64 __pyx_v_nstate; PyObject *__pyx_v_queue_type = 0; bool __pyx_v_reverse; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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_u_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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nstate); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_queue_type); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 4135, __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, 4136, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__49; } if (values[2]) { __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4137, __pyx_L3_error) } else { __pyx_v_nstate = __pyx_k__50; } __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, 4139, __pyx_L3_error) } else { /* "pywrapfst.pyx":4139 * int64 nstate=fst.kNoStateId, * queue_type="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, 4135, __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, 4135, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_54shortestdistance(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_queue_type, __pyx_v_reverse); /* "pywrapfst.pyx":4135 * * * 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_54shortestdistance(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst, float __pyx_v_delta, int64 __pyx_v_nstate, PyObject *__pyx_v_queue_type, bool __pyx_v_reverse) { std::vector __pyx_v__distance; fst::script::WeightClass __pyx_7genexpr__pyx_v_weight; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations struct __pyx_opt_args_9pywrapfst__shortestdistance __pyx_t_1; PyObject *__pyx_t_2 = NULL; std::vector ::iterator __pyx_t_3; fst::script::WeightClass __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("shortestdistance", 0); /* "pywrapfst.pyx":4167 * """ * cdef vector[fst.WeightClass] _distance * _shortestdistance(ifst, addr(_distance), delta, nstate, queue_type, reverse) # <<<<<<<<<<<<<< * return [Weight(ifst._fst.get().WeightType(), weight.ToString()) * for weight in _distance] */ __pyx_t_1.__pyx_n = 4; __pyx_t_1.delta = __pyx_v_delta; __pyx_t_1.nstate = __pyx_v_nstate; __pyx_t_1.queue_type = __pyx_v_queue_type; __pyx_t_1.reverse = __pyx_v_reverse; __pyx_f_9pywrapfst__shortestdistance(__pyx_v_ifst, (&__pyx_v__distance), &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4167, __pyx_L1_error) /* "pywrapfst.pyx":4168 * cdef vector[fst.WeightClass] _distance * _shortestdistance(ifst, addr(_distance), delta, nstate, queue_type, reverse) * return [Weight(ifst._fst.get().WeightType(), weight.ToString()) # <<<<<<<<<<<<<< * for weight in _distance] * */ __Pyx_XDECREF(__pyx_r); { /* enter inner scope */ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pywrapfst.pyx":4169 * _shortestdistance(ifst, addr(_distance), delta, nstate, queue_type, reverse) * return [Weight(ifst._fst.get().WeightType(), weight.ToString()) * for weight in _distance] # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __pyx_v__distance.begin(); for (;;) { if (!(__pyx_t_3 != __pyx_v__distance.end())) break; __pyx_t_4 = *__pyx_t_3; ++__pyx_t_3; __pyx_7genexpr__pyx_v_weight = __pyx_t_4; /* "pywrapfst.pyx":4168 * cdef vector[fst.WeightClass] _distance * _shortestdistance(ifst, addr(_distance), delta, nstate, queue_type, reverse) * return [Weight(ifst._fst.get().WeightType(), weight.ToString()) # <<<<<<<<<<<<<< * for weight in _distance] * */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst"); __PYX_ERR(0, 4168, __pyx_L1_error) } __pyx_t_5 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_ifst->_fst.get()->WeightType()); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_7genexpr__pyx_v_weight.ToString()); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 4168, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "pywrapfst.pyx":4169 * _shortestdistance(ifst, addr(_distance), delta, nstate, queue_type, reverse) * return [Weight(ifst._fst.get().WeightType(), weight.ToString()) * for weight in _distance] # <<<<<<<<<<<<<< * * */ } } /* exit inner scope */ __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pywrapfst.pyx":4135 * * * def shortestdistance(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * int64 nstate=fst.kNoStateId, */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __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":4172 * * * cpdef MutableFst shortestpath(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * int32 nshortest=1, */ static PyObject *__pyx_pw_9pywrapfst_57shortestpath(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__51; int32 __pyx_v_nshortest = ((int32)1); int64 __pyx_v_nstate = __pyx_k__52; PyObject *__pyx_v_queue_type = ((PyObject *)__pyx_n_u_auto); /* "pywrapfst.pyx":4177 * int64 nstate=fst.kNoStateId, * queue_type="auto", * bool unique=False, # <<<<<<<<<<<<<< * weight=None): * """ */ bool __pyx_v_unique = ((bool)0); /* "pywrapfst.pyx":4178 * queue_type="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__weight; 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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":4210 * """ * 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 _weight = _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, 4210, __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":4212 * _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) * # Threshold is set to semiring Zero (no pruning) if no weight is specified. * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), # <<<<<<<<<<<<<< * weight) * cdef unique_ptr[fst.ShortestPathOptions] _opts */ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "weight_type"); __PYX_ERR(0, 4212, __pyx_L1_error) } /* "pywrapfst.pyx":4213 * # Threshold is set to semiring Zero (no pruning) if no weight is specified. * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), * weight) # <<<<<<<<<<<<<< * cdef unique_ptr[fst.ShortestPathOptions] _opts * _opts.reset( */ __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, 4212, __pyx_L1_error) __pyx_v__weight = __pyx_t_1; /* "pywrapfst.pyx":4216 * cdef unique_ptr[fst.ShortestPathOptions] _opts * _opts.reset( * new fst.ShortestPathOptions(_get_queue_type(tostring(queue_type)), # <<<<<<<<<<<<<< * nshortest, * unique, */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_queue_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4216, __pyx_L1_error) __pyx_t_3 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4216, __pyx_L1_error) /* "pywrapfst.pyx":4215 * weight) * cdef unique_ptr[fst.ShortestPathOptions] _opts * _opts.reset( # <<<<<<<<<<<<<< * new fst.ShortestPathOptions(_get_queue_type(tostring(queue_type)), * nshortest, */ __pyx_v__opts.reset(new fst::script::ShortestPathOptions(__pyx_t_3, __pyx_v_nshortest, __pyx_v_unique, __pyx_v_delta, __pyx_v__weight, __pyx_v_nstate)); /* "pywrapfst.pyx":4222 * _weight, * 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, 4222, __pyx_L1_error) } fst::script::ShortestPath((*__pyx_v_ifst->_fst), __pyx_v__tfst.get(), (*__pyx_v__opts)); /* "pywrapfst.pyx":4223 * 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, 4223, __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":4172 * * * 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_57shortestpath(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_56shortestpath[] = "\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_57shortestpath(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; float __pyx_v_delta; int32 __pyx_v_nshortest; int64 __pyx_v_nstate; PyObject *__pyx_v_queue_type = 0; bool __pyx_v_unique; PyObject *__pyx_v_weight = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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_u_auto); /* "pywrapfst.pyx":4178 * queue_type="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] = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_delta); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nshortest); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nstate); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_queue_type); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_unique); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 4172, __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, 4173, __pyx_L3_error) } else { __pyx_v_delta = __pyx_k__51; } if (values[2]) { __pyx_v_nshortest = __Pyx_PyInt_As_int32_t(values[2]); if (unlikely((__pyx_v_nshortest == ((int32)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4174, __pyx_L3_error) } else { __pyx_v_nshortest = ((int32)1); } if (values[3]) { __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nstate == ((int64)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4175, __pyx_L3_error) } else { __pyx_v_nstate = __pyx_k__52; } __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, 4177, __pyx_L3_error) } else { /* "pywrapfst.pyx":4177 * int64 nstate=fst.kNoStateId, * queue_type="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, 4172, __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, 4172, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_56shortestpath(__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":4172 * * * 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_56shortestpath(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst, float __pyx_v_delta, int32 __pyx_v_nshortest, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4172, __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":4226 * * * cpdef Fst statemap(Fst ifst, map_type): # <<<<<<<<<<<<<< * """ * state_map(ifst, map_type) */ static PyObject *__pyx_pw_9pywrapfst_59statemap(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("statemap", 0); /* "pywrapfst.pyx":4249 * FstArgError: Unknown map type. * """ * 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, 4249, __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":4226 * * * 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_59statemap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_9pywrapfst_58statemap[] = "\n state_map(ifst, map_type)\n\n Constructively applies a transform to all states.\n\n This operation transforms each state using one of the following:\n\n * arc_sum: sums weights of identically-labeled multi-arcs.\n * arc_unique: deletes non-unique identically-labeled multi-arcs.\n * identity: maps to self.\n\n Args:\n ifst: The input FST.\n map_type: A string matching a known mapping operation; one of: \"arc_sum\",\n \"arc_unique\", \"identity\".\n\n Returns:\n An FST with states remapped.\n\n Raises:\n FstArgError: Unknown map type.\n "; static PyObject *__pyx_pw_9pywrapfst_59statemap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst = 0; PyObject *__pyx_v_map_type = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_map_type)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("statemap", 1, 2, 2, 1); __PYX_ERR(0, 4226, __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, 4226, __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, 4226, __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, 4226, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_58statemap(__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_58statemap(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4226, __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":4252 * * * cpdef MutableFst synchronize(Fst ifst): # <<<<<<<<<<<<<< * """ * synchronize(ifst) */ static PyObject *__pyx_pw_9pywrapfst_61synchronize(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("synchronize", 0); /* "pywrapfst.pyx":4272 * """ * 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, 4272, __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":4273 * 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, 4273, __pyx_L1_error) } fst::script::Synchronize((*__pyx_v_ifst->_fst), __pyx_v__tfst.get()); /* "pywrapfst.pyx":4274 * _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, 4274, __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":4252 * * * 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_61synchronize(PyObject *__pyx_self, PyObject *__pyx_v_ifst); /*proto*/ static char __pyx_doc_9pywrapfst_60synchronize[] = "\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_61synchronize(PyObject *__pyx_self, PyObject *__pyx_v_ifst) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 4252, __pyx_L1_error) __pyx_r = __pyx_pf_9pywrapfst_60synchronize(__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_60synchronize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Fst *__pyx_v_ifst) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4252, __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":4331 * """ * * def __cinit__(self, # <<<<<<<<<<<<<< * str fst_type="vector", * str arc_type="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) { PyObject *__pyx_v_fst_type = 0; PyObject *__pyx_v_arc_type = 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; bool __pyx_v_keep_isymbols; bool __pyx_v_keep_osymbols; bool __pyx_v_keep_state_numbering; bool __pyx_v_allow_negative_labels; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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}; values[0] = ((PyObject*)__pyx_n_u_vector); values[1] = ((PyObject*)__pyx_n_u_standard); /* "pywrapfst.pyx":4334 * str fst_type="vector", * str arc_type="standard", * SymbolTable isymbols=None, # <<<<<<<<<<<<<< * SymbolTable osymbols=None, * SymbolTable ssymbols=None, */ values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None); /* "pywrapfst.pyx":4335 * str arc_type="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":4336 * 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 = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fst_type); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arc_type); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_isymbols); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_osymbols); if (value) { values[3] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ssymbols); if (value) { values[4] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_acceptor); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep_isymbols); if (value) { values[6] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep_osymbols); if (value) { values[7] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 8: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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 = __Pyx_PyDict_GetItemStr(__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, 4331, __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; } } __pyx_v_fst_type = ((PyObject*)values[0]); __pyx_v_arc_type = ((PyObject*)values[1]); __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, 4337, __pyx_L3_error) } else { /* "pywrapfst.pyx":4337 * 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, 4338, __pyx_L3_error) } else { /* "pywrapfst.pyx":4338 * 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, 4339, __pyx_L3_error) } else { /* "pywrapfst.pyx":4339 * 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, 4340, __pyx_L3_error) } else { /* "pywrapfst.pyx":4340 * 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, 4341, __pyx_L3_error) } else { /* "pywrapfst.pyx":4341 * 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, 4331, __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_fst_type), (&PyUnicode_Type), 1, "fst_type", 1))) __PYX_ERR(0, 4332, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arc_type), (&PyUnicode_Type), 1, "arc_type", 1))) __PYX_ERR(0, 4333, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_isymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "isymbols", 0))) __PYX_ERR(0, 4334, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "osymbols", 0))) __PYX_ERR(0, 4335, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "ssymbols", 0))) __PYX_ERR(0, 4336, __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":4331 * """ * * def __cinit__(self, # <<<<<<<<<<<<<< * str fst_type="vector", * str arc_type="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, PyObject *__pyx_v_fst_type, PyObject *__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 std::string __pyx_t_1; int __pyx_t_2; int __pyx_t_3; fst::SymbolTable const *__pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "pywrapfst.pyx":4342 * 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, 4342, __pyx_L1_error) } __pyx_v_self->_sstrm.reset(new std::stringstream()); /* "pywrapfst.pyx":4343 * 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_f_9pywrapfst_tostring(__pyx_v_fst_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4343, __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, 4343, __pyx_L1_error) } __pyx_v_self->_fst_type = __pyx_t_1; /* "pywrapfst.pyx":4344 * 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_f_9pywrapfst_tostring(__pyx_v_arc_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4344, __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, 4344, __pyx_L1_error) } __pyx_v_self->_arc_type = __pyx_t_1; /* "pywrapfst.pyx":4345 * self._fst_type = tostring(fst_type) * self._arc_type = tostring(arc_type) * self._isymbols = NULL # <<<<<<<<<<<<<< * if isymbols is not None: * self._isymbols = isymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_isymbols"); __PYX_ERR(0, 4345, __pyx_L1_error) } __pyx_v_self->_isymbols = NULL; /* "pywrapfst.pyx":4346 * self._arc_type = tostring(arc_type) * self._isymbols = NULL * if isymbols is not None: # <<<<<<<<<<<<<< * self._isymbols = isymbols._raw_ptr_or_raise() * self._osymbols = NULL */ __pyx_t_2 = (((PyObject *)__pyx_v_isymbols) != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "pywrapfst.pyx":4347 * self._isymbols = NULL * if isymbols is not None: * self._isymbols = isymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * 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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 4347, __pyx_L1_error) } __pyx_t_4 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTable *)__pyx_v_isymbols->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._raw_ptr_or_raise(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_isymbols)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4347, __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, 4347, __pyx_L1_error) } __pyx_v_self->_isymbols = __pyx_t_4; /* "pywrapfst.pyx":4346 * self._arc_type = tostring(arc_type) * self._isymbols = NULL * if isymbols is not None: # <<<<<<<<<<<<<< * self._isymbols = isymbols._raw_ptr_or_raise() * self._osymbols = NULL */ } /* "pywrapfst.pyx":4348 * if isymbols is not None: * self._isymbols = isymbols._raw_ptr_or_raise() * self._osymbols = NULL # <<<<<<<<<<<<<< * if osymbols is not None: * self._osymbols = osymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_osymbols"); __PYX_ERR(0, 4348, __pyx_L1_error) } __pyx_v_self->_osymbols = NULL; /* "pywrapfst.pyx":4349 * self._isymbols = isymbols._raw_ptr_or_raise() * self._osymbols = NULL * if osymbols is not None: # <<<<<<<<<<<<<< * self._osymbols = osymbols._raw_ptr_or_raise() * self._ssymbols = NULL */ __pyx_t_3 = (((PyObject *)__pyx_v_osymbols) != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); if (__pyx_t_2) { /* "pywrapfst.pyx":4350 * self._osymbols = NULL * if osymbols is not None: * self._osymbols = osymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * 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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 4350, __pyx_L1_error) } __pyx_t_4 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTable *)__pyx_v_osymbols->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._raw_ptr_or_raise(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_osymbols)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4350, __pyx_L1_error) if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_osymbols"); __PYX_ERR(0, 4350, __pyx_L1_error) } __pyx_v_self->_osymbols = __pyx_t_4; /* "pywrapfst.pyx":4349 * self._isymbols = isymbols._raw_ptr_or_raise() * self._osymbols = NULL * if osymbols is not None: # <<<<<<<<<<<<<< * self._osymbols = osymbols._raw_ptr_or_raise() * self._ssymbols = NULL */ } /* "pywrapfst.pyx":4351 * if osymbols is not None: * self._osymbols = osymbols._raw_ptr_or_raise() * self._ssymbols = NULL # <<<<<<<<<<<<<< * if ssymbols is not None: * self._ssymbols = ssymbols._raw_ptr_or_raise() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_ssymbols"); __PYX_ERR(0, 4351, __pyx_L1_error) } __pyx_v_self->_ssymbols = NULL; /* "pywrapfst.pyx":4352 * self._osymbols = osymbols._raw_ptr_or_raise() * self._ssymbols = NULL * if ssymbols is not None: # <<<<<<<<<<<<<< * self._ssymbols = ssymbols._raw_ptr_or_raise() * self._acceptor = acceptor */ __pyx_t_2 = (((PyObject *)__pyx_v_ssymbols) != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "pywrapfst.pyx":4353 * self._ssymbols = NULL * if ssymbols is not None: * self._ssymbols = ssymbols._raw_ptr_or_raise() # <<<<<<<<<<<<<< * 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'", "_raw_ptr_or_raise"); __PYX_ERR(0, 4353, __pyx_L1_error) } __pyx_t_4 = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTable *)__pyx_v_ssymbols->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._raw_ptr_or_raise(((struct __pyx_obj_9pywrapfst_SymbolTableView *)__pyx_v_ssymbols)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4353, __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, 4353, __pyx_L1_error) } __pyx_v_self->_ssymbols = __pyx_t_4; /* "pywrapfst.pyx":4352 * self._osymbols = osymbols._raw_ptr_or_raise() * self._ssymbols = NULL * if ssymbols is not None: # <<<<<<<<<<<<<< * self._ssymbols = ssymbols._raw_ptr_or_raise() * self._acceptor = acceptor */ } /* "pywrapfst.pyx":4354 * if ssymbols is not None: * self._ssymbols = ssymbols._raw_ptr_or_raise() * 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, 4354, __pyx_L1_error) } __pyx_v_self->_acceptor = __pyx_v_acceptor; /* "pywrapfst.pyx":4355 * self._ssymbols = ssymbols._raw_ptr_or_raise() * 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, 4355, __pyx_L1_error) } __pyx_v_self->_keep_isymbols = __pyx_v_keep_isymbols; /* "pywrapfst.pyx":4356 * 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, 4356, __pyx_L1_error) } __pyx_v_self->_keep_osymbols = __pyx_v_keep_osymbols; /* "pywrapfst.pyx":4357 * 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, 4357, __pyx_L1_error) } __pyx_v_self->_keep_state_numbering = __pyx_v_keep_state_numbering; /* "pywrapfst.pyx":4358 * 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, 4358, __pyx_L1_error) } __pyx_v_self->_allow_negative_labels = __pyx_v_allow_negative_labels; /* "pywrapfst.pyx":4331 * """ * * def __cinit__(self, # <<<<<<<<<<<<<< * str fst_type="vector", * str arc_type="standard", */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pywrapfst.Compiler.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":4360 * 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; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_compile); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4360, __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, 4360, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4375 * """ * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.CompileFstInternal(deref(self._sstrm), # <<<<<<<<<<<<<< * b"", * self._fst_type, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_sstrm"); __PYX_ERR(0, 4375, __pyx_L1_error) } /* "pywrapfst.pyx":4377 * _tfst.reset(fst.CompileFstInternal(deref(self._sstrm), * b"", * self._fst_type, # <<<<<<<<<<<<<< * self._arc_type, * self._isymbols, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_fst_type"); __PYX_ERR(0, 4377, __pyx_L1_error) } /* "pywrapfst.pyx":4378 * b"", * self._fst_type, * self._arc_type, # <<<<<<<<<<<<<< * self._isymbols, * self._osymbols, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_arc_type"); __PYX_ERR(0, 4378, __pyx_L1_error) } /* "pywrapfst.pyx":4379 * self._fst_type, * self._arc_type, * self._isymbols, # <<<<<<<<<<<<<< * self._osymbols, * self._ssymbols, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_isymbols"); __PYX_ERR(0, 4379, __pyx_L1_error) } /* "pywrapfst.pyx":4380 * self._arc_type, * self._isymbols, * self._osymbols, # <<<<<<<<<<<<<< * self._ssymbols, * self._acceptor, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_osymbols"); __PYX_ERR(0, 4380, __pyx_L1_error) } /* "pywrapfst.pyx":4381 * 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'", "_ssymbols"); __PYX_ERR(0, 4381, __pyx_L1_error) } /* "pywrapfst.pyx":4382 * self._osymbols, * self._ssymbols, * self._acceptor, # <<<<<<<<<<<<<< * self._keep_isymbols, * self._keep_osymbols, */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_acceptor"); __PYX_ERR(0, 4382, __pyx_L1_error) } /* "pywrapfst.pyx":4383 * self._ssymbols, * self._acceptor, * self._keep_isymbols, # <<<<<<<<<<<<<< * self._keep_osymbols, * self._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, 4383, __pyx_L1_error) } /* "pywrapfst.pyx":4384 * 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'", "_keep_osymbols"); __PYX_ERR(0, 4384, __pyx_L1_error) } /* "pywrapfst.pyx":4385 * 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_state_numbering"); __PYX_ERR(0, 4385, __pyx_L1_error) } /* "pywrapfst.pyx":4386 * 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, 4386, __pyx_L1_error) } /* "pywrapfst.pyx":4375 * """ * cdef unique_ptr[fst.FstClass] _tfst * _tfst.reset(fst.CompileFstInternal(deref(self._sstrm), # <<<<<<<<<<<<<< * b"", * self._fst_type, */ __pyx_v__tfst.reset(fst::script::CompileFstInternal((*__pyx_v_self->_sstrm), __pyx_k_pywrapfst, __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":4387 * 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, 4387, __pyx_L1_error) } __pyx_v_self->_sstrm.reset(new std::stringstream()); /* "pywrapfst.pyx":4388 * self._allow_negative_labels)) * self._sstrm.reset(new stringstream()) * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstOpError("Compilation failed") * return _init_XFst(_tfst.release()) */ __pyx_t_5 = ((__pyx_v__tfst.get() == NULL) != 0); if (unlikely(__pyx_t_5)) { /* "pywrapfst.pyx":4389 * self._sstrm.reset(new stringstream()) * if _tfst.get() == NULL: * raise FstOpError("Compilation failed") # <<<<<<<<<<<<<< * return _init_XFst(_tfst.release()) * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_Compilation_failed) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_Compilation_failed); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4389, __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, 4389, __pyx_L1_error) /* "pywrapfst.pyx":4388 * self._allow_negative_labels)) * self._sstrm.reset(new stringstream()) * if _tfst.get() == NULL: # <<<<<<<<<<<<<< * raise FstOpError("Compilation failed") * return _init_XFst(_tfst.release()) */ } /* "pywrapfst.pyx":4390 * 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_1 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v__tfst.release())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4390, __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":4360 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4360, __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":4392 * 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) { std::string __pyx_v__line; __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; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_expression) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_expression); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4392, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4408 * expression: A string expression to add to compiler string buffer. * """ * cdef string _line = tostring(expression) # <<<<<<<<<<<<<< * if not _line.empty() and _line.back() != b'\n': * _line.append(b'\n') */ __pyx_t_5 = __pyx_f_9pywrapfst_tostring(__pyx_v_expression); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4408, __pyx_L1_error) __pyx_v__line = __pyx_t_5; /* "pywrapfst.pyx":4409 * """ * cdef string _line = tostring(expression) * if not _line.empty() and _line.back() != b'\n': # <<<<<<<<<<<<<< * _line.append(b'\n') * deref(self._sstrm) << _line */ __pyx_t_7 = ((!(__pyx_v__line.empty() != 0)) != 0); if (__pyx_t_7) { } else { __pyx_t_6 = __pyx_t_7; goto __pyx_L4_bool_binop_done; } __pyx_t_7 = ((__pyx_v__line.back() != '\n') != 0); __pyx_t_6 = __pyx_t_7; __pyx_L4_bool_binop_done:; if (__pyx_t_6) { /* "pywrapfst.pyx":4410 * cdef string _line = tostring(expression) * if not _line.empty() and _line.back() != b'\n': * _line.append(b'\n') # <<<<<<<<<<<<<< * deref(self._sstrm) << _line * */ (void)(__pyx_v__line.append(((char const *)"\n"))); /* "pywrapfst.pyx":4409 * """ * cdef string _line = tostring(expression) * if not _line.empty() and _line.back() != b'\n': # <<<<<<<<<<<<<< * _line.append(b'\n') * deref(self._sstrm) << _line */ } /* "pywrapfst.pyx":4411 * if not _line.empty() and _line.back() != b'\n': * _line.append(b'\n') * deref(self._sstrm) << _line # <<<<<<<<<<<<<< * * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_sstrm"); __PYX_ERR(0, 4411, __pyx_L1_error) } (void)(((*__pyx_v_self->_sstrm) << __pyx_v__line)); /* "pywrapfst.pyx":4392 * 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_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 compiler.write(\"0 0 49 49\")\n compiler.write(\"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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4392, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__53, 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__54, 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":4433 * """ * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":4434 * * def __init__(self): * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") # <<<<<<<<<<<<<< * * def __repr__(self): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Cannot_construct, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4434, __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, 4434, __pyx_L1_error) /* "pywrapfst.pyx":4433 * """ * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pywrapfst.FarReader.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":4436 * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.far_type()} FarReader at 0x{id(self):x}>" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":4437 * * def __repr__(self): * return f"<{self.far_type()} FarReader at 0x{id(self):x}>" # <<<<<<<<<<<<<< * * @classmethod */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u__2); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u__2); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "far_type"); __PYX_ERR(0, 4437, __pyx_L1_error) } __pyx_t_4 = __pyx_convert_PyUnicode_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_4)) __PYX_ERR(0, 4437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_FarReader_at_0x); __pyx_t_2 += 16; __Pyx_GIVEREF(__pyx_kp_u_FarReader_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_FarReader_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":4436 * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.far_type()} FarReader at 0x{id(self):x}>" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __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":4440 * * @classmethod * def open(cls, *sources): # <<<<<<<<<<<<<< * """ * FarReader.open(*sources) */ /* 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(*sources)\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 *sources: 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_sources = 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_sources = __pyx_args; __pyx_r = __pyx_pf_9pywrapfst_9FarReader_4open(((PyTypeObject*)__pyx_v_cls), __pyx_v_sources); /* function exit code */ __Pyx_XDECREF(__pyx_v_sources); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_9FarReader_4open(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_sources) { std::vector __pyx_v__sources; std::unique_ptr __pyx_v__tfar; struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_reader = 0; PyObject *__pyx_8genexpr1__pyx_v_source = 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("open", 0); /* "pywrapfst.pyx":4458 * FstIOError: Read failed. * """ * cdef vector[string] _sources = [path_tostring(source) for source in sources] # <<<<<<<<<<<<<< * cdef unique_ptr[fst.FarReaderClass] _tfar * _tfar.reset(fst.FarReaderClass.Open(_sources)) */ { /* enter inner scope */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4458, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __pyx_v_sources; __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, 4458, __pyx_L5_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4458, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_source, __pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __pyx_f_9pywrapfst_path_tostring(__pyx_8genexpr1__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4458, __pyx_L5_error) __pyx_t_4 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4458, __pyx_L5_error) __Pyx_GOTREF(__pyx_t_4); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 4458, __pyx_L5_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_source); __pyx_8genexpr1__pyx_v_source = 0; goto __pyx_L8_exit_scope; __pyx_L5_error:; __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_source); __pyx_8genexpr1__pyx_v_source = 0; goto __pyx_L1_error; __pyx_L8_exit_scope:; } /* exit inner scope */ __pyx_t_6 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4458, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v__sources = __pyx_t_6; /* "pywrapfst.pyx":4460 * cdef vector[string] _sources = [path_tostring(source) for source in sources] * cdef unique_ptr[fst.FarReaderClass] _tfar * _tfar.reset(fst.FarReaderClass.Open(_sources)) # <<<<<<<<<<<<<< * if _tfar.get() == NULL: * raise FstIOError(f"Read failed: {sources!r}") */ __pyx_v__tfar.reset(fst::script::FarReaderClass::Open(__pyx_v__sources)); /* "pywrapfst.pyx":4461 * cdef unique_ptr[fst.FarReaderClass] _tfar * _tfar.reset(fst.FarReaderClass.Open(_sources)) * if _tfar.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {sources!r}") * cdef FarReader reader = FarReader.__new__(FarReader) */ __pyx_t_7 = ((__pyx_v__tfar.get() == NULL) != 0); if (unlikely(__pyx_t_7)) { /* "pywrapfst.pyx":4462 * _tfar.reset(fst.FarReaderClass.Open(_sources)) * if _tfar.get() == NULL: * raise FstIOError(f"Read failed: {sources!r}") # <<<<<<<<<<<<<< * cdef FarReader reader = FarReader.__new__(FarReader) * reader._reader.reset(_tfar.release()) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_sources), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Read_failed, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __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); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_8); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4462, __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, 4462, __pyx_L1_error) /* "pywrapfst.pyx":4461 * cdef unique_ptr[fst.FarReaderClass] _tfar * _tfar.reset(fst.FarReaderClass.Open(_sources)) * if _tfar.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Read failed: {sources!r}") * cdef FarReader reader = FarReader.__new__(FarReader) */ } /* "pywrapfst.pyx":4463 * if _tfar.get() == NULL: * raise FstIOError(f"Read failed: {sources!r}") * cdef FarReader reader = FarReader.__new__(FarReader) # <<<<<<<<<<<<<< * reader._reader.reset(_tfar.release()) * return reader */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_9pywrapfst_FarReader(((PyTypeObject *)__pyx_ptype_9pywrapfst_FarReader), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4463, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v_reader = ((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":4464 * raise FstIOError(f"Read failed: {sources!r}") * cdef FarReader reader = FarReader.__new__(FarReader) * reader._reader.reset(_tfar.release()) # <<<<<<<<<<<<<< * return reader * */ if (unlikely(((PyObject *)__pyx_v_reader) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); __PYX_ERR(0, 4464, __pyx_L1_error) } __pyx_v_reader->_reader.reset(__pyx_v__tfar.release()); /* "pywrapfst.pyx":4465 * cdef FarReader reader = FarReader.__new__(FarReader) * reader._reader.reset(_tfar.release()) * return reader # <<<<<<<<<<<<<< * * cpdef string arc_type(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_reader)); __pyx_r = ((PyObject *)__pyx_v_reader); goto __pyx_L0; /* "pywrapfst.pyx":4440 * * @classmethod * def open(cls, *sources): # <<<<<<<<<<<<<< * """ * FarReader.open(*sources) */ /* 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_AddTraceback("pywrapfst.FarReader.open", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_reader); __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_source); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":4467 * return reader * * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_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)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; 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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4473 * 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, 4473, __pyx_L1_error) } __pyx_r = __pyx_v_self->_reader.get()->ArcType(); goto __pyx_L0; /* "pywrapfst.pyx":4467 * return reader * * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("arc_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_arc_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.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":4475 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4475, __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, 4475, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4484 * 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, 4484, __pyx_L1_error) } __pyx_r = __pyx_v_self->_reader.get()->Done(); goto __pyx_L0; /* "pywrapfst.pyx":4475 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4475, __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":4486 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4486, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4486, __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, 4486, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4495 * 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, 4495, __pyx_L1_error) } __pyx_r = __pyx_v_self->_reader.get()->Error(); goto __pyx_L0; /* "pywrapfst.pyx":4486 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4486, __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":4497 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_far_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4497, __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, 4497, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4498 * * cpdef string far_type(self): * return fst.GetFarTypeString(self._reader.get().Type()) # <<<<<<<<<<<<<< * * cpdef bool find(self, key): */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); __PYX_ERR(0, 4498, __pyx_L1_error) } __pyx_r = fst::GetFarTypeString(__pyx_v_self->_reader.get()->Type()); goto __pyx_L0; /* "pywrapfst.pyx":4497 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("far_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_far_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4497, __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":4500 * return fst.GetFarTypeString(self._reader.get().Type()) * * cpdef bool find(self, key): # <<<<<<<<<<<<<< * """ * 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; bool __pyx_t_5; std::string __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_find); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_key) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_key); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4500, __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, 4500, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4513 * 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, 4513, __pyx_L1_error) } __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_key); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4513, __pyx_L1_error) __pyx_r = __pyx_v_self->_reader.get()->Find(__pyx_t_6); goto __pyx_L0; /* "pywrapfst.pyx":4500 * return fst.GetFarTypeString(self._reader.get().Type()) * * cpdef bool find(self, key): # <<<<<<<<<<<<<< * """ * 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_WriteUnraisable("pywrapfst.FarReader.find", __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_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 PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("find", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_9FarReader_find(__pyx_v_self, __pyx_v_key, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4500, __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.find", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":4515 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_fst); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4515, __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, 4515, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4524 * 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): */ __Pyx_XDECREF(((PyObject *)__pyx_r)); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); __PYX_ERR(0, 4524, __pyx_L1_error) } __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, 4524, __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":4515 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4515, __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":4526 * return _init_XFst(new fst.FstClass(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4526, __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, 4526, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4535 * 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, 4535, __pyx_L1_error) } __pyx_r = __pyx_v_self->_reader.get()->GetKey(); goto __pyx_L0; /* "pywrapfst.pyx":4526 * return _init_XFst(new fst.FstClass(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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_key", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_get_key(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4526, __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":4537 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4537, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4543 * 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, 4543, __pyx_L1_error) } __pyx_v_self->_reader.get()->Next(); /* "pywrapfst.pyx":4537 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4537, __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":4545 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4545, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4551 * 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, 4551, __pyx_L1_error) } __pyx_v_self->_reader.get()->Reset(); /* "pywrapfst.pyx":4545 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4545, __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":4553 * self._reader.get().Reset() * * def __getitem__(self, key): # <<<<<<<<<<<<<< * if self._reader.get().Find(tostring(key)): * return self.get_fst() */ /* 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) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); /* "pywrapfst.pyx":4554 * * def __getitem__(self, key): * if self._reader.get().Find(tostring(key)): # <<<<<<<<<<<<<< * return self.get_fst() * else: */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_reader"); __PYX_ERR(0, 4554, __pyx_L1_error) } __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_key); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4554, __pyx_L1_error) __pyx_t_2 = (__pyx_v_self->_reader.get()->Find(__pyx_t_1) != 0); if (likely(__pyx_t_2)) { /* "pywrapfst.pyx":4555 * def __getitem__(self, key): * if self._reader.get().Find(tostring(key)): * return self.get_fst() # <<<<<<<<<<<<<< * else: * 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, 4555, __pyx_L1_error) } __pyx_t_3 = ((PyObject *)((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->get_fst(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "pywrapfst.pyx":4554 * * def __getitem__(self, key): * if self._reader.get().Find(tostring(key)): # <<<<<<<<<<<<<< * return self.get_fst() * else: */ } /* "pywrapfst.pyx":4557 * return self.get_fst() * else: * raise KeyError(key) # <<<<<<<<<<<<<< * * def __next__(self): */ /*else*/ { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_KeyError, __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 4557, __pyx_L1_error) } /* "pywrapfst.pyx":4553 * self._reader.get().Reset() * * def __getitem__(self, key): # <<<<<<<<<<<<<< * if self._reader.get().Find(tostring(key)): * return self.get_fst() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __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; } /* "pywrapfst.pyx":4559 * raise KeyError(key) * * def __next__(self): # <<<<<<<<<<<<<< * if self.done(): * raise StopIteration */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_9FarReader_27__next__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_9FarReader_27__next__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_9FarReader_26__next__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_9FarReader_26__next__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { std::string __pyx_v__key; struct __pyx_obj_9pywrapfst_Fst *__pyx_v__fst = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__next__", 0); /* "pywrapfst.pyx":4560 * * def __next__(self): * if self.done(): # <<<<<<<<<<<<<< * raise StopIteration * cdef string _key = self.get_key() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "done"); __PYX_ERR(0, 4560, __pyx_L1_error) } __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0); if (unlikely(__pyx_t_1)) { /* "pywrapfst.pyx":4561 * def __next__(self): * if self.done(): * raise StopIteration # <<<<<<<<<<<<<< * cdef string _key = self.get_key() * cdef Fst _fst = self.get_fst() */ __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); __PYX_ERR(0, 4561, __pyx_L1_error) /* "pywrapfst.pyx":4560 * * def __next__(self): * if self.done(): # <<<<<<<<<<<<<< * raise StopIteration * cdef string _key = self.get_key() */ } /* "pywrapfst.pyx":4562 * if self.done(): * raise StopIteration * cdef string _key = self.get_key() # <<<<<<<<<<<<<< * cdef Fst _fst = self.get_fst() * self.next() */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get_key"); __PYX_ERR(0, 4562, __pyx_L1_error) } __pyx_v__key = ((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->get_key(__pyx_v_self, 0); /* "pywrapfst.pyx":4563 * raise StopIteration * cdef string _key = self.get_key() * cdef Fst _fst = self.get_fst() # <<<<<<<<<<<<<< * self.next() * return (_key, _fst) */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get_fst"); __PYX_ERR(0, 4563, __pyx_L1_error) } __pyx_t_2 = ((PyObject *)((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->get_fst(__pyx_v_self, 0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v__fst = ((struct __pyx_obj_9pywrapfst_Fst *)__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":4564 * cdef string _key = self.get_key() * cdef Fst _fst = self.get_fst() * self.next() # <<<<<<<<<<<<<< * return (_key, _fst) * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "next"); __PYX_ERR(0, 4564, __pyx_L1_error) } ((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0); /* "pywrapfst.pyx":4565 * cdef Fst _fst = self.get_fst() * self.next() * return (_key, _fst) # <<<<<<<<<<<<<< * * # This just registers this class as a possible iterator. */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v__key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_INCREF(((PyObject *)__pyx_v__fst)); __Pyx_GIVEREF(((PyObject *)__pyx_v__fst)); PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v__fst)); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "pywrapfst.pyx":4559 * raise KeyError(key) * * 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_AddTraceback("pywrapfst.FarReader.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v__fst); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":4568 * * # This just registers this class as a possible iterator. * def __iter__(self): # <<<<<<<<<<<<<< * return self * */ /* Python wrapper */ static PyObject *__pyx_pw_9pywrapfst_9FarReader_29__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_9FarReader_29__iter__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); __pyx_r = __pyx_pf_9pywrapfst_9FarReader_28__iter__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_9FarReader_28__iter__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__", 0); /* "pywrapfst.pyx":4569 * # This just registers this class as a possible iterator. * def __iter__(self): * return self # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "pywrapfst.pyx":4568 * * # 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; } /* "(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_31__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_9FarReader_31__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_30__reduce_cython__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_9pywrapfst_9FarReader_30__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__55, 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_33__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static PyObject *__pyx_pw_9pywrapfst_9FarReader_33__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_32__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_32__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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__56, 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":4592 * """ * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "pywrapfst.pyx":4593 * * def __init__(self): * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") # <<<<<<<<<<<<<< * * def __repr__(self): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Cannot_construct, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4593, __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, 4593, __pyx_L1_error) /* "pywrapfst.pyx":4592 * """ * * def __init__(self): # <<<<<<<<<<<<<< * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pywrapfst.FarWriter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":4595 * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.far_type()} FarWriter at 0x{id(self):x}>" * */ /* 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; Py_ssize_t __pyx_t_2; Py_UCS4 __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__repr__", 0); /* "pywrapfst.pyx":4596 * * def __repr__(self): * return f"<{self.far_type()} FarWriter at 0x{id(self):x}>" # <<<<<<<<<<<<<< * * @classmethod */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = 127; __Pyx_INCREF(__pyx_kp_u__2); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u__2); if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "far_type"); __PYX_ERR(0, 4596, __pyx_L1_error) } __pyx_t_4 = __pyx_convert_PyUnicode_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_4)) __PYX_ERR(0, 4596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); __pyx_t_4 = 0; __Pyx_INCREF(__pyx_kp_u_FarWriter_at_0x); __pyx_t_2 += 16; __Pyx_GIVEREF(__pyx_kp_u_FarWriter_at_0x); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_FarWriter_at_0x); __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_Format(__pyx_t_4, __pyx_n_u_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_3; __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_5); __pyx_t_5 = 0; __Pyx_INCREF(__pyx_kp_u__3); __pyx_t_2 += 1; __Pyx_GIVEREF(__pyx_kp_u__3); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__3); __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_5; __pyx_t_5 = 0; goto __pyx_L0; /* "pywrapfst.pyx":4595 * raise NotImplementedError(f"Cannot construct {self.__class__.__name__}") * * def __repr__(self): # <<<<<<<<<<<<<< * return f"<{self.far_type()} FarWriter at 0x{id(self):x}>" * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __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":4599 * * @classmethod * def create(cls, source, arc_type="standard", far_type="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 source: 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_source = 0; PyObject *__pyx_v_arc_type = 0; PyObject *__pyx_v_far_type = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("create (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source,&__pyx_n_s_arc_type,&__pyx_n_s_far_type,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_n_u_standard); values[2] = ((PyObject *)__pyx_n_u_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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_source)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arc_type); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__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, 4599, __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_source = 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, 4599, __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_source, __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_source, PyObject *__pyx_v_arc_type, PyObject *__pyx_v_far_type) { std::unique_ptr __pyx_v__tfar; struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_writer = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations std::string __pyx_t_1; std::string __pyx_t_2; std::string __pyx_t_3; fst::FarType __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("create", 0); /* "pywrapfst.pyx":4622 * cdef unique_ptr[fst.FarWriterClass] _tfar * _tfar.reset(fst.FarWriterClass.Create( * path_tostring(source), # <<<<<<<<<<<<<< * tostring(arc_type), * _get_far_type(tostring(far_type)))) */ __pyx_t_1 = __pyx_f_9pywrapfst_path_tostring(__pyx_v_source); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4622, __pyx_L1_error) /* "pywrapfst.pyx":4623 * _tfar.reset(fst.FarWriterClass.Create( * path_tostring(source), * tostring(arc_type), # <<<<<<<<<<<<<< * _get_far_type(tostring(far_type)))) * if _tfar.get() == NULL: */ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4623, __pyx_L1_error) /* "pywrapfst.pyx":4624 * path_tostring(source), * tostring(arc_type), * _get_far_type(tostring(far_type)))) # <<<<<<<<<<<<<< * if _tfar.get() == NULL: * raise FstIOError(f"Open failed: {source!r}") */ __pyx_t_3 = __pyx_f_9pywrapfst_tostring(__pyx_v_far_type); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4624, __pyx_L1_error) __pyx_t_4 = __pyx_f_9pywrapfst__get_far_type(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4624, __pyx_L1_error) /* "pywrapfst.pyx":4621 * """ * cdef unique_ptr[fst.FarWriterClass] _tfar * _tfar.reset(fst.FarWriterClass.Create( # <<<<<<<<<<<<<< * path_tostring(source), * tostring(arc_type), */ __pyx_v__tfar.reset(fst::script::FarWriterClass::Create(__pyx_t_1, __pyx_t_2, __pyx_t_4)); /* "pywrapfst.pyx":4625 * tostring(arc_type), * _get_far_type(tostring(far_type)))) * if _tfar.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Open failed: {source!r}") * cdef FarWriter writer = FarWriter.__new__(FarWriter) */ __pyx_t_5 = ((__pyx_v__tfar.get() == NULL) != 0); if (unlikely(__pyx_t_5)) { /* "pywrapfst.pyx":4626 * _get_far_type(tostring(far_type)))) * if _tfar.get() == NULL: * raise FstIOError(f"Open failed: {source!r}") # <<<<<<<<<<<<<< * cdef FarWriter writer = FarWriter.__new__(FarWriter) * writer._writer = move(_tfar) */ __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_FstIOError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_v_source), __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Open_failed, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_9); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 4626, __pyx_L1_error) /* "pywrapfst.pyx":4625 * tostring(arc_type), * _get_far_type(tostring(far_type)))) * if _tfar.get() == NULL: # <<<<<<<<<<<<<< * raise FstIOError(f"Open failed: {source!r}") * cdef FarWriter writer = FarWriter.__new__(FarWriter) */ } /* "pywrapfst.pyx":4627 * if _tfar.get() == NULL: * raise FstIOError(f"Open failed: {source!r}") * cdef FarWriter writer = FarWriter.__new__(FarWriter) # <<<<<<<<<<<<<< * writer._writer = move(_tfar) * return writer */ __pyx_t_6 = ((PyObject *)__pyx_tp_new_9pywrapfst_FarWriter(((PyTypeObject *)__pyx_ptype_9pywrapfst_FarWriter), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4627, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_6)); __pyx_v_writer = ((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_t_6); __pyx_t_6 = 0; /* "pywrapfst.pyx":4628 * raise FstIOError(f"Open failed: {source!r}") * cdef FarWriter writer = FarWriter.__new__(FarWriter) * writer._writer = move(_tfar) # <<<<<<<<<<<<<< * return writer * */ if (unlikely(((PyObject *)__pyx_v_writer) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); __PYX_ERR(0, 4628, __pyx_L1_error) } __pyx_v_writer->_writer = fst::move >(__pyx_v__tfar); /* "pywrapfst.pyx":4629 * cdef FarWriter writer = FarWriter.__new__(FarWriter) * writer._writer = move(_tfar) * return writer # <<<<<<<<<<<<<< * * # NB: Invoking this method may be dangerous: calling any other method on the */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_writer)); __pyx_r = ((PyObject *)__pyx_v_writer); goto __pyx_L0; /* "pywrapfst.pyx":4599 * * @classmethod * def create(cls, source, arc_type="standard", far_type="default"): # <<<<<<<<<<<<<< * """ * FarWriter. */ /* function exit code */ __pyx_L1_error:; __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_writer); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pywrapfst.pyx":4633 * # 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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close", 0); /* "pywrapfst.pyx":4634 * # 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, 4634, __pyx_L1_error) } __pyx_v_self->_writer.reset(); /* "pywrapfst.pyx":4633 * # 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":4636 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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, 4636, __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, 4636, __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, 4636, __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, 4636, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4654 * # 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") * */ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "_writer"); __PYX_ERR(0, 4654, __pyx_L1_error) } __pyx_t_7 = __pyx_f_9pywrapfst_tostring(__pyx_v_key); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4654, __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, 4654, __pyx_L1_error) } __pyx_t_8 = ((!(__pyx_v_self->_writer.get()->Add(__pyx_t_7, (*__pyx_v_ifst->_fst)) != 0)) != 0); if (unlikely(__pyx_t_8)) { /* "pywrapfst.pyx":4655 * # 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") # <<<<<<<<<<<<<< * * cpdef string arc_type(self): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4655, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(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); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_Incompatible_or_invalid_arc_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_Incompatible_or_invalid_arc_type); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4655, __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, 4655, __pyx_L1_error) /* "pywrapfst.pyx":4654 * # 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") * */ } /* "pywrapfst.pyx":4636 * 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 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 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] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_key)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, 1); __PYX_ERR(0, 4636, __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, 4636, __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, 4636, __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, 4636, __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4636, __pyx_L1_error) __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4636, __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":4657 * raise FstOpError("Incompatible or invalid arc type") * * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4657, __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, 4657, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4663 * 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, 4663, __pyx_L1_error) } __pyx_r = __pyx_v_self->_writer.get()->ArcType(); goto __pyx_L0; /* "pywrapfst.pyx":4657 * raise FstOpError("Incompatible or invalid 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.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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("arc_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarWriter_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4657, __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":4665 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4665, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4665, __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, 4665, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4674 * 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, 4674, __pyx_L1_error) } __pyx_r = __pyx_v_self->_writer.get()->Error(); goto __pyx_L0; /* "pywrapfst.pyx":4665 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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, 4665, __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":4676 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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) || (Py_TYPE(((PyObject *)__pyx_v_self))->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_far_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__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); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4676, __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, 4676, __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; } #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_type_dict_guard != __pyx_tp_dict_version)) { __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; } #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS } #endif } /* "pywrapfst.pyx":4682 * 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, 4682, __pyx_L1_error) } __pyx_r = fst::GetFarTypeString(__pyx_v_self->_writer.get()->Type()); goto __pyx_L0; /* "pywrapfst.pyx":4676 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("far_type", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarWriter_far_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4676, __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":4685 * * # 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_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; 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, 4685, __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 int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setitem__", 0); /* "pywrapfst.pyx":4686 * # 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, 4686, __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, 4686, __pyx_L1_error) /* "pywrapfst.pyx":4685 * * # 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__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._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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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__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._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; } /* "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 = 0 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0); /* "string.from_py":14 * @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 = 0 # <<<<<<<<<<<<<< * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) * return string(data, length) */ __pyx_v_length = 0; /* "string.from_py":15 * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: * cdef Py_ssize_t length = 0 * 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 = 0 * 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 = 0 * 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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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_int64") * cdef vector[X] __pyx_convert_vector_from_py_int64(object o) except *: # <<<<<<<<<<<<<< * cdef vector[X] v * for item in o: */ static std::vector __pyx_convert_vector_from_py_int64(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; int64 __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_int64", 0); /* "vector.from_py":47 * cdef vector[X] __pyx_convert_vector_from_py_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)-1)) && PyErr_Occurred())) __PYX_ERR(1, 48, __pyx_L1_error) __pyx_v_v.push_back(((int64)__pyx_t_5)); /* "vector.from_py":47 * cdef vector[X] __pyx_convert_vector_from_py_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_int64") * cdef vector[X] __pyx_convert_vector_from_py_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_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; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __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}, {"no_weight", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_15no_weight, METH_O, __pyx_doc_9pywrapfst_6Weight_14no_weight}, {"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}, {"member", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_25member, METH_NOARGS, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_27__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_29__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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_9pywrapfst_SymbolTableView __pyx_vtable_9pywrapfst_SymbolTableView; static PyObject *__pyx_tp_new_9pywrapfst_SymbolTableView(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_9pywrapfst_SymbolTableView *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_SymbolTableView *)o); p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_SymbolTableView; return o; } static void __pyx_tp_dealloc_9pywrapfst_SymbolTableView(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_SymbolTableView[] = { {"__reduce__", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_5__reduce__, METH_NOARGS, 0}, {"available_key", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_7available_key, METH_NOARGS, __pyx_doc_9pywrapfst_15SymbolTableView_6available_key}, {"checksum", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_9checksum, METH_NOARGS, __pyx_doc_9pywrapfst_15SymbolTableView_8checksum}, {"copy", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_11copy, METH_NOARGS, __pyx_doc_9pywrapfst_15SymbolTableView_10copy}, {"find", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_13find, METH_O, __pyx_doc_9pywrapfst_15SymbolTableView_12find}, {"get_nth_key", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_15get_nth_key, METH_O, __pyx_doc_9pywrapfst_15SymbolTableView_14get_nth_key}, {"labeled_checksum", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_17labeled_checksum, METH_NOARGS, __pyx_doc_9pywrapfst_15SymbolTableView_16labeled_checksum}, {"member", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_19member, METH_O, __pyx_doc_9pywrapfst_15SymbolTableView_18member}, {"name", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_21name, METH_NOARGS, __pyx_doc_9pywrapfst_15SymbolTableView_20name}, {"num_symbols", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_23num_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_15SymbolTableView_22num_symbols}, {"write", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_25write, METH_O, __pyx_doc_9pywrapfst_15SymbolTableView_24write}, {"write_text", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_27write_text, METH_O, __pyx_doc_9pywrapfst_15SymbolTableView_26write_text}, {"write_to_string", (PyCFunction)__pyx_pw_9pywrapfst_15SymbolTableView_29write_to_string, METH_NOARGS, __pyx_doc_9pywrapfst_15SymbolTableView_28write_to_string}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_9pywrapfst_SymbolTableView = { PyVarObject_HEAD_INIT(0, 0) "pywrapfst.SymbolTableView", /*tp_name*/ sizeof(struct __pyx_obj_9pywrapfst_SymbolTableView), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_9pywrapfst_SymbolTableView, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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 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_15SymbolTableView_3__iter__, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_9pywrapfst_SymbolTableView, /*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_15SymbolTableView_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_9pywrapfst_SymbolTableView, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTableView __pyx_vtable_9pywrapfst__EncodeMapperSymbolTableView; static PyObject *__pyx_tp_new_9pywrapfst__EncodeMapperSymbolTableView(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *p; PyObject *o = __pyx_tp_new_9pywrapfst_SymbolTableView(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst_SymbolTableView*)__pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTableView; new((void*)&(p->_mapper)) std::shared_ptr (); return o; } static void __pyx_tp_dealloc_9pywrapfst__EncodeMapperSymbolTableView(PyObject *o) { struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *p = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *)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->_mapper); __pyx_tp_dealloc_9pywrapfst_SymbolTableView(o); } static PyMethodDef __pyx_methods_9pywrapfst__EncodeMapperSymbolTableView[] = { {0, 0, 0, 0} }; static PyTypeObject __pyx_type_9pywrapfst__EncodeMapperSymbolTableView = { PyVarObject_HEAD_INIT(0, 0) "pywrapfst._EncodeMapperSymbolTableView", /*tp_name*/ sizeof(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_9pywrapfst__EncodeMapperSymbolTableView, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_28_EncodeMapperSymbolTableView_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_15SymbolTableView_3__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif 0, /*tp_iternext*/ __pyx_methods_9pywrapfst__EncodeMapperSymbolTableView, /*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_15SymbolTableView_1__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_9pywrapfst__EncodeMapperSymbolTableView, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_9pywrapfst__FstSymbolTableView __pyx_vtable_9pywrapfst__FstSymbolTableView; static PyObject *__pyx_tp_new_9pywrapfst__FstSymbolTableView(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_9pywrapfst__FstSymbolTableView *p; PyObject *o = __pyx_tp_new_9pywrapfst_SymbolTableView(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_9pywrapfst__FstSymbolTableView *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst_SymbolTableView*)__pyx_vtabptr_9pywrapfst__FstSymbolTableView; new((void*)&(p->_fst)) std::shared_ptr (); return o; } static void __pyx_tp_dealloc_9pywrapfst__FstSymbolTableView(PyObject *o) { struct __pyx_obj_9pywrapfst__FstSymbolTableView *p = (struct __pyx_obj_9pywrapfst__FstSymbolTableView *)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_SymbolTableView(o); } static PyMethodDef __pyx_methods_9pywrapfst__FstSymbolTableView[] = { {0, 0, 0, 0} }; static PyTypeObject __pyx_type_9pywrapfst__FstSymbolTableView = { PyVarObject_HEAD_INIT(0, 0) "pywrapfst._FstSymbolTableView", /*tp_name*/ sizeof(struct __pyx_obj_9pywrapfst__FstSymbolTableView), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_9pywrapfst__FstSymbolTableView, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_19_FstSymbolTableView_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_15SymbolTableView_3__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif 0, /*tp_iternext*/ __pyx_methods_9pywrapfst__FstSymbolTableView, /*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_15SymbolTableView_1__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_9pywrapfst__FstSymbolTableView, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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_SymbolTableView(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst_SymbolTableView*)__pyx_vtabptr_9pywrapfst__MutableSymbolTable; return o; } static PyMethodDef __pyx_methods_9pywrapfst__MutableSymbolTable[] = { {"add_symbol", (PyCFunction)(void*)(PyCFunctionWithKeywords)__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}, {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_SymbolTableView, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_15SymbolTableView_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_15SymbolTableView_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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTableView __pyx_vtable_9pywrapfst__MutableFstSymbolTableView; static PyObject *__pyx_tp_new_9pywrapfst__MutableFstSymbolTableView(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *p; PyObject *o = __pyx_tp_new_9pywrapfst__MutableSymbolTable(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *)o); p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst_SymbolTableView*)__pyx_vtabptr_9pywrapfst__MutableFstSymbolTableView; new((void*)&(p->_mfst)) std::shared_ptr (); return o; } static void __pyx_tp_dealloc_9pywrapfst__MutableFstSymbolTableView(PyObject *o) { struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *p = (struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *)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_SymbolTableView(o); } static PyMethodDef __pyx_methods_9pywrapfst__MutableFstSymbolTableView[] = { {0, 0, 0, 0} }; static PyTypeObject __pyx_type_9pywrapfst__MutableFstSymbolTableView = { PyVarObject_HEAD_INIT(0, 0) "pywrapfst._MutableFstSymbolTableView", /*tp_name*/ sizeof(struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_9pywrapfst__MutableFstSymbolTableView, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_26_MutableFstSymbolTableView_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_15SymbolTableView_3__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif 0, /*tp_iternext*/ __pyx_methods_9pywrapfst__MutableFstSymbolTableView, /*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_15SymbolTableView_1__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_9pywrapfst__MutableFstSymbolTableView, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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_SymbolTableView*)__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_SymbolTableView(o); } static PyMethodDef __pyx_methods_9pywrapfst_SymbolTable[] = { {"read", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_5read, METH_O, __pyx_doc_9pywrapfst_11SymbolTable_4read}, {"read_text", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_11SymbolTable_7read_text, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11SymbolTable_6read_text}, {"read_fst", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_11SymbolTable_9read_fst, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11SymbolTable_8read_fst}, {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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_15SymbolTableView_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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; 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); new((void*)&(p->_siter)) std::unique_ptr (); p->_table = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); Py_INCREF(Py_None); 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) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); __Pyx_call_destructor(p->_siter); Py_CLEAR(p->_table); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_9pywrapfst__SymbolTableIterator(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_9pywrapfst__SymbolTableIterator *p = (struct __pyx_obj_9pywrapfst__SymbolTableIterator *)o; if (p->_table) { e = (*v)(((PyObject *)p->_table), a); if (e) return e; } return 0; } static int __pyx_tp_clear_9pywrapfst__SymbolTableIterator(PyObject *o) { PyObject* tmp; struct __pyx_obj_9pywrapfst__SymbolTableIterator *p = (struct __pyx_obj_9pywrapfst__SymbolTableIterator *)o; tmp = ((PyObject*)p->_table); p->_table = ((struct __pyx_obj_9pywrapfst_SymbolTableView *)Py_None); Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_specialmethod___pyx_pw_9pywrapfst_20_SymbolTableIterator_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {return __pyx_pw_9pywrapfst_20_SymbolTableIterator_7__next__(self);} static PyMethodDef __pyx_methods_9pywrapfst__SymbolTableIterator[] = { {"__next__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pywrapfst_20_SymbolTableIterator_7__next__, METH_NOARGS|METH_COEXIST, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_20_SymbolTableIterator_9__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_20_SymbolTableIterator_11__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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_20_SymbolTableIterator_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|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "\n _SymbolTableIterator(symbols)\n\n This class is used for iterating over a symbol table.\n ", /*tp_doc*/ __pyx_tp_traverse_9pywrapfst__SymbolTableIterator, /*tp_traverse*/ __pyx_tp_clear_9pywrapfst__SymbolTableIterator, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ __pyx_pw_9pywrapfst_20_SymbolTableIterator_5__iter__, /*tp_iter*/ __pyx_pw_9pywrapfst_20_SymbolTableIterator_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_20_SymbolTableIterator_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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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->_mapper)) 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->_mapper); (*Py_TYPE(o)->tp_free)(o); } static PyMethodDef __pyx_methods_9pywrapfst_EncodeMapper[] = { {"__reduce__", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_7__reduce__, METH_NOARGS, 0}, {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_9arc_type, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_8arc_type}, {"weight_type", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_11weight_type, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_10weight_type}, {"flags", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_13flags, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_12flags}, {"properties", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_15properties, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_14properties}, {"read", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_17read, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_16read}, {"read_from_string", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_12EncodeMapper_19read_from_string, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_12EncodeMapper_18read_from_string}, {"write", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_21write, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_20write}, {"write_to_string", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_23write_to_string, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_22write_to_string}, {"input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_25input_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_24input_symbols}, {"output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_27output_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_12EncodeMapper_26output_symbols}, {"set_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_29set_input_symbols, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_28set_input_symbols}, {"set_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_31set_output_symbols, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_30set_output_symbols}, {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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_5__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 mapper 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 mapper\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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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_3Fst_1_repr_svg_, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst__repr_svg_}, {"__reduce__", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_5__reduce__, METH_NOARGS, 0}, {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_11arc_type, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_10arc_type}, {"arcs", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_13arcs, METH_O, __pyx_doc_9pywrapfst_3Fst_12arcs}, {"copy", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_15copy, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_14copy}, {"draw", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_3Fst_17draw, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_3Fst_16draw}, {"final", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_19final, METH_O, __pyx_doc_9pywrapfst_3Fst_18final}, {"fst_type", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_21fst_type, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_20fst_type}, {"input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_23input_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_22input_symbols}, {"num_arcs", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_25num_arcs, METH_O, __pyx_doc_9pywrapfst_3Fst_24num_arcs}, {"num_input_epsilons", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_27num_input_epsilons, METH_O, __pyx_doc_9pywrapfst_3Fst_26num_input_epsilons}, {"num_output_epsilons", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_29num_output_epsilons, METH_O, __pyx_doc_9pywrapfst_3Fst_28num_output_epsilons}, {"output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_31output_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_30output_symbols}, {"print", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_3Fst_33print, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_3Fst_32print}, {"properties", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_3Fst_35properties, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_3Fst_34properties}, {"read", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_37read, METH_O, __pyx_doc_9pywrapfst_3Fst_36read}, {"read_from_string", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_39read_from_string, METH_O, __pyx_doc_9pywrapfst_3Fst_38read_from_string}, {"start", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_41start, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_40start}, {"states", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_43states, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_42states}, {"verify", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_45verify, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_44verify}, {"weight_type", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_47weight_type, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_46weight_type}, {"write", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_49write, METH_O, __pyx_doc_9pywrapfst_3Fst_48write}, {"write_to_string", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_51write_to_string, METH_NOARGS, __pyx_doc_9pywrapfst_3Fst_50write_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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_3Fst_7__repr__, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ __pyx_pw_9pywrapfst_3Fst_9__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_3Fst_3__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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_1add_arc, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_add_arc}, {"add_state", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_3add_state, METH_NOARGS, __pyx_doc_9pywrapfst_10MutableFst_2add_state}, {"add_states", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_5add_states, METH_O, __pyx_doc_9pywrapfst_10MutableFst_4add_states}, {"arcsort", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_7arcsort, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_6arcsort}, {"closure", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_9closure, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_8closure}, {"concat", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_11concat, METH_O, __pyx_doc_9pywrapfst_10MutableFst_10concat}, {"connect", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_13connect, METH_NOARGS, __pyx_doc_9pywrapfst_10MutableFst_12connect}, {"decode", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_15decode, METH_O, __pyx_doc_9pywrapfst_10MutableFst_14decode}, {"delete_arcs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_17delete_arcs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_16delete_arcs}, {"delete_states", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_19delete_states, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_18delete_states}, {"encode", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_21encode, METH_O, __pyx_doc_9pywrapfst_10MutableFst_20encode}, {"invert", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_23invert, METH_NOARGS, __pyx_doc_9pywrapfst_10MutableFst_22invert}, {"minimize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_25minimize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_24minimize}, {"mutable_arcs", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_27mutable_arcs, METH_O, __pyx_doc_9pywrapfst_10MutableFst_26mutable_arcs}, {"mutable_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_29mutable_input_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_10MutableFst_28mutable_input_symbols}, {"mutable_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_31mutable_output_symbols, METH_NOARGS, __pyx_doc_9pywrapfst_10MutableFst_30mutable_output_symbols}, {"num_states", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_33num_states, METH_NOARGS, __pyx_doc_9pywrapfst_10MutableFst_32num_states}, {"project", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_35project, METH_O, __pyx_doc_9pywrapfst_10MutableFst_34project}, {"prune", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_37prune, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_36prune}, {"push", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_39push, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_38push}, {"relabel_pairs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_41relabel_pairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_40relabel_pairs}, {"relabel_tables", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_43relabel_tables, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_42relabel_tables}, {"reserve_arcs", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_45reserve_arcs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_44reserve_arcs}, {"reserve_states", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_47reserve_states, METH_O, __pyx_doc_9pywrapfst_10MutableFst_46reserve_states}, {"reweight", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_49reweight, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_48reweight}, {"rmepsilon", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_51rmepsilon, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_50rmepsilon}, {"set_final", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_53set_final, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_52set_final}, {"set_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_55set_input_symbols, METH_O, __pyx_doc_9pywrapfst_10MutableFst_54set_input_symbols}, {"set_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_57set_output_symbols, METH_O, __pyx_doc_9pywrapfst_10MutableFst_56set_output_symbols}, {"set_properties", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_59set_properties, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_58set_properties}, {"set_start", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_61set_start, METH_O, __pyx_doc_9pywrapfst_10MutableFst_60set_start}, {"topsort", (PyCFunction)__pyx_pw_9pywrapfst_10MutableFst_63topsort, METH_NOARGS, __pyx_doc_9pywrapfst_10MutableFst_62topsort}, {"union", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_10MutableFst_65union, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10MutableFst_64union}, {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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_3Fst_7__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_3Fst_9__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_3Fst_3__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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_9pywrapfst_VectorFst __pyx_vtable_9pywrapfst_VectorFst; static PyObject *__pyx_tp_new_9pywrapfst_VectorFst(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_9pywrapfst_VectorFst *p; PyObject *o = __pyx_tp_new_9pywrapfst_MutableFst(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_9pywrapfst_VectorFst *)o); p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst_Fst*)__pyx_vtabptr_9pywrapfst_VectorFst; return o; } static PyMethodDef __pyx_methods_9pywrapfst_VectorFst[] = { {0, 0, 0, 0} }; static PyTypeObject __pyx_type_9pywrapfst_VectorFst = { PyVarObject_HEAD_INIT(0, 0) "pywrapfst.VectorFst", /*tp_name*/ sizeof(struct __pyx_obj_9pywrapfst_VectorFst), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_9pywrapfst_MutableFst, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_3Fst_7__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_3Fst_9__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 VectorFst(arc_type=\"standard\")\n\n Constructs a concrete, empty, mutable FST.\n\n Args:\n arc_type: A string indicating the arc type.\n\n Raises:\n FstOpError: Unknown arc 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_VectorFst, /*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_9VectorFst_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_9pywrapfst_VectorFst, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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 PyObject *__pyx_specialmethod___pyx_pw_9pywrapfst_11ArcIterator_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {return __pyx_pw_9pywrapfst_11ArcIterator_7__next__(self);} static PyMethodDef __pyx_methods_9pywrapfst_ArcIterator[] = { {"__next__", (PyCFunction)__pyx_specialmethod___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)(void*)(PyCFunctionWithKeywords)__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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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_8done, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_7done}, {"flags", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_10flags, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_9flags}, {"next", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_12next, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_11next}, {"position", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_14position, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_13position}, {"reset", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_16reset, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_15reset}, {"seek", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_18seek, METH_O, __pyx_doc_9pywrapfst_18MutableArcIterator_17seek}, {"set_flags", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_18MutableArcIterator_20set_flags, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_18MutableArcIterator_19set_flags}, {"set_value", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_22set_value, METH_O, __pyx_doc_9pywrapfst_18MutableArcIterator_21set_value}, {"value", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_24value, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_23value}, {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_26__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_28__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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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*/ __pyx_pw_9pywrapfst_18MutableArcIterator_5__iter__, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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 PyObject *__pyx_specialmethod___pyx_pw_9pywrapfst_13StateIterator_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {return __pyx_pw_9pywrapfst_13StateIterator_7__next__(self);} static PyMethodDef __pyx_methods_9pywrapfst_StateIterator[] = { {"__next__", (PyCFunction)__pyx_specialmethod___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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_symbols, osymbols=ascii_symbols)\n\n Once constructed, Compiler instances behave like a file handle opened for\n writing:\n\n # /ba+/\n compiler.write(\"0 1 50 50\")\n compiler.write(\"1 2 49 49\")\n compiler.write(\"2 2 49 49\")\n compiler.write(\"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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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 PyObject *__pyx_specialmethod___pyx_pw_9pywrapfst_9FarReader_27__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {return __pyx_pw_9pywrapfst_9FarReader_27__next__(self);} static PyMethodDef __pyx_methods_9pywrapfst_FarReader[] = { {"open", (PyCFunction)(void*)(PyCFunctionWithKeywords)__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}, {"__next__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pywrapfst_9FarReader_27__next__, METH_NOARGS|METH_COEXIST, 0}, {"__reduce_cython__", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_31__reduce_cython__, METH_NOARGS, 0}, {"__setstate_cython__", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_33__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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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*/ __pyx_pw_9pywrapfst_9FarReader_29__iter__, /*tp_iter*/ __pyx_pw_9pywrapfst_9FarReader_27__next__, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #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)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_9FarWriter_5create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_9FarWriter_4create}, {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__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*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *__pyx_freelist_9pywrapfst___pyx_scope_struct____iter__[8]; static int __pyx_freecount_9pywrapfst___pyx_scope_struct____iter__ = 0; static PyObject *__pyx_tp_new_9pywrapfst___pyx_scope_struct____iter__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_9pywrapfst___pyx_scope_struct____iter__ > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__)))) { o = (PyObject*)__pyx_freelist_9pywrapfst___pyx_scope_struct____iter__[--__pyx_freecount_9pywrapfst___pyx_scope_struct____iter__]; memset(o, 0, sizeof(struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_9pywrapfst___pyx_scope_struct____iter__(PyObject *o) { struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *p = (struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_self); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_9pywrapfst___pyx_scope_struct____iter__ < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__)))) { __pyx_freelist_9pywrapfst___pyx_scope_struct____iter__[__pyx_freecount_9pywrapfst___pyx_scope_struct____iter__++] = ((struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_9pywrapfst___pyx_scope_struct____iter__(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *p = (struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__ *)o; if (p->__pyx_v_self) { e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_9pywrapfst___pyx_scope_struct____iter__ = { PyVarObject_HEAD_INIT(0, 0) "pywrapfst.__pyx_scope_struct____iter__", /*tp_name*/ sizeof(struct __pyx_obj_9pywrapfst___pyx_scope_struct____iter__), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_9pywrapfst___pyx_scope_struct____iter__, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 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_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_9pywrapfst___pyx_scope_struct____iter__, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*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___pyx_scope_struct____iter__, /*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 #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static PyMethodDef __pyx_methods[] = { {"_read_SymbolTable_from_string", (PyCFunction)__pyx_pw_9pywrapfst_9_read_SymbolTable_from_string, METH_O, 0}, {"compact_symbol_table", (PyCFunction)__pyx_pw_9pywrapfst_11compact_symbol_table, METH_O, __pyx_doc_9pywrapfst_10compact_symbol_table}, {"merge_symbol_table", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_13merge_symbol_table, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_12merge_symbol_table}, {"_read_EncodeMapper_from_string", (PyCFunction)__pyx_pw_9pywrapfst_15_read_EncodeMapper_from_string, METH_O, 0}, {"_read_Fst", (PyCFunction)__pyx_pw_9pywrapfst_17_read_Fst, METH_O, 0}, {"_read_Fst_from_string", (PyCFunction)__pyx_pw_9pywrapfst_19_read_Fst_from_string, METH_O, 0}, {"arcmap", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_21arcmap, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_20arcmap}, {"compose", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_23compose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_22compose}, {"convert", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_25convert, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_24convert}, {"determinize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_27determinize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_26determinize}, {"difference", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_29difference, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_28difference}, {"disambiguate", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_31disambiguate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_30disambiguate}, {"epsnormalize", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_33epsnormalize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_32epsnormalize}, {"equal", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_35equal, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_34equal}, {"equivalent", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_37equivalent, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_36equivalent}, {"intersect", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_39intersect, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_38intersect}, {"isomorphic", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_41isomorphic, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_40isomorphic}, {"prune", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_43prune, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_42prune}, {"push", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_45push, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_44push}, {"randequivalent", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_47randequivalent, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_46randequivalent}, {"randgen", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_49randgen, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_48randgen}, {"replace", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_51replace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_50replace}, {"reverse", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_53reverse, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_52reverse}, {"shortestpath", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_57shortestpath, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_56shortestpath}, {"statemap", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_9pywrapfst_59statemap, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_58statemap}, {"synchronize", (PyCFunction)__pyx_pw_9pywrapfst_61synchronize, METH_O, __pyx_doc_9pywrapfst_60synchronize}, {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 #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, {&__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_n_s_Arc, __pyx_k_Arc, sizeof(__pyx_k_Arc), 0, 0, 1, 1}, {&__pyx_n_s_ArcIterator, __pyx_k_ArcIterator, sizeof(__pyx_k_ArcIterator), 0, 0, 1, 1}, {&__pyx_kp_u_ArcIterator_at_0x, __pyx_k_ArcIterator_at_0x, sizeof(__pyx_k_ArcIterator_at_0x), 0, 1, 0, 0}, {&__pyx_n_s_ArcMapType, __pyx_k_ArcMapType, sizeof(__pyx_k_ArcMapType), 0, 0, 1, 1}, {&__pyx_kp_u_Arc_at_0x, __pyx_k_Arc_at_0x, sizeof(__pyx_k_Arc_at_0x), 0, 1, 0, 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_kp_u_Cannot_construct, __pyx_k_Cannot_construct, sizeof(__pyx_k_Cannot_construct), 0, 1, 0, 0}, {&__pyx_kp_u_Cannot_topsort_cyclic_FST, __pyx_k_Cannot_topsort_cyclic_FST, sizeof(__pyx_k_Cannot_topsort_cyclic_FST), 0, 1, 0, 0}, {&__pyx_kp_u_Compilation_failed, __pyx_k_Compilation_failed, sizeof(__pyx_k_Compilation_failed), 0, 1, 0, 0}, {&__pyx_n_s_Compiler, __pyx_k_Compiler, sizeof(__pyx_k_Compiler), 0, 0, 1, 1}, {&__pyx_n_s_ComposeFilter, __pyx_k_ComposeFilter, sizeof(__pyx_k_ComposeFilter), 0, 0, 1, 1}, {&__pyx_kp_u_Conversion_to, __pyx_k_Conversion_to, sizeof(__pyx_k_Conversion_to), 0, 1, 0, 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_DeterminizeType, __pyx_k_DeterminizeType, sizeof(__pyx_k_DeterminizeType), 0, 0, 1, 1}, {&__pyx_kp_u_Dot_rendering_failed_s, __pyx_k_Dot_rendering_failed_s, sizeof(__pyx_k_Dot_rendering_failed_s), 0, 1, 0, 0}, {&__pyx_n_s_DrawFloatFormat, __pyx_k_DrawFloatFormat, sizeof(__pyx_k_DrawFloatFormat), 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_n_s_EncodeMapper, __pyx_k_EncodeMapper, sizeof(__pyx_k_EncodeMapper), 0, 0, 1, 1}, {&__pyx_n_s_EncodeMapperSymbolTableView, __pyx_k_EncodeMapperSymbolTableView, sizeof(__pyx_k_EncodeMapperSymbolTableView), 0, 0, 1, 1}, {&__pyx_kp_u_EncodeMapper_at_0x, __pyx_k_EncodeMapper_at_0x, sizeof(__pyx_k_EncodeMapper_at_0x), 0, 1, 0, 0}, {&__pyx_kp_u_Expected, __pyx_k_Expected, sizeof(__pyx_k_Expected), 0, 1, 0, 0}, {&__pyx_n_s_FST_PROPERTIES, __pyx_k_FST_PROPERTIES, sizeof(__pyx_k_FST_PROPERTIES), 0, 0, 1, 1}, {&__pyx_n_s_FarReader, __pyx_k_FarReader, sizeof(__pyx_k_FarReader), 0, 0, 1, 1}, {&__pyx_kp_u_FarReader_at_0x, __pyx_k_FarReader_at_0x, sizeof(__pyx_k_FarReader_at_0x), 0, 1, 0, 0}, {&__pyx_n_s_FarType, __pyx_k_FarType, sizeof(__pyx_k_FarType), 0, 0, 1, 1}, {&__pyx_n_s_FarWriter, __pyx_k_FarWriter, sizeof(__pyx_k_FarWriter), 0, 0, 1, 1}, {&__pyx_kp_u_FarWriter_at_0x, __pyx_k_FarWriter_at_0x, sizeof(__pyx_k_FarWriter_at_0x), 0, 1, 0, 0}, {&__pyx_n_s_Flag, __pyx_k_Flag, sizeof(__pyx_k_Flag), 0, 0, 1, 1}, {&__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_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_n_s_FstProperties, __pyx_k_FstProperties, sizeof(__pyx_k_FstProperties), 0, 0, 1, 1}, {&__pyx_n_s_FstSymbolTableView, __pyx_k_FstSymbolTableView, sizeof(__pyx_k_FstSymbolTableView), 0, 0, 1, 1}, {&__pyx_kp_u_Fst_SymbolTableView, __pyx_k_Fst_SymbolTableView, sizeof(__pyx_k_Fst_SymbolTableView), 0, 1, 0, 0}, {&__pyx_kp_u_Fst_at_0x, __pyx_k_Fst_at_0x, sizeof(__pyx_k_Fst_at_0x), 0, 1, 0, 0}, {&__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_u_Incompatible_or_invalid_arc_type, __pyx_k_Incompatible_or_invalid_arc_type, sizeof(__pyx_k_Incompatible_or_invalid_arc_type), 0, 1, 0, 0}, {&__pyx_kp_u_Incompatible_or_invalid_weight, __pyx_k_Incompatible_or_invalid_weight, sizeof(__pyx_k_Incompatible_or_invalid_weight), 0, 1, 0, 0}, {&__pyx_kp_u_Incompatible_or_invalid_weight_t, __pyx_k_Incompatible_or_invalid_weight_t, sizeof(__pyx_k_Incompatible_or_invalid_weight_t), 0, 1, 0, 0}, {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, {&__pyx_kp_u_Invalid_weight, __pyx_k_Invalid_weight, sizeof(__pyx_k_Invalid_weight), 0, 1, 0, 0}, {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1}, {&__pyx_n_s_MUTABLE, __pyx_k_MUTABLE, sizeof(__pyx_k_MUTABLE), 0, 0, 1, 1}, {&__pyx_n_s_MutableArcIterator, __pyx_k_MutableArcIterator, sizeof(__pyx_k_MutableArcIterator), 0, 0, 1, 1}, {&__pyx_n_s_MutableArcIterator___iter, __pyx_k_MutableArcIterator___iter, sizeof(__pyx_k_MutableArcIterator___iter), 0, 0, 1, 1}, {&__pyx_kp_u_MutableArcIterator_at_0x, __pyx_k_MutableArcIterator_at_0x, sizeof(__pyx_k_MutableArcIterator_at_0x), 0, 1, 0, 0}, {&__pyx_n_s_MutableFst, __pyx_k_MutableFst, sizeof(__pyx_k_MutableFst), 0, 0, 1, 1}, {&__pyx_n_s_MutableFstSymbolTableView, __pyx_k_MutableFstSymbolTableView, sizeof(__pyx_k_MutableFstSymbolTableView), 0, 0, 1, 1}, {&__pyx_n_s_MutableSymbolTable, __pyx_k_MutableSymbolTable, sizeof(__pyx_k_MutableSymbolTable), 0, 0, 1, 1}, {&__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_kp_u_No_new_SymbolTables_specified, __pyx_k_No_new_SymbolTables_specified, sizeof(__pyx_k_No_new_SymbolTables_specified), 0, 1, 0, 0}, {&__pyx_kp_u_No_relabeling_pairs_specified, __pyx_k_No_relabeling_pairs_specified, sizeof(__pyx_k_No_relabeling_pairs_specified), 0, 1, 0, 0}, {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, {&__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_kp_u_Open_failed, __pyx_k_Open_failed, sizeof(__pyx_k_Open_failed), 0, 1, 0, 0}, {&__pyx_kp_u_Operation_failed, __pyx_k_Operation_failed, sizeof(__pyx_k_Operation_failed), 0, 1, 0, 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_ProjectType, __pyx_k_ProjectType, sizeof(__pyx_k_ProjectType), 0, 0, 1, 1}, {&__pyx_n_s_QueueType, __pyx_k_QueueType, sizeof(__pyx_k_QueueType), 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_n_s_RandArcSelection, __pyx_k_RandArcSelection, sizeof(__pyx_k_RandArcSelection), 0, 0, 1, 1}, {&__pyx_kp_u_Read_failed, __pyx_k_Read_failed, sizeof(__pyx_k_Read_failed), 0, 1, 0, 0}, {&__pyx_kp_u_Read_from_FST_failed, __pyx_k_Read_from_FST_failed, sizeof(__pyx_k_Read_from_FST_failed), 0, 1, 0, 0}, {&__pyx_kp_u_Read_from_string_failed, __pyx_k_Read_from_string_failed, sizeof(__pyx_k_Read_from_string_failed), 0, 1, 0, 0}, {&__pyx_n_s_ReplaceLabelType, __pyx_k_ReplaceLabelType, sizeof(__pyx_k_ReplaceLabelType), 0, 0, 1, 1}, {&__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_n_s_SortType, __pyx_k_SortType, sizeof(__pyx_k_SortType), 0, 0, 1, 1}, {&__pyx_n_s_StateIterator, __pyx_k_StateIterator, sizeof(__pyx_k_StateIterator), 0, 0, 1, 1}, {&__pyx_kp_u_StateIterator_at_0x, __pyx_k_StateIterator_at_0x, sizeof(__pyx_k_StateIterator_at_0x), 0, 1, 0, 0}, {&__pyx_n_s_StateMapType, __pyx_k_StateMapType, sizeof(__pyx_k_StateMapType), 0, 0, 1, 1}, {&__pyx_kp_u_State_index_out_of_range, __pyx_k_State_index_out_of_range, sizeof(__pyx_k_State_index_out_of_range), 0, 1, 0, 0}, {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1}, {&__pyx_kp_u_SymbolTable, __pyx_k_SymbolTable, sizeof(__pyx_k_SymbolTable), 0, 1, 0, 0}, {&__pyx_n_s_SymbolTableIterator, __pyx_k_SymbolTableIterator, sizeof(__pyx_k_SymbolTableIterator), 0, 0, 1, 1}, {&__pyx_kp_u_SymbolTableIterator_at_0x, __pyx_k_SymbolTableIterator_at_0x, sizeof(__pyx_k_SymbolTableIterator_at_0x), 0, 1, 0, 0}, {&__pyx_n_s_SymbolTableView, __pyx_k_SymbolTableView, sizeof(__pyx_k_SymbolTableView), 0, 0, 1, 1}, {&__pyx_n_s_SymbolTable_2, __pyx_k_SymbolTable_2, sizeof(__pyx_k_SymbolTable_2), 0, 0, 1, 1}, {&__pyx_kp_u_SymbolTable_no_longer_exists, __pyx_k_SymbolTable_no_longer_exists, sizeof(__pyx_k_SymbolTable_no_longer_exists), 0, 1, 0, 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_u_Tsvg, __pyx_k_Tsvg, sizeof(__pyx_k_Tsvg), 0, 1, 0, 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_u_Unknown_FAR_type, __pyx_k_Unknown_FAR_type, sizeof(__pyx_k_Unknown_FAR_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_arc_type, __pyx_k_Unknown_arc_type, sizeof(__pyx_k_Unknown_arc_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_compose_filter_type, __pyx_k_Unknown_compose_filter_type, sizeof(__pyx_k_Unknown_compose_filter_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_determinization_type, __pyx_k_Unknown_determinization_type, sizeof(__pyx_k_Unknown_determinization_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_map_type, __pyx_k_Unknown_map_type, sizeof(__pyx_k_Unknown_map_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_projection_type, __pyx_k_Unknown_projection_type, sizeof(__pyx_k_Unknown_projection_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_queue_type, __pyx_k_Unknown_queue_type, sizeof(__pyx_k_Unknown_queue_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_random_arc_selection_typ, __pyx_k_Unknown_random_arc_selection_typ, sizeof(__pyx_k_Unknown_random_arc_selection_typ), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_replace_label_type, __pyx_k_Unknown_replace_label_type, sizeof(__pyx_k_Unknown_replace_label_type), 0, 1, 0, 0}, {&__pyx_kp_u_Unknown_sort_type, __pyx_k_Unknown_sort_type, sizeof(__pyx_k_Unknown_sort_type), 0, 1, 0, 0}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_VectorFst, __pyx_k_VectorFst, sizeof(__pyx_k_VectorFst), 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_u_Weight, __pyx_k_Weight, sizeof(__pyx_k_Weight), 0, 1, 0, 0}, {&__pyx_n_s_WeightLike, __pyx_k_WeightLike, sizeof(__pyx_k_WeightLike), 0, 0, 1, 1}, {&__pyx_n_s_Weight_2, __pyx_k_Weight_2, sizeof(__pyx_k_Weight_2), 0, 0, 1, 1}, {&__pyx_kp_u_Weight_type_not_found, __pyx_k_Weight_type_not_found, sizeof(__pyx_k_Weight_type_not_found), 0, 1, 0, 0}, {&__pyx_kp_u_Write_failed, __pyx_k_Write_failed, sizeof(__pyx_k_Write_failed), 0, 1, 0, 0}, {&__pyx_kp_u_Write_to_string_failed, __pyx_k_Write_to_string_failed, sizeof(__pyx_k_Write_to_string_failed), 0, 1, 0, 0}, {&__pyx_kp_u__11, __pyx_k__11, sizeof(__pyx_k__11), 0, 1, 0, 0}, {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, {&__pyx_kp_u__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 1, 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_states, __pyx_k_add_states, sizeof(__pyx_k_add_states), 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_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_kp_u_at_0x, __pyx_k_at_0x, sizeof(__pyx_k_at_0x), 0, 1, 0, 0}, {&__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_u_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 1, 0, 1}, {&__pyx_n_s_available_key, __pyx_k_available_key, sizeof(__pyx_k_available_key), 0, 0, 1, 1}, {&__pyx_kp_u_but_received, __pyx_k_but_received, sizeof(__pyx_k_but_received), 0, 1, 0, 0}, {&__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_class_2, __pyx_k_class_2, sizeof(__pyx_k_class_2), 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_close, __pyx_k_close, sizeof(__pyx_k_close), 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_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_u_const_EncodeMapper_SymbolTableV, __pyx_k_const_EncodeMapper_SymbolTableV, sizeof(__pyx_k_const_EncodeMapper_SymbolTableV), 0, 1, 0, 0}, {&__pyx_kp_u_const_Fst_SymbolTableView, __pyx_k_const_Fst_SymbolTableView, sizeof(__pyx_k_const_Fst_SymbolTableView), 0, 1, 0, 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_u_default, __pyx_k_default, sizeof(__pyx_k_default), 0, 1, 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_u_dot, __pyx_k_dot, sizeof(__pyx_k_dot), 0, 1, 0, 1}, {&__pyx_n_s_draw, __pyx_k_draw, sizeof(__pyx_k_draw), 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_enum, __pyx_k_enum, sizeof(__pyx_k_enum), 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_kp_u_failed, __pyx_k_failed, sizeof(__pyx_k_failed), 0, 1, 0, 0}, {&__pyx_n_s_far_type, __pyx_k_far_type, sizeof(__pyx_k_far_type), 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_fspath, __pyx_k_fspath, sizeof(__pyx_k_fspath), 0, 0, 1, 1}, {&__pyx_n_s_fst_type, __pyx_k_fst_type, sizeof(__pyx_k_fst_type), 0, 0, 1, 1}, {&__pyx_n_u_functional, __pyx_k_functional, sizeof(__pyx_k_functional), 0, 1, 0, 1}, {&__pyx_n_u_g, __pyx_k_g, sizeof(__pyx_k_g), 0, 1, 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_u_identity, __pyx_k_identity, sizeof(__pyx_k_identity), 0, 1, 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_s_ilabel, __pyx_k_ilabel, sizeof(__pyx_k_ilabel), 0, 0, 1, 1}, {&__pyx_n_u_ilabel, __pyx_k_ilabel, sizeof(__pyx_k_ilabel), 0, 1, 0, 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_u_input, __pyx_k_input, sizeof(__pyx_k_input), 0, 1, 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_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, {&__pyx_n_s_iter, __pyx_k_iter, sizeof(__pyx_k_iter), 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_members, __pyx_k_members, sizeof(__pyx_k_members), 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_u_neither, __pyx_k_neither, sizeof(__pyx_k_neither), 0, 1, 0, 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_no_weight, __pyx_k_no_weight, sizeof(__pyx_k_no_weight), 0, 0, 1, 1}, {&__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_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_one, __pyx_k_one, sizeof(__pyx_k_one), 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_os, __pyx_k_os, sizeof(__pyx_k_os), 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_print, __pyx_k_print, sizeof(__pyx_k_print), 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_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_EncodeMapper_from_string, __pyx_k_read_EncodeMapper_from_string, sizeof(__pyx_k_read_EncodeMapper_from_string), 0, 0, 1, 1}, {&__pyx_n_s_read_Fst_from_string, __pyx_k_read_Fst_from_string, sizeof(__pyx_k_read_Fst_from_string), 0, 0, 1, 1}, {&__pyx_n_s_read_SymbolTable_from_string, __pyx_k_read_SymbolTable_from_string, sizeof(__pyx_k_read_SymbolTable_from_string), 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_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_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_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_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_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__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__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_cannot_be_converted, __pyx_k_self__siter_cannot_be_converted, sizeof(__pyx_k_self__siter_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_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, {&__pyx_n_s_set_flags, __pyx_k_set_flags, sizeof(__pyx_k_set_flags), 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_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_source, __pyx_k_source, sizeof(__pyx_k_source), 0, 0, 1, 1}, {&__pyx_n_s_ssymbols, __pyx_k_ssymbols, sizeof(__pyx_k_ssymbols), 0, 0, 1, 1}, {&__pyx_n_u_standard, __pyx_k_standard, sizeof(__pyx_k_standard), 0, 1, 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_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_symbols, __pyx_k_symbols, sizeof(__pyx_k_symbols), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 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_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 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_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1}, {&__pyx_n_s_typing, __pyx_k_typing, sizeof(__pyx_k_typing), 0, 0, 1, 1}, {&__pyx_kp_u_typing_Literal_alt_sequence_auto, __pyx_k_typing_Literal_alt_sequence_auto, sizeof(__pyx_k_typing_Literal_alt_sequence_auto), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_arc_sum_arc_uniqu, __pyx_k_typing_Literal_arc_sum_arc_uniqu, sizeof(__pyx_k_typing_Literal_arc_sum_arc_uniqu), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_auto_fifo_lifo_sh, __pyx_k_typing_Literal_auto_fifo_lifo_sh, sizeof(__pyx_k_typing_Literal_auto_fifo_lifo_sh), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_e_f_g, __pyx_k_typing_Literal_e_f_g, sizeof(__pyx_k_typing_Literal_e_f_g), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_fst_stlist_sttabl, __pyx_k_typing_Literal_fst_stlist_sttabl, sizeof(__pyx_k_typing_Literal_fst_stlist_sttabl), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_functional_nonfun, __pyx_k_typing_Literal_functional_nonfun, sizeof(__pyx_k_typing_Literal_functional_nonfun), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_identity_input_ep, __pyx_k_typing_Literal_identity_input_ep, sizeof(__pyx_k_typing_Literal_identity_input_ep), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_ilabel_olabel, __pyx_k_typing_Literal_ilabel_olabel, sizeof(__pyx_k_typing_Literal_ilabel_olabel), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_input_output, __pyx_k_typing_Literal_input_output, sizeof(__pyx_k_typing_Literal_input_output), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_neither_input_out, __pyx_k_typing_Literal_neither_input_out, sizeof(__pyx_k_typing_Literal_neither_input_out), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Literal_uniform_log_prob, __pyx_k_typing_Literal_uniform_log_prob, sizeof(__pyx_k_typing_Literal_uniform_log_prob), 0, 1, 0, 0}, {&__pyx_kp_u_typing_Union_Weight_typing_Union, __pyx_k_typing_Union_Weight_typing_Union, sizeof(__pyx_k_typing_Union_Weight_typing_Union), 0, 1, 0, 0}, {&__pyx_n_u_uniform, __pyx_k_uniform, sizeof(__pyx_k_uniform), 0, 1, 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_u_unspecified, __pyx_k_unspecified, sizeof(__pyx_k_unspecified), 0, 1, 0, 0}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_n_u_vector, __pyx_k_vector, sizeof(__pyx_k_vector), 0, 1, 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_2, __pyx_k_weight_2, sizeof(__pyx_k_weight_2), 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_s_write_to_string, __pyx_k_write_to_string, sizeof(__pyx_k_write_to_string), 0, 0, 1, 1}, {&__pyx_n_u_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 1, 0, 1}, {&__pyx_n_s_zero, __pyx_k_zero, sizeof(__pyx_k_zero), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 147, __pyx_L1_error) __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(0, 157, __pyx_L1_error) __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) __PYX_ERR(0, 162, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 167, __pyx_L1_error) __pyx_builtin_staticmethod = __Pyx_GetBuiltinName(__pyx_n_s_staticmethod); if (!__pyx_builtin_staticmethod) __PYX_ERR(0, 1420, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 196, __pyx_L1_error) __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(0, 425, __pyx_L1_error) __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 746, __pyx_L1_error) __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) __PYX_ERR(0, 1286, __pyx_L1_error) __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 4557, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 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_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_self__weight_cannot_be_converted); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "(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__5 = PyTuple_Pack(1, __pyx_kp_s_self__weight_cannot_be_converted); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self._siter cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._siter cannot be converted to a Python object for pickling") */ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_self__siter_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._siter cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self._siter cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_self__siter_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); /* "pywrapfst.pyx":1578 * @staticmethod * cdef string _local_render_svg(const string &dot): * proc = subprocess.Popen(("dot", "-Tsvg"), # <<<<<<<<<<<<<< * stdin=subprocess.PIPE, * stdout=subprocess.PIPE) */ __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_u_dot, __pyx_kp_u_Tsvg); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); __pyx_tuple__10 = PyTuple_Pack(1, __pyx_tuple__9); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "(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__24 = PyTuple_Pack(1, __pyx_kp_s_self__arc_cannot_be_converted_to); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "(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__25 = PyTuple_Pack(1, __pyx_kp_s_self__arc_cannot_be_converted_to); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "(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__26 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__fst_cannot_be); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); /* "(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__27 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__fst_cannot_be); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); /* "(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__28 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__mfst_cannot_be); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); /* "(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__29 = PyTuple_Pack(1, __pyx_kp_s_self__aiter_self__mfst_cannot_be); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); /* "(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__30 = PyTuple_Pack(1, __pyx_kp_s_self__fst_self__siter_cannot_be); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); /* "(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__31 = PyTuple_Pack(1, __pyx_kp_s_self__fst_self__siter_cannot_be); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); /* "(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__53 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); /* "(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__54 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__54); __Pyx_GIVEREF(__pyx_tuple__54); /* "(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__55 = PyTuple_Pack(1, __pyx_kp_s_self__reader_cannot_be_converted); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(1, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); /* "(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__56 = PyTuple_Pack(1, __pyx_kp_s_self__reader_cannot_be_converted); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); /* "(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__57 = PyTuple_Pack(1, __pyx_kp_s_self__writer_cannot_be_converted); 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._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__58 = PyTuple_Pack(1, __pyx_kp_s_self__writer_cannot_be_converted); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); /* "pywrapfst.pyx":514 * * * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * """ * plus(lhs, rhs) */ __pyx_tuple__59 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_weight_2); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_plus, 514, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(0, 514, __pyx_L1_error) /* "pywrapfst.pyx":546 * * * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * """ * times(lhs, rhs) */ __pyx_tuple__61 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_weight_2); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__61, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_times, 546, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(0, 546, __pyx_L1_error) /* "pywrapfst.pyx":578 * * * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * """ * divide(lhs, rhs) */ __pyx_tuple__63 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_weight_2); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); __pyx_codeobj__64 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_divide, 578, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__64)) __PYX_ERR(0, 578, __pyx_L1_error) /* "pywrapfst.pyx":611 * * * def power(Weight w, size_t n): # <<<<<<<<<<<<<< * """ * power(lhs, rhs) */ __pyx_tuple__65 = PyTuple_Pack(3, __pyx_n_s_w, __pyx_n_s_n, __pyx_n_s_weight_2); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); __pyx_codeobj__66 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_power, 611, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__66)) __PYX_ERR(0, 611, __pyx_L1_error) /* "pywrapfst.pyx":1421 * * @staticmethod * def read_from_string(state): # <<<<<<<<<<<<<< * """ * read_from_string(state) */ __pyx_tuple__67 = PyTuple_Pack(1, __pyx_n_s_state); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 1421, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); __pyx_codeobj__68 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_read_from_string, 1421, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__68)) __PYX_ERR(0, 1421, __pyx_L1_error) /* "pywrapfst.pyx":4135 * * * def shortestdistance(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * int64 nstate=fst.kNoStateId, */ __pyx_tuple__69 = PyTuple_Pack(7, __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); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 4135, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); __pyx_codeobj__70 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__69, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_pywrapfst_pyx, __pyx_n_s_shortestdistance, 4135, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__70)) __PYX_ERR(0, 4135, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ if (__Pyx_ExportFunction("tostring", (void (*)(void))__pyx_f_9pywrapfst_tostring, "std::string (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("weight_tostring", (void (*)(void))__pyx_f_9pywrapfst_weight_tostring, "std::string (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("path_tostring", (void (*)(void))__pyx_f_9pywrapfst_path_tostring, "std::string (PyObject *)") < 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("_no_weight", (void (*)(void))__pyx_f_9pywrapfst__no_weight, "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_EncodeMapperSymbolTableView", (void (*)(void))__pyx_f_9pywrapfst__init_EncodeMapperSymbolTableView, "struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *(std::shared_ptr , bool)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("_init_FstSymbolTableView", (void (*)(void))__pyx_f_9pywrapfst__init_FstSymbolTableView, "struct __pyx_obj_9pywrapfst__FstSymbolTableView *(std::shared_ptr , bool)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("_init_MutableFstSymbolTableView", (void (*)(void))__pyx_f_9pywrapfst__init_MutableFstSymbolTableView, "struct __pyx_obj_9pywrapfst__MutableFstSymbolTableView *(std::shared_ptr , bool)") < 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 *(std::unique_ptr )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("_read_SymbolTable_from_string", (void (*)(void))__pyx_f_9pywrapfst__read_SymbolTable_from_string, "struct __pyx_obj_9pywrapfst_SymbolTable *(std::string, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("_init_EncodeMapper", (void (*)(void))__pyx_f_9pywrapfst__init_EncodeMapper, "struct __pyx_obj_9pywrapfst_EncodeMapper *(__pyx_t_9pywrapfst_EncodeMapperClass_ptr)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("_read_EncodeMapper_from_string", (void (*)(void))__pyx_f_9pywrapfst__read_EncodeMapper_from_string, "struct __pyx_obj_9pywrapfst_EncodeMapper *(std::string, int __pyx_skip_dispatch)") < 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("_read_Fst", (void (*)(void))__pyx_f_9pywrapfst__read_Fst, "struct __pyx_obj_9pywrapfst_Fst *(PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (__Pyx_ExportFunction("_read_Fst_from_string", (void (*)(void))__pyx_f_9pywrapfst__read_Fst_from_string, "struct __pyx_obj_9pywrapfst_Fst *(std::string, 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, "void (struct __pyx_obj_9pywrapfst_Fst *, std::vector *, 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) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- 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; __pyx_vtable_9pywrapfst_Weight.member = (bool (*)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_6Weight_member; if (PyType_Ready(&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 404, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_Weight.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_Weight.tp_dictoffset && __pyx_type_9pywrapfst_Weight.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_Weight.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Weight.tp_dict, __pyx_vtabptr_9pywrapfst_Weight) < 0) __PYX_ERR(0, 404, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Weight_2, (PyObject *)&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 404, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 404, __pyx_L1_error) __pyx_ptype_9pywrapfst_Weight = &__pyx_type_9pywrapfst_Weight; __pyx_vtabptr_9pywrapfst_SymbolTableView = &__pyx_vtable_9pywrapfst_SymbolTableView; __pyx_vtable_9pywrapfst_SymbolTableView._raw = (fst::SymbolTable const *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_15SymbolTableView__raw; __pyx_vtable_9pywrapfst_SymbolTableView._raise_nonexistent = (void (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_15SymbolTableView__raise_nonexistent; __pyx_vtable_9pywrapfst_SymbolTableView._raw_ptr_or_raise = (fst::SymbolTable const *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_15SymbolTableView__raw_ptr_or_raise; __pyx_vtable_9pywrapfst_SymbolTableView.available_key = (int64 (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_available_key; __pyx_vtable_9pywrapfst_SymbolTableView.checksum = (PyObject *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_checksum; __pyx_vtable_9pywrapfst_SymbolTableView.copy = (struct __pyx_obj_9pywrapfst_SymbolTable *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_copy; __pyx_vtable_9pywrapfst_SymbolTableView.get_nth_key = (int64 (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, Py_ssize_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_get_nth_key; __pyx_vtable_9pywrapfst_SymbolTableView.labeled_checksum = (PyObject *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_labeled_checksum; __pyx_vtable_9pywrapfst_SymbolTableView.member = (bool (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_member; __pyx_vtable_9pywrapfst_SymbolTableView.name = (std::string (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_name; __pyx_vtable_9pywrapfst_SymbolTableView.num_symbols = (size_t (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_num_symbols; __pyx_vtable_9pywrapfst_SymbolTableView.write = (void (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_write; __pyx_vtable_9pywrapfst_SymbolTableView.write_text = (void (*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_write_text; __pyx_vtable_9pywrapfst_SymbolTableView.write_to_string = (PyObject *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_15SymbolTableView_write_to_string; if (PyType_Ready(&__pyx_type_9pywrapfst_SymbolTableView) < 0) __PYX_ERR(0, 731, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_SymbolTableView.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_SymbolTableView.tp_dictoffset && __pyx_type_9pywrapfst_SymbolTableView.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_SymbolTableView.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_SymbolTableView.tp_dict, __pyx_vtabptr_9pywrapfst_SymbolTableView) < 0) __PYX_ERR(0, 731, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SymbolTableView, (PyObject *)&__pyx_type_9pywrapfst_SymbolTableView) < 0) __PYX_ERR(0, 731, __pyx_L1_error) __pyx_ptype_9pywrapfst_SymbolTableView = &__pyx_type_9pywrapfst_SymbolTableView; __pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTableView = &__pyx_vtable_9pywrapfst__EncodeMapperSymbolTableView; __pyx_vtable_9pywrapfst__EncodeMapperSymbolTableView.__pyx_base = *__pyx_vtabptr_9pywrapfst_SymbolTableView; __pyx_vtable_9pywrapfst__EncodeMapperSymbolTableView.__pyx_base._raw = (fst::SymbolTable const *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_28_EncodeMapperSymbolTableView__raw; __pyx_type_9pywrapfst__EncodeMapperSymbolTableView.tp_base = __pyx_ptype_9pywrapfst_SymbolTableView; if (PyType_Ready(&__pyx_type_9pywrapfst__EncodeMapperSymbolTableView) < 0) __PYX_ERR(0, 934, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst__EncodeMapperSymbolTableView.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst__EncodeMapperSymbolTableView.tp_dictoffset && __pyx_type_9pywrapfst__EncodeMapperSymbolTableView.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst__EncodeMapperSymbolTableView.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst__EncodeMapperSymbolTableView.tp_dict, __pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTableView) < 0) __PYX_ERR(0, 934, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_EncodeMapperSymbolTableView, (PyObject *)&__pyx_type_9pywrapfst__EncodeMapperSymbolTableView) < 0) __PYX_ERR(0, 934, __pyx_L1_error) __pyx_ptype_9pywrapfst__EncodeMapperSymbolTableView = &__pyx_type_9pywrapfst__EncodeMapperSymbolTableView; __pyx_vtabptr_9pywrapfst__FstSymbolTableView = &__pyx_vtable_9pywrapfst__FstSymbolTableView; __pyx_vtable_9pywrapfst__FstSymbolTableView.__pyx_base = *__pyx_vtabptr_9pywrapfst_SymbolTableView; __pyx_vtable_9pywrapfst__FstSymbolTableView.__pyx_base._raw = (fst::SymbolTable const *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_19_FstSymbolTableView__raw; __pyx_type_9pywrapfst__FstSymbolTableView.tp_base = __pyx_ptype_9pywrapfst_SymbolTableView; if (PyType_Ready(&__pyx_type_9pywrapfst__FstSymbolTableView) < 0) __PYX_ERR(0, 958, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst__FstSymbolTableView.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst__FstSymbolTableView.tp_dictoffset && __pyx_type_9pywrapfst__FstSymbolTableView.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst__FstSymbolTableView.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst__FstSymbolTableView.tp_dict, __pyx_vtabptr_9pywrapfst__FstSymbolTableView) < 0) __PYX_ERR(0, 958, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FstSymbolTableView, (PyObject *)&__pyx_type_9pywrapfst__FstSymbolTableView) < 0) __PYX_ERR(0, 958, __pyx_L1_error) __pyx_ptype_9pywrapfst__FstSymbolTableView = &__pyx_type_9pywrapfst__FstSymbolTableView; __pyx_vtabptr_9pywrapfst__MutableSymbolTable = &__pyx_vtable_9pywrapfst__MutableSymbolTable; __pyx_vtable_9pywrapfst__MutableSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst_SymbolTableView; __pyx_vtable_9pywrapfst__MutableSymbolTable.__pyx_base._raw = (fst::SymbolTable const *(*)(struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_19_MutableSymbolTable__raw; __pyx_vtable_9pywrapfst__MutableSymbolTable._mutable_raw = (fst::SymbolTable *(*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *))__pyx_f_9pywrapfst_19_MutableSymbolTable__mutable_raw; __pyx_vtable_9pywrapfst__MutableSymbolTable._mutable_raw_ptr_or_raise = (fst::SymbolTable *(*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *))__pyx_f_9pywrapfst_19_MutableSymbolTable__mutable_raw_ptr_or_raise; __pyx_vtable_9pywrapfst__MutableSymbolTable.add_symbol = (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_SymbolTableView *, 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_SymbolTableView; if (PyType_Ready(&__pyx_type_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 981, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst__MutableSymbolTable.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst__MutableSymbolTable.tp_dictoffset && __pyx_type_9pywrapfst__MutableSymbolTable.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst__MutableSymbolTable.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 981, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MutableSymbolTable, (PyObject *)&__pyx_type_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 981, __pyx_L1_error) __pyx_ptype_9pywrapfst__MutableSymbolTable = &__pyx_type_9pywrapfst__MutableSymbolTable; __pyx_vtabptr_9pywrapfst__MutableFstSymbolTableView = &__pyx_vtable_9pywrapfst__MutableFstSymbolTableView; __pyx_vtable_9pywrapfst__MutableFstSymbolTableView.__pyx_base = *__pyx_vtabptr_9pywrapfst__MutableSymbolTable; __pyx_vtable_9pywrapfst__MutableFstSymbolTableView.__pyx_base._mutable_raw = (fst::SymbolTable *(*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *))__pyx_f_9pywrapfst_26_MutableFstSymbolTableView__mutable_raw; __pyx_type_9pywrapfst__MutableFstSymbolTableView.tp_base = __pyx_ptype_9pywrapfst__MutableSymbolTable; if (PyType_Ready(&__pyx_type_9pywrapfst__MutableFstSymbolTableView) < 0) __PYX_ERR(0, 1053, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst__MutableFstSymbolTableView.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst__MutableFstSymbolTableView.tp_dictoffset && __pyx_type_9pywrapfst__MutableFstSymbolTableView.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst__MutableFstSymbolTableView.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableFstSymbolTableView.tp_dict, __pyx_vtabptr_9pywrapfst__MutableFstSymbolTableView) < 0) __PYX_ERR(0, 1053, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MutableFstSymbolTableView, (PyObject *)&__pyx_type_9pywrapfst__MutableFstSymbolTableView) < 0) __PYX_ERR(0, 1053, __pyx_L1_error) __pyx_ptype_9pywrapfst__MutableFstSymbolTableView = &__pyx_type_9pywrapfst__MutableFstSymbolTableView; __pyx_vtabptr_9pywrapfst_SymbolTable = &__pyx_vtable_9pywrapfst_SymbolTable; __pyx_vtable_9pywrapfst_SymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__MutableSymbolTable; __pyx_vtable_9pywrapfst_SymbolTable.__pyx_base._mutable_raw = (fst::SymbolTable *(*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *))__pyx_f_9pywrapfst_11SymbolTable__mutable_raw; __pyx_type_9pywrapfst_SymbolTable.tp_base = __pyx_ptype_9pywrapfst__MutableSymbolTable; if (PyType_Ready(&__pyx_type_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 1068, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_SymbolTable.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_SymbolTable.tp_dictoffset && __pyx_type_9pywrapfst_SymbolTable.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_SymbolTable.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_SymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 1068, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SymbolTable_2, (PyObject *)&__pyx_type_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 1068, __pyx_L1_error) __pyx_ptype_9pywrapfst_SymbolTable = &__pyx_type_9pywrapfst_SymbolTable; if (PyType_Ready(&__pyx_type_9pywrapfst__SymbolTableIterator) < 0) __PYX_ERR(0, 1264, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst__SymbolTableIterator.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst__SymbolTableIterator.tp_dictoffset && __pyx_type_9pywrapfst__SymbolTableIterator.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst__SymbolTableIterator.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SymbolTableIterator, (PyObject *)&__pyx_type_9pywrapfst__SymbolTableIterator) < 0) __PYX_ERR(0, 1264, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst__SymbolTableIterator) < 0) __PYX_ERR(0, 1264, __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.weight_type = (std::string (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_weight_type; __pyx_vtable_9pywrapfst_EncodeMapper.flags = (uint8 (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_flags; __pyx_vtable_9pywrapfst_EncodeMapper.write = (void (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_write; __pyx_vtable_9pywrapfst_EncodeMapper.write_to_string = (PyObject *(*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_write_to_string; __pyx_vtable_9pywrapfst_EncodeMapper.input_symbols = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTableView *(*)(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__EncodeMapperSymbolTableView *(*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_output_symbols; __pyx_vtable_9pywrapfst_EncodeMapper._set_input_symbols = (void (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_12EncodeMapper__set_input_symbols; __pyx_vtable_9pywrapfst_EncodeMapper._set_output_symbols = (void (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_12EncodeMapper__set_output_symbols; if (PyType_Ready(&__pyx_type_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1296, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_EncodeMapper.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_EncodeMapper.tp_dictoffset && __pyx_type_9pywrapfst_EncodeMapper.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_EncodeMapper.tp_getattro = __Pyx_PyObject_GenericGetAttr; } #if CYTHON_COMPILING_IN_CPYTHON { PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_9pywrapfst_EncodeMapper, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(0, 1296, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_9pywrapfst_12EncodeMapper_4__call__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_9pywrapfst_12EncodeMapper_4__call__.doc = __pyx_doc_9pywrapfst_12EncodeMapper_4__call__; ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pywrapfst_12EncodeMapper_4__call__; } } #endif if (__Pyx_SetVtable(__pyx_type_9pywrapfst_EncodeMapper.tp_dict, __pyx_vtabptr_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1296, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_EncodeMapper, (PyObject *)&__pyx_type_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1296, __pyx_L1_error) __pyx_ptype_9pywrapfst_EncodeMapper = &__pyx_type_9pywrapfst_EncodeMapper; __pyx_vtabptr_9pywrapfst_Fst = &__pyx_vtable_9pywrapfst_Fst; __pyx_vtable_9pywrapfst_Fst._local_render_svg = (std::string (*)(std::string const &))__pyx_f_9pywrapfst_3Fst__local_render_svg; __pyx_vtable_9pywrapfst_Fst.arc_type = (std::string (*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_arc_type; __pyx_vtable_9pywrapfst_Fst.arcs = (struct __pyx_obj_9pywrapfst_ArcIterator *(*)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_arcs; __pyx_vtable_9pywrapfst_Fst.copy = (struct __pyx_obj_9pywrapfst_Fst *(*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_copy; __pyx_vtable_9pywrapfst_Fst.draw = (void (*)(struct __pyx_obj_9pywrapfst_Fst *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_3Fst_draw *__pyx_optional_args))__pyx_f_9pywrapfst_3Fst_draw; __pyx_vtable_9pywrapfst_Fst.final = (struct __pyx_obj_9pywrapfst_Weight *(*)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_final; __pyx_vtable_9pywrapfst_Fst.fst_type = (std::string (*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_fst_type; __pyx_vtable_9pywrapfst_Fst.input_symbols = (struct __pyx_obj_9pywrapfst__FstSymbolTableView *(*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_input_symbols; __pyx_vtable_9pywrapfst_Fst.num_arcs = (size_t (*)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_num_arcs; __pyx_vtable_9pywrapfst_Fst.num_input_epsilons = (size_t (*)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_num_input_epsilons; __pyx_vtable_9pywrapfst_Fst.num_output_epsilons = (size_t (*)(struct __pyx_obj_9pywrapfst_Fst *, int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_num_output_epsilons; __pyx_vtable_9pywrapfst_Fst.output_symbols = (struct __pyx_obj_9pywrapfst__FstSymbolTableView *(*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_output_symbols; __pyx_vtable_9pywrapfst_Fst.print = (std::string (*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_3Fst_print *__pyx_optional_args))__pyx_f_9pywrapfst_3Fst_print; __pyx_vtable_9pywrapfst_Fst.start = (int64 (*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_start; __pyx_vtable_9pywrapfst_Fst.states = (struct __pyx_obj_9pywrapfst_StateIterator *(*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_states; __pyx_vtable_9pywrapfst_Fst.verify = (bool (*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_verify; __pyx_vtable_9pywrapfst_Fst.weight_type = (std::string (*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_weight_type; __pyx_vtable_9pywrapfst_Fst.write = (void (*)(struct __pyx_obj_9pywrapfst_Fst *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_write; __pyx_vtable_9pywrapfst_Fst.write_to_string = (PyObject *(*)(struct __pyx_obj_9pywrapfst_Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Fst_write_to_string; if (PyType_Ready(&__pyx_type_9pywrapfst_Fst) < 0) __PYX_ERR(0, 1563, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_Fst.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_Fst.tp_dictoffset && __pyx_type_9pywrapfst_Fst.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_Fst.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Fst.tp_dict, __pyx_vtabptr_9pywrapfst_Fst) < 0) __PYX_ERR(0, 1563, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Fst, (PyObject *)&__pyx_type_9pywrapfst_Fst) < 0) __PYX_ERR(0, 1563, __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_10MutableFst__check_mutating_imethod; __pyx_vtable_9pywrapfst_MutableFst._add_arc = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, struct __pyx_obj_9pywrapfst_Arc *))__pyx_f_9pywrapfst_10MutableFst__add_arc; __pyx_vtable_9pywrapfst_MutableFst.add_state = (int64 (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_10MutableFst_add_state; __pyx_vtable_9pywrapfst_MutableFst.add_states = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, size_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_10MutableFst_add_states; __pyx_vtable_9pywrapfst_MutableFst._arcsort = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__arcsort *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__arcsort; __pyx_vtable_9pywrapfst_MutableFst._closure = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__closure *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__closure; __pyx_vtable_9pywrapfst_MutableFst._concat = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_obj_9pywrapfst_Fst *))__pyx_f_9pywrapfst_10MutableFst__concat; __pyx_vtable_9pywrapfst_MutableFst._connect = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *))__pyx_f_9pywrapfst_10MutableFst__connect; __pyx_vtable_9pywrapfst_MutableFst._decode = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *))__pyx_f_9pywrapfst_10MutableFst__decode; __pyx_vtable_9pywrapfst_MutableFst._delete_arcs = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_arcs *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__delete_arcs; __pyx_vtable_9pywrapfst_MutableFst._delete_states = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__delete_states *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__delete_states; __pyx_vtable_9pywrapfst_MutableFst._encode = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *))__pyx_f_9pywrapfst_10MutableFst__encode; __pyx_vtable_9pywrapfst_MutableFst._invert = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *))__pyx_f_9pywrapfst_10MutableFst__invert; __pyx_vtable_9pywrapfst_MutableFst._minimize = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__minimize *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__minimize; __pyx_vtable_9pywrapfst_MutableFst.mutable_arcs = (struct __pyx_obj_9pywrapfst_MutableArcIterator *(*)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_10MutableFst_mutable_arcs; __pyx_vtable_9pywrapfst_MutableFst.num_states = (int64 (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_10MutableFst_num_states; __pyx_vtable_9pywrapfst_MutableFst._project = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, PyObject *))__pyx_f_9pywrapfst_10MutableFst__project; __pyx_vtable_9pywrapfst_MutableFst._prune = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__prune *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__prune; __pyx_vtable_9pywrapfst_MutableFst._push = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__push *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__push; __pyx_vtable_9pywrapfst_MutableFst._relabel_pairs = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_pairs *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__relabel_pairs; __pyx_vtable_9pywrapfst_MutableFst._relabel_tables = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__relabel_tables *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__relabel_tables; __pyx_vtable_9pywrapfst_MutableFst._reserve_arcs = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, size_t))__pyx_f_9pywrapfst_10MutableFst__reserve_arcs; __pyx_vtable_9pywrapfst_MutableFst._reserve_states = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int64))__pyx_f_9pywrapfst_10MutableFst__reserve_states; __pyx_vtable_9pywrapfst_MutableFst._reweight = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, PyObject *, struct __pyx_opt_args_9pywrapfst_10MutableFst__reweight *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__reweight; __pyx_vtable_9pywrapfst_MutableFst._rmepsilon = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_opt_args_9pywrapfst_10MutableFst__rmepsilon *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__rmepsilon; __pyx_vtable_9pywrapfst_MutableFst._set_final = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int64, struct __pyx_opt_args_9pywrapfst_10MutableFst__set_final *__pyx_optional_args))__pyx_f_9pywrapfst_10MutableFst__set_final; __pyx_vtable_9pywrapfst_MutableFst._set_start = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, int64))__pyx_f_9pywrapfst_10MutableFst__set_start; __pyx_vtable_9pywrapfst_MutableFst._set_input_symbols = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_10MutableFst__set_input_symbols; __pyx_vtable_9pywrapfst_MutableFst._set_output_symbols = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *, struct __pyx_obj_9pywrapfst_SymbolTableView *))__pyx_f_9pywrapfst_10MutableFst__set_output_symbols; __pyx_vtable_9pywrapfst_MutableFst._topsort = (void (*)(struct __pyx_obj_9pywrapfst_MutableFst *))__pyx_f_9pywrapfst_10MutableFst__topsort; __pyx_type_9pywrapfst_MutableFst.tp_base = __pyx_ptype_9pywrapfst_Fst; if (PyType_Ready(&__pyx_type_9pywrapfst_MutableFst) < 0) __PYX_ERR(0, 2028, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_MutableFst.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_MutableFst.tp_dictoffset && __pyx_type_9pywrapfst_MutableFst.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_MutableFst.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_MutableFst.tp_dict, __pyx_vtabptr_9pywrapfst_MutableFst) < 0) __PYX_ERR(0, 2028, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MutableFst, (PyObject *)&__pyx_type_9pywrapfst_MutableFst) < 0) __PYX_ERR(0, 2028, __pyx_L1_error) __pyx_ptype_9pywrapfst_MutableFst = &__pyx_type_9pywrapfst_MutableFst; __pyx_vtabptr_9pywrapfst_VectorFst = &__pyx_vtable_9pywrapfst_VectorFst; __pyx_vtable_9pywrapfst_VectorFst.__pyx_base = *__pyx_vtabptr_9pywrapfst_MutableFst; __pyx_type_9pywrapfst_VectorFst.tp_base = __pyx_ptype_9pywrapfst_MutableFst; if (PyType_Ready(&__pyx_type_9pywrapfst_VectorFst) < 0) __PYX_ERR(0, 2890, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_VectorFst.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_VectorFst.tp_dictoffset && __pyx_type_9pywrapfst_VectorFst.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_VectorFst.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_VectorFst.tp_dict, __pyx_vtabptr_9pywrapfst_VectorFst) < 0) __PYX_ERR(0, 2890, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_VectorFst, (PyObject *)&__pyx_type_9pywrapfst_VectorFst) < 0) __PYX_ERR(0, 2890, __pyx_L1_error) __pyx_ptype_9pywrapfst_VectorFst = &__pyx_type_9pywrapfst_VectorFst; __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, 3073, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_Arc.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_Arc.tp_dictoffset && __pyx_type_9pywrapfst_Arc.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_Arc.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Arc.tp_dict, __pyx_vtabptr_9pywrapfst_Arc) < 0) __PYX_ERR(0, 3073, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Arc, (PyObject *)&__pyx_type_9pywrapfst_Arc) < 0) __PYX_ERR(0, 3073, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_Arc) < 0) __PYX_ERR(0, 3073, __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 = (uint8 (*)(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 *, uint8, uint8, 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, 3140, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_ArcIterator.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_ArcIterator.tp_dictoffset && __pyx_type_9pywrapfst_ArcIterator.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_ArcIterator.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_ArcIterator.tp_dict, __pyx_vtabptr_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 3140, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ArcIterator, (PyObject *)&__pyx_type_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 3140, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 3140, __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 = (uint8 (*)(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 *, uint8, uint8, 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, 3251, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_MutableArcIterator.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_MutableArcIterator.tp_dictoffset && __pyx_type_9pywrapfst_MutableArcIterator.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_MutableArcIterator.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_MutableArcIterator.tp_dict, __pyx_vtabptr_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 3251, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_MutableArcIterator, (PyObject *)&__pyx_type_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 3251, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 3251, __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 = (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, 3371, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_StateIterator.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_StateIterator.tp_dictoffset && __pyx_type_9pywrapfst_StateIterator.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_StateIterator.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_StateIterator.tp_dict, __pyx_vtabptr_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3371, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_StateIterator, (PyObject *)&__pyx_type_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3371, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3371, __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, 4280, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_Compiler.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_Compiler.tp_dictoffset && __pyx_type_9pywrapfst_Compiler.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_Compiler.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Compiler.tp_dict, __pyx_vtabptr_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4280, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Compiler, (PyObject *)&__pyx_type_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4280, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4280, __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, 4417, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_FarReader.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_FarReader.tp_dictoffset && __pyx_type_9pywrapfst_FarReader.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_FarReader.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_FarReader.tp_dict, __pyx_vtabptr_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4417, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FarReader, (PyObject *)&__pyx_type_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4417, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4417, __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, 4572, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst_FarWriter.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst_FarWriter.tp_dictoffset && __pyx_type_9pywrapfst_FarWriter.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst_FarWriter.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_9pywrapfst_FarWriter.tp_dict, __pyx_vtabptr_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4572, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FarWriter, (PyObject *)&__pyx_type_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4572, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4572, __pyx_L1_error) __pyx_ptype_9pywrapfst_FarWriter = &__pyx_type_9pywrapfst_FarWriter; if (PyType_Ready(&__pyx_type_9pywrapfst___pyx_scope_struct____iter__) < 0) __PYX_ERR(0, 3271, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_9pywrapfst___pyx_scope_struct____iter__.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_9pywrapfst___pyx_scope_struct____iter__.tp_dictoffset && __pyx_type_9pywrapfst___pyx_scope_struct____iter__.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_9pywrapfst___pyx_scope_struct____iter__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_9pywrapfst___pyx_scope_struct____iter__ = &__pyx_type_9pywrapfst___pyx_scope_struct____iter__; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initpywrapfst(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initpywrapfst(void) #else __Pyx_PyMODINIT_FUNC PyInit_pywrapfst(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_pywrapfst(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; 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__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE 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; Py_ssize_t __pyx_t_5; Py_ssize_t __pyx_t_6; int __pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'pywrapfst' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #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("__Pyx_PyMODINIT_FUNC PyInit_pywrapfst(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __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) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); 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_SetAttr(__pyx_m, __pyx_n_s_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 type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) (void)__Pyx_modinit_type_import_code(); (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_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":99 * * # Python imports. * import logging # <<<<<<<<<<<<<< * import enum * import numbers */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_logging, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_logging, __pyx_t_1) < 0) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":100 * # Python imports. * import logging * import enum # <<<<<<<<<<<<<< * import numbers * import os */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_enum, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_enum, __pyx_t_1) < 0) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":101 * import logging * import enum * import numbers # <<<<<<<<<<<<<< * import os * import subprocess */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numbers, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_numbers, __pyx_t_1) < 0) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":102 * import enum * import numbers * import os # <<<<<<<<<<<<<< * import subprocess * import sys */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":103 * import numbers * import os * import subprocess # <<<<<<<<<<<<<< * import sys * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_subprocess, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_subprocess, __pyx_t_1) < 0) __PYX_ERR(0, 103, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":104 * import os * import subprocess * import sys # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(0, 104, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":111 * # These defintions only ensure that these are defined to avoid attribute errors, * # but don't actually contain the type definitions. Those are in _pywrapfst.pyi. * import typing # <<<<<<<<<<<<<< * * ArcMapType = """typing.Literal["identity", "input_epsilon", "invert", */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_typing, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_typing, __pyx_t_1) < 0) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":113 * import typing * * ArcMapType = """typing.Literal["identity", "input_epsilon", "invert", # <<<<<<<<<<<<<< * "output_epsilon", "plus", "power", "quantize", * "rmweight", "superfinal", "times", "to_log", */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ArcMapType, __pyx_kp_u_typing_Literal_identity_input_ep) < 0) __PYX_ERR(0, 113, __pyx_L1_error) /* "pywrapfst.pyx":118 * # NOTE: Both spellings of "to_std" * "to_log64", "to_std", "to_standard"]""" * ComposeFilter = """typing.Literal["alt_sequence", "auto", "match", "no_match", # <<<<<<<<<<<<<< * "null", "sequence", "trivial"]""" * DeterminizeType = """typing.Literal["functional", "nonfunctional", */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ComposeFilter, __pyx_kp_u_typing_Literal_alt_sequence_auto) < 0) __PYX_ERR(0, 118, __pyx_L1_error) /* "pywrapfst.pyx":120 * ComposeFilter = """typing.Literal["alt_sequence", "auto", "match", "no_match", * "null", "sequence", "trivial"]""" * DeterminizeType = """typing.Literal["functional", "nonfunctional", # <<<<<<<<<<<<<< * "disambiguate"]""" * DrawFloatFormat = """typing.Literal["e", "f", "g"]""" */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_DeterminizeType, __pyx_kp_u_typing_Literal_functional_nonfun) < 0) __PYX_ERR(0, 120, __pyx_L1_error) /* "pywrapfst.pyx":122 * DeterminizeType = """typing.Literal["functional", "nonfunctional", * "disambiguate"]""" * DrawFloatFormat = """typing.Literal["e", "f", "g"]""" # <<<<<<<<<<<<<< * FarType = """typing.Literal[ * "fst", */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_DrawFloatFormat, __pyx_kp_u_typing_Literal_e_f_g) < 0) __PYX_ERR(0, 122, __pyx_L1_error) /* "pywrapfst.pyx":123 * "disambiguate"]""" * DrawFloatFormat = """typing.Literal["e", "f", "g"]""" * FarType = """typing.Literal[ # <<<<<<<<<<<<<< * "fst", * "stlist", */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FarType, __pyx_kp_u_typing_Literal_fst_stlist_sttabl) < 0) __PYX_ERR(0, 123, __pyx_L1_error) /* "pywrapfst.pyx":129 * "default" * ]""" * ProjectType = """typing.Literal["input", "output"]""" # <<<<<<<<<<<<<< * QueueType = """typing.Literal["auto", "fifo", "lifo", "shortest", "state", * "top"]""" */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ProjectType, __pyx_kp_u_typing_Literal_input_output) < 0) __PYX_ERR(0, 129, __pyx_L1_error) /* "pywrapfst.pyx":130 * ]""" * ProjectType = """typing.Literal["input", "output"]""" * QueueType = """typing.Literal["auto", "fifo", "lifo", "shortest", "state", # <<<<<<<<<<<<<< * "top"]""" * RandArcSelection = """typing.Literal["uniform", "log_prob", "fast_log_prob"]""" */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_QueueType, __pyx_kp_u_typing_Literal_auto_fifo_lifo_sh) < 0) __PYX_ERR(0, 130, __pyx_L1_error) /* "pywrapfst.pyx":132 * QueueType = """typing.Literal["auto", "fifo", "lifo", "shortest", "state", * "top"]""" * RandArcSelection = """typing.Literal["uniform", "log_prob", "fast_log_prob"]""" # <<<<<<<<<<<<<< * ReplaceLabelType = """typing.Literal["neither", "input", "output", "both"]""" * SortType = """typing.Literal["ilabel", "olabel"]""" */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_RandArcSelection, __pyx_kp_u_typing_Literal_uniform_log_prob) < 0) __PYX_ERR(0, 132, __pyx_L1_error) /* "pywrapfst.pyx":133 * "top"]""" * RandArcSelection = """typing.Literal["uniform", "log_prob", "fast_log_prob"]""" * ReplaceLabelType = """typing.Literal["neither", "input", "output", "both"]""" # <<<<<<<<<<<<<< * SortType = """typing.Literal["ilabel", "olabel"]""" * StateMapType = """typing.Literal["arc_sum", "arc_unique", "identity"]""" */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ReplaceLabelType, __pyx_kp_u_typing_Literal_neither_input_out) < 0) __PYX_ERR(0, 133, __pyx_L1_error) /* "pywrapfst.pyx":134 * RandArcSelection = """typing.Literal["uniform", "log_prob", "fast_log_prob"]""" * ReplaceLabelType = """typing.Literal["neither", "input", "output", "both"]""" * SortType = """typing.Literal["ilabel", "olabel"]""" # <<<<<<<<<<<<<< * StateMapType = """typing.Literal["arc_sum", "arc_unique", "identity"]""" * */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_SortType, __pyx_kp_u_typing_Literal_ilabel_olabel) < 0) __PYX_ERR(0, 134, __pyx_L1_error) /* "pywrapfst.pyx":135 * ReplaceLabelType = """typing.Literal["neither", "input", "output", "both"]""" * SortType = """typing.Literal["ilabel", "olabel"]""" * StateMapType = """typing.Literal["arc_sum", "arc_unique", "identity"]""" # <<<<<<<<<<<<<< * * WeightLike = "typing.Union[Weight, typing.Union[str, int, float]]" */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_StateMapType, __pyx_kp_u_typing_Literal_arc_sum_arc_uniqu) < 0) __PYX_ERR(0, 135, __pyx_L1_error) /* "pywrapfst.pyx":137 * StateMapType = """typing.Literal["arc_sum", "arc_unique", "identity"]""" * * WeightLike = "typing.Union[Weight, typing.Union[str, int, float]]" # <<<<<<<<<<<<<< * * ## Custom exceptions. */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_WeightLike, __pyx_kp_u_typing_Union_Weight_typing_Union) < 0) __PYX_ERR(0, 137, __pyx_L1_error) /* "pywrapfst.pyx":142 * * * class FstError(Exception): # <<<<<<<<<<<<<< * * pass */ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 142, __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, 142, __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, 142, __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, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstError, __pyx_t_4) < 0) __PYX_ERR(0, 142, __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":147 * * * class FstArgError(FstError, ValueError): # <<<<<<<<<<<<<< * * pass */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __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, 147, __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, 147, __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, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 147, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstArgError, __pyx_t_4) < 0) __PYX_ERR(0, 147, __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":152 * * * class FstBadWeightError(FstError, ValueError): # <<<<<<<<<<<<<< * * pass */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __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, 152, __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, 152, __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, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 152, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstBadWeightError, __pyx_t_4) < 0) __PYX_ERR(0, 152, __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":157 * * * class FstIndexError(FstError, IndexError): # <<<<<<<<<<<<<< * * pass */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __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_IndexError); __Pyx_GIVEREF(__pyx_builtin_IndexError); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_builtin_IndexError); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __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, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstIndexError, __pyx_t_2, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstIndexError, __pyx_t_4) < 0) __PYX_ERR(0, 157, __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":162 * * * class FstIOError(FstError, IOError): # <<<<<<<<<<<<<< * * pass */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 162, __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_IOError); __Pyx_GIVEREF(__pyx_builtin_IOError); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_IOError); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __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, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstIOError, __pyx_t_1, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstIOError, __pyx_t_4) < 0) __PYX_ERR(0, 162, __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":167 * * * class FstOpError(FstError, RuntimeError): # <<<<<<<<<<<<<< * * pass */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __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, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __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, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstOpError, __pyx_t_2, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstOpError, __pyx_t_4) < 0) __PYX_ERR(0, 167, __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":461 * * @classmethod * def zero(cls, weight_type): # <<<<<<<<<<<<<< * """ * Weight.zero(weight_type) */ __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_zero); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pywrapfst.pyx":460 * # C++ part out-of-class and then call it from within. * * @classmethod # <<<<<<<<<<<<<< * def zero(cls, weight_type): * """ */ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 460, __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_zero, __pyx_t_1) < 0) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_Weight); /* "pywrapfst.pyx":470 * * @classmethod * def one(cls, weight_type): # <<<<<<<<<<<<<< * """ * Weight.one(weight_type) */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_one); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "pywrapfst.pyx":469 * return _zero(weight_type) * * @classmethod # <<<<<<<<<<<<<< * def one(cls, weight_type): * """ */ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 469, __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_one, __pyx_t_2) < 0) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_Weight); /* "pywrapfst.pyx":479 * * @classmethod * def no_weight(cls, weight_type): # <<<<<<<<<<<<<< * """ * Weight.no_weight(weight_type) */ __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_no_weight); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pywrapfst.pyx":478 * return _one(weight_type) * * @classmethod # <<<<<<<<<<<<<< * def no_weight(cls, weight_type): * """ */ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 478, __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_no_weight, __pyx_t_1) < 0) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_Weight); /* "pywrapfst.pyx":514 * * * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * """ * plus(lhs, rhs) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_1plus, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_plus, __pyx_t_1) < 0) __PYX_ERR(0, 514, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":546 * * * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * """ * times(lhs, rhs) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_3times, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_times, __pyx_t_1) < 0) __PYX_ERR(0, 546, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":578 * * * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<< * """ * divide(lhs, rhs) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_5divide, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_divide, __pyx_t_1) < 0) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":611 * * * def power(Weight w, size_t n): # <<<<<<<<<<<<<< * """ * power(lhs, rhs) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_7power, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_power, __pyx_t_1) < 0) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pywrapfst.pyx":1010 * return mutable_raw * * cpdef int64 add_symbol(self, symbol, int64 key=fst.kNoSymbol) except *: # <<<<<<<<<<<<<< * """ * add_symbol(self, symbol, key=NO_SYMBOL) */ __pyx_k__6 = fst::kNoSymbol; __pyx_k__6 = fst::kNoSymbol; /* "pywrapfst.pyx":1095 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * SymbolTable.read(source) */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1095, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "pywrapfst.pyx":1094 * return self._smart_table.get() * * @classmethod # <<<<<<<<<<<<<< * def read(cls, source): * """ */ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1094, __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, __pyx_t_2) < 0) __PYX_ERR(0, 1095, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable); /* "pywrapfst.pyx":1116 * * @classmethod * def read_text(cls, source, bool allow_negative_labels=False): # <<<<<<<<<<<<<< * """ * SymbolTable.read_text(source) */ __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read_text); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pywrapfst.pyx":1115 * return _init_SymbolTable(move(_symbols)) * * @classmethod # <<<<<<<<<<<<<< * def read_text(cls, source, bool allow_negative_labels=False): * """ */ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1115, __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_text, __pyx_t_1) < 0) __PYX_ERR(0, 1116, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable); /* "pywrapfst.pyx":1142 * * @classmethod * def read_fst(cls, source, bool input_table): # <<<<<<<<<<<<<< * """ * SymbolTable.read_fst(source, input_table) */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read_fst); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "pywrapfst.pyx":1141 * return _init_SymbolTable(move(_symbols)) * * @classmethod # <<<<<<<<<<<<<< * def read_fst(cls, source, bool input_table): * """ */ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1141, __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_fst, __pyx_t_2) < 0) __PYX_ERR(0, 1142, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable); /* "pywrapfst.pyx":1399 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * EncodeMapper.read(source) */ __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_9pywrapfst_EncodeMapper, __pyx_n_s_read); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pywrapfst.pyx":1398 * return FstProperties(self._mapper.get().Properties(mask.value)) * * @classmethod # <<<<<<<<<<<<<< * def read(cls, source): * """ */ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_EncodeMapper->tp_dict, __pyx_n_s_read, __pyx_t_1) < 0) __PYX_ERR(0, 1399, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_EncodeMapper); /* "pywrapfst.pyx":1421 * * @staticmethod * def read_from_string(state): # <<<<<<<<<<<<<< * """ * read_from_string(state) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_12EncodeMapper_19read_from_string, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_EncodeMapper->tp_dict, __pyx_n_s_read_from_string, __pyx_t_1) < 0) __PYX_ERR(0, 1421, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_EncodeMapper); /* "pywrapfst.pyx":1420 * return _init_EncodeMapper(_mapper.release()) * * @staticmethod # <<<<<<<<<<<<<< * def read_from_string(state): * """ */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_9pywrapfst_EncodeMapper, __pyx_n_s_read_from_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1421, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_staticmethod, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1420, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_EncodeMapper->tp_dict, __pyx_n_s_read_from_string, __pyx_t_2) < 0) __PYX_ERR(0, 1421, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_EncodeMapper); /* "pywrapfst.pyx":1917 * * @classmethod * def read(cls, source): # <<<<<<<<<<<<<< * """ * read(source) */ __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_9pywrapfst_Fst, __pyx_n_s_read); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pywrapfst.pyx":1916 * return FstProperties(self._fst.get().Properties(mask.value, test)) * * @classmethod # <<<<<<<<<<<<<< * def read(cls, source): * """ */ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1916, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_Fst->tp_dict, __pyx_n_s_read, __pyx_t_1) < 0) __PYX_ERR(0, 1917, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_Fst); /* "pywrapfst.pyx":1935 * * @classmethod * def read_from_string(cls, state): # <<<<<<<<<<<<<< * """ * read_from_string(state) */ __Pyx_GetNameInClass(__pyx_t_1, (PyObject *)__pyx_ptype_9pywrapfst_Fst, __pyx_n_s_read_from_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1935, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "pywrapfst.pyx":1934 * return _read_Fst(source) * * @classmethod # <<<<<<<<<<<<<< * def read_from_string(cls, state): * """ */ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1934, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_Fst->tp_dict, __pyx_n_s_read_from_string, __pyx_t_2) < 0) __PYX_ERR(0, 1935, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_Fst); /* "pywrapfst.pyx":2308 * * 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__12 = fst::kShortestDelta; /* "pywrapfst.pyx":2314 * 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__13 = fst::kShortestDelta; /* "pywrapfst.pyx":2409 * * cdef void _prune(self, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * weight=None) except *: */ __pyx_k__14 = fst::kDelta; /* "pywrapfst.pyx":2410 * 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__15 = fst::kNoStateId; /* "pywrapfst.pyx":2419 * * def prune(self, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * weight=None): */ __pyx_k__16 = fst::kDelta; /* "pywrapfst.pyx":2420 * def prune(self, * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * weight=None): * """ */ __pyx_k__17 = fst::kNoStateId; /* "pywrapfst.pyx":2445 * * cdef void _push(self, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * bool remove_total_weight=False, * bool to_final=False): */ __pyx_k__18 = fst::kShortestDelta; /* "pywrapfst.pyx":2454 * * def push(self, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * bool remove_total_weight=False, * bool to_final=False): */ __pyx_k__19 = fst::kShortestDelta; /* "pywrapfst.pyx":2685 * bool connect=True, * weight=None, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta) except *: * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(self.weight_type(), */ __pyx_k__20 = fst::kNoStateId; /* "pywrapfst.pyx":2686 * weight=None, * int64 nstate=fst.kNoStateId, * float delta=fst.kShortestDelta) except *: # <<<<<<<<<<<<<< * cdef fst.WeightClass _weight = _get_WeightClass_or_zero(self.weight_type(), * weight) */ __pyx_k__21 = fst::kShortestDelta; /* "pywrapfst.pyx":2703 * bool connect=True, * weight=None, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta): * """ */ __pyx_k__22 = fst::kNoStateId; /* "pywrapfst.pyx":2704 * weight=None, * int64 nstate=fst.kNoStateId, * float delta=fst.kShortestDelta): # <<<<<<<<<<<<<< * """ * rmepsilon(self, queue_type="auto", connect=True, weight=None, */ __pyx_k__23 = fst::kShortestDelta; /* "pywrapfst.pyx":2976 * * * NO_LABEL = fst.kNoLabel # <<<<<<<<<<<<<< * NO_STATE_ID = fst.kNoStateId * NO_SYMBOL = fst.kNoSymbol */ __pyx_t_2 = __Pyx_PyInt_From_int(fst::kNoLabel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_LABEL, __pyx_t_2) < 0) __PYX_ERR(0, 2976, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2977 * * NO_LABEL = fst.kNoLabel * NO_STATE_ID = fst.kNoStateId # <<<<<<<<<<<<<< * NO_SYMBOL = fst.kNoSymbol * */ __pyx_t_2 = __Pyx_PyInt_From_int(fst::kNoStateId); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2977, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_STATE_ID, __pyx_t_2) < 0) __PYX_ERR(0, 2977, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2978 * NO_LABEL = fst.kNoLabel * NO_STATE_ID = fst.kNoStateId * NO_SYMBOL = fst.kNoSymbol # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyInt_From_int64_t(fst::kNoSymbol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2978, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_SYMBOL, __pyx_t_2) < 0) __PYX_ERR(0, 2978, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":2983 * ## FST properties. * * class FstProperties(enum.Flag): # <<<<<<<<<<<<<< * EXPANDED = fst.kExpanded * MUTABLE = fst.kMutable */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_enum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Flag); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_FstProperties, __pyx_n_s_FstProperties, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "pywrapfst.pyx":2984 * * class FstProperties(enum.Flag): * EXPANDED = fst.kExpanded # <<<<<<<<<<<<<< * MUTABLE = fst.kMutable * ERROR = fst.kError */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kExpanded); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2984, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_EXPANDED, __pyx_t_4) < 0) __PYX_ERR(0, 2984, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2985 * class FstProperties(enum.Flag): * EXPANDED = fst.kExpanded * MUTABLE = fst.kMutable # <<<<<<<<<<<<<< * ERROR = fst.kError * ACCEPTOR = fst.kAcceptor */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kMutable); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2985, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_MUTABLE, __pyx_t_4) < 0) __PYX_ERR(0, 2985, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2986 * EXPANDED = fst.kExpanded * MUTABLE = fst.kMutable * ERROR = fst.kError # <<<<<<<<<<<<<< * ACCEPTOR = fst.kAcceptor * NOT_ACCEPTOR = fst.kNotAcceptor */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2986, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ERROR, __pyx_t_4) < 0) __PYX_ERR(0, 2986, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2987 * MUTABLE = fst.kMutable * ERROR = fst.kError * ACCEPTOR = fst.kAcceptor # <<<<<<<<<<<<<< * NOT_ACCEPTOR = fst.kNotAcceptor * I_DETERMINISTIC = fst.kIDeterministic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kAcceptor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2987, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ACCEPTOR, __pyx_t_4) < 0) __PYX_ERR(0, 2987, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2988 * ERROR = fst.kError * ACCEPTOR = fst.kAcceptor * NOT_ACCEPTOR = fst.kNotAcceptor # <<<<<<<<<<<<<< * I_DETERMINISTIC = fst.kIDeterministic * NON_I_DETERMINISTIC = fst.kNonIDeterministic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNotAcceptor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2988, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NOT_ACCEPTOR, __pyx_t_4) < 0) __PYX_ERR(0, 2988, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2989 * ACCEPTOR = fst.kAcceptor * NOT_ACCEPTOR = fst.kNotAcceptor * I_DETERMINISTIC = fst.kIDeterministic # <<<<<<<<<<<<<< * NON_I_DETERMINISTIC = fst.kNonIDeterministic * O_DETERMINISTIC = fst.kODeterministic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kIDeterministic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2989, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_I_DETERMINISTIC, __pyx_t_4) < 0) __PYX_ERR(0, 2989, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2990 * NOT_ACCEPTOR = fst.kNotAcceptor * I_DETERMINISTIC = fst.kIDeterministic * NON_I_DETERMINISTIC = fst.kNonIDeterministic # <<<<<<<<<<<<<< * O_DETERMINISTIC = fst.kODeterministic * NON_O_DETERMINISTIC = fst.kNonODeterministic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNonIDeterministic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2990, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NON_I_DETERMINISTIC, __pyx_t_4) < 0) __PYX_ERR(0, 2990, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2991 * I_DETERMINISTIC = fst.kIDeterministic * NON_I_DETERMINISTIC = fst.kNonIDeterministic * O_DETERMINISTIC = fst.kODeterministic # <<<<<<<<<<<<<< * NON_O_DETERMINISTIC = fst.kNonODeterministic * EPSILONS = fst.kEpsilons */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kODeterministic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2991, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_O_DETERMINISTIC, __pyx_t_4) < 0) __PYX_ERR(0, 2991, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2992 * NON_I_DETERMINISTIC = fst.kNonIDeterministic * O_DETERMINISTIC = fst.kODeterministic * NON_O_DETERMINISTIC = fst.kNonODeterministic # <<<<<<<<<<<<<< * EPSILONS = fst.kEpsilons * NO_EPSILONS = fst.kNoEpsilons */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNonODeterministic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2992, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NON_O_DETERMINISTIC, __pyx_t_4) < 0) __PYX_ERR(0, 2992, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2993 * O_DETERMINISTIC = fst.kODeterministic * NON_O_DETERMINISTIC = fst.kNonODeterministic * EPSILONS = fst.kEpsilons # <<<<<<<<<<<<<< * NO_EPSILONS = fst.kNoEpsilons * I_EPSILONS = fst.kIEpsilons */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kEpsilons); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_EPSILONS, __pyx_t_4) < 0) __PYX_ERR(0, 2993, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2994 * NON_O_DETERMINISTIC = fst.kNonODeterministic * EPSILONS = fst.kEpsilons * NO_EPSILONS = fst.kNoEpsilons # <<<<<<<<<<<<<< * I_EPSILONS = fst.kIEpsilons * NO_I_EPSILONS = fst.kNoIEpsilons */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNoEpsilons); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2994, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NO_EPSILONS, __pyx_t_4) < 0) __PYX_ERR(0, 2994, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2995 * EPSILONS = fst.kEpsilons * NO_EPSILONS = fst.kNoEpsilons * I_EPSILONS = fst.kIEpsilons # <<<<<<<<<<<<<< * NO_I_EPSILONS = fst.kNoIEpsilons * O_EPSILONS = fst.kOEpsilons */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kIEpsilons); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2995, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_I_EPSILONS, __pyx_t_4) < 0) __PYX_ERR(0, 2995, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2996 * NO_EPSILONS = fst.kNoEpsilons * I_EPSILONS = fst.kIEpsilons * NO_I_EPSILONS = fst.kNoIEpsilons # <<<<<<<<<<<<<< * O_EPSILONS = fst.kOEpsilons * NO_O_EPSILONS = fst.kNoOEpsilons */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNoIEpsilons); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2996, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NO_I_EPSILONS, __pyx_t_4) < 0) __PYX_ERR(0, 2996, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2997 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kOEpsilons); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2997, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_O_EPSILONS, __pyx_t_4) < 0) __PYX_ERR(0, 2997, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2998 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kNoOEpsilons); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2998, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NO_O_EPSILONS, __pyx_t_4) < 0) __PYX_ERR(0, 2998, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2999 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kILabelSorted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2999, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_I_LABEL_SORTED, __pyx_t_4) < 0) __PYX_ERR(0, 2999, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3000 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kNotILabelSorted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NOT_I_LABEL_SORTED, __pyx_t_4) < 0) __PYX_ERR(0, 3000, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3001 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kOLabelSorted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3001, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_O_LABEL_SORTED, __pyx_t_4) < 0) __PYX_ERR(0, 3001, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3002 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kNotOLabelSorted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3002, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NOT_O_LABEL_SORTED, __pyx_t_4) < 0) __PYX_ERR(0, 3002, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3003 * O_LABEL_SORTED = fst.kOLabelSorted * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted * WEIGHTED = fst.kWeighted # <<<<<<<<<<<<<< * UNWEIGHTED = fst.kUnweighted * CYCLIC = fst.kCyclic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kWeighted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3003, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_WEIGHTED, __pyx_t_4) < 0) __PYX_ERR(0, 3003, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3004 * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted * WEIGHTED = fst.kWeighted * UNWEIGHTED = fst.kUnweighted # <<<<<<<<<<<<<< * CYCLIC = fst.kCyclic * ACYCLIC = fst.kAcyclic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kUnweighted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3004, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_UNWEIGHTED, __pyx_t_4) < 0) __PYX_ERR(0, 3004, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3005 * WEIGHTED = fst.kWeighted * UNWEIGHTED = fst.kUnweighted * CYCLIC = fst.kCyclic # <<<<<<<<<<<<<< * ACYCLIC = fst.kAcyclic * INITIAL_CYCLIC = fst.kInitialCyclic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kCyclic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_CYCLIC, __pyx_t_4) < 0) __PYX_ERR(0, 3005, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3006 * UNWEIGHTED = fst.kUnweighted * CYCLIC = fst.kCyclic * ACYCLIC = fst.kAcyclic # <<<<<<<<<<<<<< * INITIAL_CYCLIC = fst.kInitialCyclic * INITIAL_ACYCLIC = fst.kInitialAcyclic */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kAcyclic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3006, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ACYCLIC, __pyx_t_4) < 0) __PYX_ERR(0, 3006, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3007 * CYCLIC = fst.kCyclic * ACYCLIC = fst.kAcyclic * INITIAL_CYCLIC = fst.kInitialCyclic # <<<<<<<<<<<<<< * INITIAL_ACYCLIC = fst.kInitialAcyclic * TOP_SORTED = fst.kTopSorted */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kInitialCyclic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3007, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_INITIAL_CYCLIC, __pyx_t_4) < 0) __PYX_ERR(0, 3007, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3008 * ACYCLIC = fst.kAcyclic * INITIAL_CYCLIC = fst.kInitialCyclic * INITIAL_ACYCLIC = fst.kInitialAcyclic # <<<<<<<<<<<<<< * TOP_SORTED = fst.kTopSorted * NOT_TOP_SORTED = fst.kNotTopSorted */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kInitialAcyclic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3008, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_INITIAL_ACYCLIC, __pyx_t_4) < 0) __PYX_ERR(0, 3008, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3009 * INITIAL_CYCLIC = fst.kInitialCyclic * INITIAL_ACYCLIC = fst.kInitialAcyclic * TOP_SORTED = fst.kTopSorted # <<<<<<<<<<<<<< * NOT_TOP_SORTED = fst.kNotTopSorted * ACCESSIBLE = fst.kAccessible */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kTopSorted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3009, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_TOP_SORTED, __pyx_t_4) < 0) __PYX_ERR(0, 3009, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3010 * INITIAL_ACYCLIC = fst.kInitialAcyclic * TOP_SORTED = fst.kTopSorted * NOT_TOP_SORTED = fst.kNotTopSorted # <<<<<<<<<<<<<< * ACCESSIBLE = fst.kAccessible * NOT_ACCESSIBLE = fst.kNotAccessible */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNotTopSorted); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3010, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NOT_TOP_SORTED, __pyx_t_4) < 0) __PYX_ERR(0, 3010, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3011 * TOP_SORTED = fst.kTopSorted * NOT_TOP_SORTED = fst.kNotTopSorted * ACCESSIBLE = fst.kAccessible # <<<<<<<<<<<<<< * NOT_ACCESSIBLE = fst.kNotAccessible * COACCESSIBLE = fst.kCoAccessible */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kAccessible); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3011, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ACCESSIBLE, __pyx_t_4) < 0) __PYX_ERR(0, 3011, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3012 * NOT_TOP_SORTED = fst.kNotTopSorted * ACCESSIBLE = fst.kAccessible * NOT_ACCESSIBLE = fst.kNotAccessible # <<<<<<<<<<<<<< * COACCESSIBLE = fst.kCoAccessible * NOT_COACCESSIBLE = fst.kNotCoAccessible */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNotAccessible); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NOT_ACCESSIBLE, __pyx_t_4) < 0) __PYX_ERR(0, 3012, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3013 * ACCESSIBLE = fst.kAccessible * NOT_ACCESSIBLE = fst.kNotAccessible * COACCESSIBLE = fst.kCoAccessible # <<<<<<<<<<<<<< * NOT_COACCESSIBLE = fst.kNotCoAccessible * STRING = fst.kString */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kCoAccessible); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_COACCESSIBLE, __pyx_t_4) < 0) __PYX_ERR(0, 3013, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3014 * NOT_ACCESSIBLE = fst.kNotAccessible * COACCESSIBLE = fst.kCoAccessible * NOT_COACCESSIBLE = fst.kNotCoAccessible # <<<<<<<<<<<<<< * STRING = fst.kString * NOT_STRING = fst.kNotString */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNotCoAccessible); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3014, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NOT_COACCESSIBLE, __pyx_t_4) < 0) __PYX_ERR(0, 3014, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3015 * COACCESSIBLE = fst.kCoAccessible * NOT_COACCESSIBLE = fst.kNotCoAccessible * STRING = fst.kString # <<<<<<<<<<<<<< * NOT_STRING = fst.kNotString * WEIGHTED_CYCLES = fst.kWeightedCycles */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kString); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3015, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_STRING, __pyx_t_4) < 0) __PYX_ERR(0, 3015, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3016 * NOT_COACCESSIBLE = fst.kNotCoAccessible * STRING = fst.kString * NOT_STRING = fst.kNotString # <<<<<<<<<<<<<< * WEIGHTED_CYCLES = fst.kWeightedCycles * UNWEIGHTED_CYCLES = fst.kUnweightedCycles */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNotString); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3016, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NOT_STRING, __pyx_t_4) < 0) __PYX_ERR(0, 3016, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3017 * STRING = fst.kString * NOT_STRING = fst.kNotString * WEIGHTED_CYCLES = fst.kWeightedCycles # <<<<<<<<<<<<<< * UNWEIGHTED_CYCLES = fst.kUnweightedCycles * # TODO(wolfsonkin): Figure out how to keep the composite properties (all the */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kWeightedCycles); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3017, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_WEIGHTED_CYCLES, __pyx_t_4) < 0) __PYX_ERR(0, 3017, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3018 * NOT_STRING = fst.kNotString * WEIGHTED_CYCLES = fst.kWeightedCycles * UNWEIGHTED_CYCLES = fst.kUnweightedCycles # <<<<<<<<<<<<<< * # TODO(wolfsonkin): Figure out how to keep the composite properties (all the * # below properties) out of the `repr`, but still available as an attribute on */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kUnweightedCycles); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_UNWEIGHTED_CYCLES, __pyx_t_4) < 0) __PYX_ERR(0, 3018, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3022 * # below properties) out of the `repr`, but still available as an attribute on * # the class. I think this could be done with `property`. * NULL_PROPERTIES = fst.kNullProperties # <<<<<<<<<<<<<< * COPY_PROPERTIES = fst.kCopyProperties * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNullProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3022, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NULL_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3022, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3023 * # the class. I think this could be done with `property`. * NULL_PROPERTIES = fst.kNullProperties * COPY_PROPERTIES = fst.kCopyProperties # <<<<<<<<<<<<<< * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kCopyProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3023, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_COPY_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3023, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3024 * NULL_PROPERTIES = fst.kNullProperties * COPY_PROPERTIES = fst.kCopyProperties * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties # <<<<<<<<<<<<<< * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties * SET_START_PROPERTIES = fst.kSetStartProperties */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kIntrinsicProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3024, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_INTRINSIC_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3024, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3025 * COPY_PROPERTIES = fst.kCopyProperties * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties # <<<<<<<<<<<<<< * SET_START_PROPERTIES = fst.kSetStartProperties * SET_FINAL_PROPERTIES = fst.kSetFinalProperties */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kExtrinsicProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_EXTRINSIC_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3025, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3026 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kSetStartProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3026, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_SET_START_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3026, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3027 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kSetFinalProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3027, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_SET_FINAL_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3027, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3028 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kAddStateProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3028, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ADD_STATE_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3028, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3029 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kAddArcProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3029, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ADD_ARC_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3029, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3030 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kSetArcProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3030, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_SET_ARC_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3030, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3031 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kDeleteStatesProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3031, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_DELETE_STATE_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3031, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3032 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kDeleteArcsProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3032, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_DELETE_ARC_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3032, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3033 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kStateSortProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_STATE_SORT_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3033, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3034 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kArcSortProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3034, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ARC_SORT_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3034, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3035 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kILabelInvariantProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3035, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_I_LABEL_INVARIANT_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3035, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3036 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kOLabelInvariantProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3036, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_O_LABEL_INVARIANT_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3036, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3037 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kWeightInvariantProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3037, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_WEIGHT_INVARIANT_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3037, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3038 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kAddSuperFinalProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3038, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_ADD_SUPERFINAL_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3038, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3039 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kRmSuperFinalProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3039, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_RM_SUPERFINAL_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3039, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3040 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kBinaryProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3040, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_BINARY_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3040, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3041 * 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_4 = __Pyx_PyInt_From_uint64_t(fst::kTrinaryProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3041, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_TRINARY_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3041, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3042 * BINARY_PROPERTIES = fst.kBinaryProperties * TRINARY_PROPERTIES = fst.kTrinaryProperties * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties # <<<<<<<<<<<<<< * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties * FST_PROPERTIES = fst.kFstProperties */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kPosTrinaryProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3042, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_POS_TRINARY_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3042, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3043 * TRINARY_PROPERTIES = fst.kTrinaryProperties * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties # <<<<<<<<<<<<<< * FST_PROPERTIES = fst.kFstProperties * */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kNegTrinaryProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3043, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_NEG_TRINARY_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3043, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":3044 * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties * FST_PROPERTIES = fst.kFstProperties # <<<<<<<<<<<<<< * * for name, member in FstProperties.__members__.items(): */ __pyx_t_4 = __Pyx_PyInt_From_uint64_t(fst::kFstProperties); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3044, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_FST_PROPERTIES, __pyx_t_4) < 0) __PYX_ERR(0, 3044, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pywrapfst.pyx":2983 * ## FST properties. * * class FstProperties(enum.Flag): # <<<<<<<<<<<<<< * EXPANDED = fst.kExpanded * MUTABLE = fst.kMutable */ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstProperties, __pyx_t_2, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2983, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstProperties, __pyx_t_4) < 0) __PYX_ERR(0, 2983, __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":3046 * FST_PROPERTIES = fst.kFstProperties * * for name, member in FstProperties.__members__.items(): # <<<<<<<<<<<<<< * globals()[name] = member * */ __pyx_t_5 = 0; __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_FstProperties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_members); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_3 == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); __PYX_ERR(0, 3046, __pyx_L1_error) } __pyx_t_1 = __Pyx_dict_iterator(__pyx_t_3, 0, __pyx_n_s_items, (&__pyx_t_6), (&__pyx_t_7)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = __pyx_t_1; __pyx_t_1 = 0; while (1) { __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_6, &__pyx_t_5, &__pyx_t_1, &__pyx_t_3, NULL, __pyx_t_7); if (unlikely(__pyx_t_8 == 0)) break; if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 3046, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_name_2, __pyx_t_1) < 0) __PYX_ERR(0, 3046, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_member, __pyx_t_3) < 0) __PYX_ERR(0, 3046, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pywrapfst.pyx":3047 * * for name, member in FstProperties.__members__.items(): * globals()[name] = member # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_member); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_Globals(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 3047, __pyx_L1_error) } __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_t_4, __pyx_t_3) < 0)) __PYX_ERR(0, 3047, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __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; /* "pywrapfst.pyx":3053 * * * ARC_I_LABEL_VALUE = fst.kArcILabelValue # <<<<<<<<<<<<<< * ARC_O_LABEL_VALUE = fst.kArcOLabelValue * ARC_WEIGHT_VALUE = fst.kArcWeightValue */ __pyx_t_2 = __Pyx_PyInt_From_uint8_t(fst::kArcILabelValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3053, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_I_LABEL_VALUE, __pyx_t_2) < 0) __PYX_ERR(0, 3053, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3054 * * 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_2 = __Pyx_PyInt_From_uint8_t(fst::kArcOLabelValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3054, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_O_LABEL_VALUE, __pyx_t_2) < 0) __PYX_ERR(0, 3054, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3055 * 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_2 = __Pyx_PyInt_From_uint8_t(fst::kArcWeightValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3055, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_WEIGHT_VALUE, __pyx_t_2) < 0) __PYX_ERR(0, 3055, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3056 * 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_2 = __Pyx_PyInt_From_uint8_t(fst::kArcNextStateValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3056, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_NEXT_STATE_VALUE, __pyx_t_2) < 0) __PYX_ERR(0, 3056, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3057 * 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_2 = __Pyx_PyInt_From_uint8_t(fst::kArcNoCache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3057, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_NO_CACHE, __pyx_t_2) < 0) __PYX_ERR(0, 3057, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3058 * ARC_NEXT_STATE_VALUE = fst.kArcNextStateValue * ARC_NO_CACHE = fst.kArcNoCache * ARC_VALUE_FLAGS = fst.kArcValueFlags # <<<<<<<<<<<<<< * ARC_FLAGS = fst.kArcFlags * */ __pyx_t_2 = __Pyx_PyInt_From_uint8_t(fst::kArcValueFlags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3058, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_VALUE_FLAGS, __pyx_t_2) < 0) __PYX_ERR(0, 3058, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3059 * ARC_NO_CACHE = fst.kArcNoCache * ARC_VALUE_FLAGS = fst.kArcValueFlags * ARC_FLAGS = fst.kArcFlags # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyInt_From_uint8_t(fst::kArcFlags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3059, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_FLAGS, __pyx_t_2) < 0) __PYX_ERR(0, 3059, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3065 * * * ENCODE_LABELS = fst.kEncodeLabels # <<<<<<<<<<<<<< * ENCODE_WEIGHTS = fst.kEncodeWeights * ENCODE_FLAGS = fst.kEncodeFlags */ __pyx_t_2 = __Pyx_PyInt_From_uint8_t(fst::kEncodeLabels); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3065, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODE_LABELS, __pyx_t_2) < 0) __PYX_ERR(0, 3065, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3066 * * ENCODE_LABELS = fst.kEncodeLabels * ENCODE_WEIGHTS = fst.kEncodeWeights # <<<<<<<<<<<<<< * ENCODE_FLAGS = fst.kEncodeFlags * */ __pyx_t_2 = __Pyx_PyInt_From_uint8_t(fst::kEncodeWeights); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3066, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODE_WEIGHTS, __pyx_t_2) < 0) __PYX_ERR(0, 3066, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3067 * ENCODE_LABELS = fst.kEncodeLabels * ENCODE_WEIGHTS = fst.kEncodeWeights * ENCODE_FLAGS = fst.kEncodeFlags # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyInt_From_uint8_t(fst::kEncodeFlags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3067, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENCODE_FLAGS, __pyx_t_2) < 0) __PYX_ERR(0, 3067, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":3439 * * cdef Fst _map(Fst ifst, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * map_type="identity", * double power=1., */ __pyx_k__32 = fst::kDelta; /* "pywrapfst.pyx":3455 * * cpdef Fst arcmap(Fst ifst, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * map_type="identity", * double power=1., */ __pyx_k__33 = fst::kDelta; /* "pywrapfst.pyx":3454 * * * cpdef Fst arcmap(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * map_type="identity", */ __pyx_k__33 = fst::kDelta; /* "pywrapfst.pyx":3564 * * cpdef MutableFst determinize(Fst ifst, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * det_type="functional", * int64 nstate=fst.kNoStateId, */ __pyx_k__34 = fst::kShortestDelta; /* "pywrapfst.pyx":3566 * float delta=fst.kShortestDelta, * det_type="functional", * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * int64 subsequential_label=0, * weight=None, */ __pyx_k__35 = fst::kNoStateId; /* "pywrapfst.pyx":3564 * * cpdef MutableFst determinize(Fst ifst, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * det_type="functional", * int64 nstate=fst.kNoStateId, */ __pyx_k__34 = fst::kShortestDelta; /* "pywrapfst.pyx":3566 * float delta=fst.kShortestDelta, * det_type="functional", * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * int64 subsequential_label=0, * weight=None, */ __pyx_k__35 = fst::kNoStateId; /* "pywrapfst.pyx":3663 * * cpdef MutableFst disambiguate(Fst ifst, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * int64 subsequential_label=0, */ __pyx_k__36 = fst::kDelta; /* "pywrapfst.pyx":3664 * cpdef MutableFst disambiguate(Fst ifst, * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * int64 subsequential_label=0, * weight=None): */ __pyx_k__37 = fst::kNoStateId; /* "pywrapfst.pyx":3663 * * cpdef MutableFst disambiguate(Fst ifst, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * int64 subsequential_label=0, */ __pyx_k__36 = fst::kDelta; /* "pywrapfst.pyx":3664 * cpdef MutableFst disambiguate(Fst ifst, * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * int64 subsequential_label=0, * weight=None): */ __pyx_k__37 = fst::kNoStateId; /* "pywrapfst.pyx":3734 * * * cpdef bool equal(Fst ifst1, Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< * """ * equal(ifst1, ifst2, delta=0.0009765625) */ __pyx_k__38 = fst::kDelta; __pyx_k__38 = fst::kDelta; /* "pywrapfst.pyx":3755 * * * cpdef bool equivalent(Fst ifst1, Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< * """ * equivalent(ifst1, ifst2, delta=0.0009765625) */ __pyx_k__39 = fst::kDelta; __pyx_k__39 = fst::kDelta; /* "pywrapfst.pyx":3811 * * * cpdef bool isomorphic(Fst ifst1, Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<< * """ * isomorphic(ifst1, ifst2, delta=0.0009765625) */ __pyx_k__40 = fst::kDelta; __pyx_k__40 = fst::kDelta; /* "pywrapfst.pyx":3836 * * cpdef MutableFst prune(Fst ifst, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * weight=None): */ __pyx_k__41 = fst::kDelta; /* "pywrapfst.pyx":3837 * cpdef MutableFst prune(Fst ifst, * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * weight=None): * """ */ __pyx_k__42 = fst::kNoStateId; /* "pywrapfst.pyx":3836 * * cpdef MutableFst prune(Fst ifst, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * weight=None): */ __pyx_k__41 = fst::kDelta; /* "pywrapfst.pyx":3837 * cpdef MutableFst prune(Fst ifst, * float delta=fst.kDelta, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * weight=None): * """ */ __pyx_k__42 = fst::kNoStateId; /* "pywrapfst.pyx":3868 * * cpdef MutableFst push(Fst ifst, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * bool push_weights=False, * bool push_labels=False, */ __pyx_k__43 = fst::kDelta; /* "pywrapfst.pyx":3867 * * * cpdef MutableFst push(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kDelta, * bool push_weights=False, */ __pyx_k__43 = fst::kDelta; /* "pywrapfst.pyx":3926 * Fst ifst2, * int32 npath=1, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * select="uniform", * int32 max_length=INT32_MAX, */ __pyx_k__44 = fst::kDelta; /* "pywrapfst.pyx":3928 * float delta=fst.kDelta, * select="uniform", * int32 max_length=INT32_MAX, # <<<<<<<<<<<<<< * uint64 seed=0) except *: * """ */ __pyx_k__45 = INT32_MAX; /* "pywrapfst.pyx":3926 * Fst ifst2, * int32 npath=1, * float delta=fst.kDelta, # <<<<<<<<<<<<<< * select="uniform", * int32 max_length=INT32_MAX, */ __pyx_k__44 = fst::kDelta; /* "pywrapfst.pyx":3928 * float delta=fst.kDelta, * select="uniform", * int32 max_length=INT32_MAX, # <<<<<<<<<<<<<< * uint64 seed=0) except *: * """ */ __pyx_k__45 = INT32_MAX; /* "pywrapfst.pyx":3978 * int32 npath=1, * select="uniform", * int32 max_length=INT32_MAX, # <<<<<<<<<<<<<< * bool weighted=False, * bool remove_total_weight=False, */ __pyx_k__46 = INT32_MAX; /* "pywrapfst.pyx":3975 * * * cpdef MutableFst randgen(Fst ifst, # <<<<<<<<<<<<<< * int32 npath=1, * select="uniform", */ __pyx_k__46 = INT32_MAX; /* "pywrapfst.pyx":4117 * cdef void _shortestdistance(Fst ifst, * vector[fst.WeightClass] *distance, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * queue_type="auto", */ __pyx_k__47 = fst::kShortestDelta; /* "pywrapfst.pyx":4118 * vector[fst.WeightClass] *distance, * float delta=fst.kShortestDelta, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * queue_type="auto", * bool reverse=False) except *: */ __pyx_k__48 = fst::kNoStateId; /* "pywrapfst.pyx":4136 * * def shortestdistance(Fst ifst, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * int64 nstate=fst.kNoStateId, * queue_type="auto", */ __pyx_k__49 = fst::kShortestDelta; /* "pywrapfst.pyx":4137 * def shortestdistance(Fst ifst, * float delta=fst.kShortestDelta, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * queue_type="auto", * bool reverse=False): */ __pyx_k__50 = fst::kNoStateId; /* "pywrapfst.pyx":4135 * * * def shortestdistance(Fst ifst, # <<<<<<<<<<<<<< * float delta=fst.kShortestDelta, * int64 nstate=fst.kNoStateId, */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_55shortestdistance, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_shortestdistance, __pyx_t_2) < 0) __PYX_ERR(0, 4135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pywrapfst.pyx":4173 * * cpdef MutableFst shortestpath(Fst ifst, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * int32 nshortest=1, * int64 nstate=fst.kNoStateId, */ __pyx_k__51 = fst::kShortestDelta; /* "pywrapfst.pyx":4175 * float delta=fst.kShortestDelta, * int32 nshortest=1, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * queue_type="auto", * bool unique=False, */ __pyx_k__52 = fst::kNoStateId; /* "pywrapfst.pyx":4173 * * cpdef MutableFst shortestpath(Fst ifst, * float delta=fst.kShortestDelta, # <<<<<<<<<<<<<< * int32 nshortest=1, * int64 nstate=fst.kNoStateId, */ __pyx_k__51 = fst::kShortestDelta; /* "pywrapfst.pyx":4175 * float delta=fst.kShortestDelta, * int32 nshortest=1, * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<< * queue_type="auto", * bool unique=False, */ __pyx_k__52 = fst::kNoStateId; /* "pywrapfst.pyx":4440 * * @classmethod * def open(cls, *sources): # <<<<<<<<<<<<<< * """ * FarReader.open(*sources) */ __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_9pywrapfst_FarReader, __pyx_n_s_open); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "pywrapfst.pyx":4439 * return f"<{self.far_type()} FarReader at 0x{id(self):x}>" * * @classmethod # <<<<<<<<<<<<<< * def open(cls, *sources): * """ */ __pyx_t_3 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_FarReader->tp_dict, __pyx_n_s_open, __pyx_t_3) < 0) __PYX_ERR(0, 4440, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_FarReader); /* "pywrapfst.pyx":4599 * * @classmethod * def create(cls, source, arc_type="standard", far_type="default"): # <<<<<<<<<<<<<< * """ * FarWriter. */ __Pyx_GetNameInClass(__pyx_t_3, (PyObject *)__pyx_ptype_9pywrapfst_FarWriter, __pyx_n_s_create); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "pywrapfst.pyx":4598 * return f"<{self.far_type()} FarWriter at 0x{id(self):x}>" * * @classmethod # <<<<<<<<<<<<<< * def create(cls, source, arc_type="standard", far_type="default"): * """ */ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_FarWriter->tp_dict, __pyx_n_s_create, __pyx_t_2) < 0) __PYX_ERR(0, 4599, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; PyType_Modified(__pyx_ptype_9pywrapfst_FarWriter); /* "pywrapfst.pyx":4690 * * # Masks fst_error_fatal in-module. * fst.FLAGS_fst_error_fatal = False # <<<<<<<<<<<<<< * */ FLAGS_fst_error_fatal = 0; /* "pywrapfst.pyx":1 * #cython: c_string_encoding=utf8, c_string_type=unicode, language_level=3, 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_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test_2, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 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); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init pywrapfst", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } 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(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #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); } #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; } /* PyObjectFormatAndDecref */ static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { if (unlikely(!s)) return NULL; if (likely(PyUnicode_CheckExact(s))) return s; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(s))) { PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict"); Py_DECREF(s); return result; } #endif return __Pyx_PyObject_FormatAndDecref(s, f); } static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { PyObject *result = PyObject_Format(s, f); Py_DECREF(s); return result; } /* JoinPyUnicode */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, CYTHON_UNUSED Py_UCS4 max_char) { #if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS PyObject *result_uval; int result_ukind; Py_ssize_t i, char_pos; void *result_udata; #if CYTHON_PEP393_ENABLED result_uval = PyUnicode_New(result_ulength, max_char); if (unlikely(!result_uval)) return NULL; result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; result_udata = PyUnicode_DATA(result_uval); #else result_uval = PyUnicode_FromUnicode(NULL, result_ulength); if (unlikely(!result_uval)) return NULL; result_ukind = sizeof(Py_UNICODE); result_udata = PyUnicode_AS_UNICODE(result_uval); #endif char_pos = 0; for (i=0; i < value_count; i++) { int ukind; Py_ssize_t ulength; void *udata; PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); if (unlikely(__Pyx_PyUnicode_READY(uval))) goto bad; ulength = __Pyx_PyUnicode_GET_LENGTH(uval); if (unlikely(!ulength)) continue; if (unlikely(char_pos + ulength < 0)) goto overflow; ukind = __Pyx_PyUnicode_KIND(uval); udata = __Pyx_PyUnicode_DATA(uval); if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { memcpy((char *)result_udata + char_pos * result_ukind, udata, (size_t) (ulength * result_ukind)); } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); #else Py_ssize_t j; for (j=0; j < ulength; j++) { Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); } #endif } char_pos += ulength; } return result_uval; overflow: PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); bad: Py_DECREF(result_uval); return NULL; #else result_ulength++; value_count++; return PyUnicode_Join(__pyx_empty_unicode, value_tuple); #endif } /* 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 | METH_STACKLESS))); 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)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL 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 = __Pyx_PyFrame_GetLocalsplus(f); 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, Py_ssize_t 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, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)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 /* 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 /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* PyObjectFormat */ #if CYTHON_USE_UNICODE_WRITER static PyObject* __Pyx_PyObject_Format(PyObject* obj, PyObject* format_spec) { int ret; _PyUnicodeWriter writer; if (likely(PyFloat_CheckExact(obj))) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x03040000 _PyUnicodeWriter_Init(&writer, 0); #else _PyUnicodeWriter_Init(&writer); #endif ret = _PyFloat_FormatAdvancedWriter( &writer, obj, format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); } else if (likely(PyLong_CheckExact(obj))) { #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x03040000 _PyUnicodeWriter_Init(&writer, 0); #else _PyUnicodeWriter_Init(&writer); #endif ret = _PyLong_FormatAdvancedWriter( &writer, obj, format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); } else { return PyObject_Format(obj, format_spec); } if (unlikely(ret == -1)) { _PyUnicodeWriter_Dealloc(&writer); return NULL; } return _PyUnicodeWriter_Finish(&writer); } #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_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 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(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 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(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_CyFunction_Check(func))) #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; } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->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 CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->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 CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->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; } /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* SwapException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->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 *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* 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; } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* 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; } /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* 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 __PYX_GOOD; #else if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; #endif #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_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 __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_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_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_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 ((1) && (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, (PyObject *)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; } /* 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 #if PY_MAJOR_VERSION == 2 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); } #else PyTypeObject *methoddescr_type = &PyMethodDescr_Type; #endif 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 { return PyClassMethod_New(method); } } /* GetNameInClass */ static PyObject *__Pyx_GetGlobalNameAfterAttributeLookup(PyObject *name) { PyObject *result; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); __Pyx_GetModuleGlobalNameUncached(result, name); return result; } static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) { PyObject *result; result = __Pyx_PyObject_GetAttrStr(nmspace, name); if (!result) { result = __Pyx_GetGlobalNameAfterAttributeLookup(name); } return result; } /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (descr != NULL) { *method = descr; return 0; } PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(name)); #endif return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod0 */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method = NULL, *result = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_CallOneArg(method, obj); Py_DECREF(method); return result; } if (unlikely(!method)) goto bad; result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } /* RaiseNoneIterError */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } /* UnpackTupleError */ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else if (PyTuple_GET_SIZE(t) < index) { __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { __Pyx_RaiseTooManyValuesError(index); } } /* UnpackTuple2 */ static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { PyObject *value1 = NULL, *value2 = NULL; #if CYTHON_COMPILING_IN_PYPY value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } *pvalue1 = value1; *pvalue2 = value2; return 0; #if CYTHON_COMPILING_IN_PYPY bad: Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; #endif } static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = Py_TYPE(iter)->tp_iternext; value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #elif PY_MAJOR_VERSION >= 3 static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* Globals */ static PyObject* __Pyx_Globals(void) { Py_ssize_t i; PyObject *names; PyObject *globals = __pyx_d; Py_INCREF(globals); names = PyObject_Dir(__pyx_m); if (!names) goto bad; for (i = PyList_GET_SIZE(names)-1; i >= 0; i--) { #if CYTHON_COMPILING_IN_PYPY PyObject* name = PySequence_ITEM(names, i); if (!name) goto bad; #else PyObject* name = PyList_GET_ITEM(names, i); #endif if (!PyDict_Contains(globals, name)) { PyObject* value = __Pyx_GetAttr(__pyx_m, name); if (!value) { #if CYTHON_COMPILING_IN_PYPY Py_DECREF(name); #endif goto bad; } if (PyDict_SetItem(globals, name, value) < 0) { #if CYTHON_COMPILING_IN_PYPY Py_DECREF(name); #endif Py_DECREF(value); goto bad; } } #if CYTHON_COMPILING_IN_PYPY Py_DECREF(name); #endif } Py_DECREF(names); return globals; bad: Py_XDECREF(names); Py_XDECREF(globals); return NULL; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*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 (use_cline == Py_False || (use_cline != Py_True && 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) ((int) 0 - (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_int64_t(int64_t value) { const int64_t neg_one = (int64_t) ((int64_t) 0 - (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_uint64_t(uint64_t value) { const uint64_t neg_one = (uint64_t) ((uint64_t) 0 - (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_uint8_t(uint8_t value) { const uint8_t neg_one = (uint8_t) ((uint8_t) 0 - (uint8_t) 1), const_zero = (uint8_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint8_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint8_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(uint8_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint8_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(uint8_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (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); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) { const int32_t neg_one = (int32_t) ((int32_t) 0 - (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) ((size_t) 0 - (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) ((int64_t) 0 - (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 int32_t __Pyx_PyInt_As_int32_t(PyObject *x) { const int32_t neg_one = (int32_t) ((int32_t) 0 - (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 uint8_t __Pyx_PyInt_As_uint8_t(PyObject *x) { const uint8_t neg_one = (uint8_t) ((uint8_t) 0 - (uint8_t) 1), const_zero = (uint8_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uint8_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint8_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint8_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 (uint8_t) 0; case 1: __PYX_VERIFY_RETURN_INT(uint8_t, digit, digits[0]) case 2: if (8 * sizeof(uint8_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint8_t) >= 2 * PyLong_SHIFT) { return (uint8_t) (((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; case 3: if (8 * sizeof(uint8_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint8_t) >= 3 * PyLong_SHIFT) { return (uint8_t) (((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0])); } } break; case 4: if (8 * sizeof(uint8_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) >= 4 * PyLong_SHIFT) { return (uint8_t) (((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_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 (uint8_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(uint8_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(uint8_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(uint8_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 (uint8_t) 0; case -1: __PYX_VERIFY_RETURN_INT(uint8_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(uint8_t, digit, +digits[0]) case -2: if (8 * sizeof(uint8_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT) { return (uint8_t) (((uint8_t)-1)*(((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 2: if (8 * sizeof(uint8_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT) { return (uint8_t) ((((((uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case -3: if (8 * sizeof(uint8_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT) { return (uint8_t) (((uint8_t)-1)*(((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 3: if (8 * sizeof(uint8_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT) { return (uint8_t) ((((((((uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case -4: if (8 * sizeof(uint8_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) - 1 > 4 * PyLong_SHIFT) { return (uint8_t) (((uint8_t)-1)*(((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; case 4: if (8 * sizeof(uint8_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint8_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(uint8_t) - 1 > 4 * PyLong_SHIFT) { return (uint8_t) ((((((((((uint8_t)digits[3]) << PyLong_SHIFT) | (uint8_t)digits[2]) << PyLong_SHIFT) | (uint8_t)digits[1]) << PyLong_SHIFT) | (uint8_t)digits[0]))); } } break; } #endif if (sizeof(uint8_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(uint8_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(uint8_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(uint8_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 uint8_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 (uint8_t) -1; } } else { uint8_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (uint8_t) -1; val = __Pyx_PyInt_As_uint8_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint8_t"); return (uint8_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint8_t"); return (uint8_t) -1; } /* CIntFromPy */ static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) { const uint64_t neg_one = (uint64_t) ((uint64_t) 0 - (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 long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (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) ((int) 0 - (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 int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; itp_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; } /* PyObjectCallMethod1 */ static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); Py_DECREF(method); return result; } static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { PyObject *method = NULL, *result; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_Call2Args(method, obj, arg); Py_DECREF(method); return result; } if (unlikely(!method)) return NULL; return __Pyx__PyObject_CallMethod1(method, arg); } /* CoroutineBase */ #include #include #define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) { PyObject *et, *ev, *tb; PyObject *value = NULL; __Pyx_ErrFetch(&et, &ev, &tb); if (!et) { Py_XDECREF(tb); Py_XDECREF(ev); Py_INCREF(Py_None); *pvalue = Py_None; return 0; } if (likely(et == PyExc_StopIteration)) { if (!ev) { Py_INCREF(Py_None); value = Py_None; } #if PY_VERSION_HEX >= 0x030300A0 else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); Py_DECREF(ev); } #endif else if (unlikely(PyTuple_Check(ev))) { if (PyTuple_GET_SIZE(ev) >= 1) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS value = PyTuple_GET_ITEM(ev, 0); Py_INCREF(value); #else value = PySequence_ITEM(ev, 0); #endif } else { Py_INCREF(Py_None); value = Py_None; } Py_DECREF(ev); } else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { value = ev; } if (likely(value)) { Py_XDECREF(tb); Py_DECREF(et); *pvalue = value; return 0; } } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { __Pyx_ErrRestore(et, ev, tb); return -1; } PyErr_NormalizeException(&et, &ev, &tb); if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { __Pyx_ErrRestore(et, ev, tb); return -1; } Py_XDECREF(tb); Py_DECREF(et); #if PY_VERSION_HEX >= 0x030300A0 value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); Py_DECREF(ev); #else { PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); Py_DECREF(ev); if (likely(args)) { value = PySequence_GetItem(args, 0); Py_DECREF(args); } if (unlikely(!value)) { __Pyx_ErrRestore(NULL, NULL, NULL); Py_INCREF(Py_None); value = Py_None; } } #endif *pvalue = value; return 0; } static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { PyObject *t, *v, *tb; t = exc_state->exc_type; v = exc_state->exc_value; tb = exc_state->exc_traceback; exc_state->exc_type = NULL; exc_state->exc_value = NULL; exc_state->exc_traceback = NULL; Py_XDECREF(t); Py_XDECREF(v); Py_XDECREF(tb); } #define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) { const char *msg; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { msg = "coroutine already executing"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { msg = "async generator already executing"; #endif } else { msg = "generator already executing"; } PyErr_SetString(PyExc_ValueError, msg); } #define __Pyx_Coroutine_NotStartedError(gen) (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL) static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) { const char *msg; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(gen)) { msg = "can't send non-None value to a just-started coroutine"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(gen)) { msg = "can't send non-None value to a just-started async generator"; #endif } else { msg = "can't send non-None value to a just-started generator"; } PyErr_SetString(PyExc_TypeError, msg); } #define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing) (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL) static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, PyObject *value, CYTHON_UNUSED int closing) { #ifdef __Pyx_Coroutine_USED if (!closing && __Pyx_Coroutine_Check(gen)) { PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); } else #endif if (value) { #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); else #endif PyErr_SetNone(PyExc_StopIteration); } } static PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, int closing) { __Pyx_PyThreadState_declare PyThreadState *tstate; __Pyx_ExcInfoStruct *exc_state; PyObject *retval; assert(!self->is_running); if (unlikely(self->resume_label == 0)) { if (unlikely(value && value != Py_None)) { return __Pyx_Coroutine_NotStartedError((PyObject*)self); } } if (unlikely(self->resume_label == -1)) { return __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign tstate = __pyx_tstate; #else tstate = __Pyx_PyThreadState_Current; #endif exc_state = &self->gi_exc_state; if (exc_state->exc_type) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON #else if (exc_state->exc_traceback) { PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback; PyFrameObject *f = tb->tb_frame; Py_XINCREF(tstate->frame); assert(f->f_back == NULL); f->f_back = tstate->frame; } #endif } #if CYTHON_USE_EXC_INFO_STACK exc_state->previous_item = tstate->exc_info; tstate->exc_info = exc_state; #else if (exc_state->exc_type) { __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } else { __Pyx_Coroutine_ExceptionClear(exc_state); __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } #endif self->is_running = 1; retval = self->body((PyObject *) self, tstate, value); self->is_running = 0; #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; tstate->exc_info = exc_state->previous_item; exc_state->previous_item = NULL; __Pyx_Coroutine_ResetFrameBackpointer(exc_state); #endif return retval; } static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { PyObject *exc_tb = exc_state->exc_traceback; if (likely(exc_tb)) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON #else PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; Py_CLEAR(f->f_back); #endif } } static CYTHON_INLINE PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) { if (unlikely(!retval)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (!__Pyx_PyErr_Occurred()) { PyObject *exc = PyExc_StopIteration; #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) exc = __Pyx_PyExc_StopAsyncIteration; #endif __Pyx_PyErr_SetNone(exc); } } return retval; } static CYTHON_INLINE PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { PyObject *ret; PyObject *val = NULL; __Pyx_Coroutine_Undelegate(gen); __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); ret = __Pyx_Coroutine_SendEx(gen, val, 0); Py_XDECREF(val); return ret; } static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { PyObject *retval; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; PyObject *yf = gen->yieldfrom; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { PyObject *ret; gen->is_running = 1; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { ret = __Pyx_async_gen_asend_send(yf, value); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyGen_CheckExact(yf)) { ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03050000 && defined(PyCoro_CheckExact) && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyCoro_CheckExact(yf)) { ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif { if (value == Py_None) ret = Py_TYPE(yf)->tp_iternext(yf); else ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); } gen->is_running = 0; if (likely(ret)) { return ret; } retval = __Pyx_Coroutine_FinishDelegation(gen); } else { retval = __Pyx_Coroutine_SendEx(gen, value, 0); } return __Pyx_Coroutine_MethodReturn(self, retval); } static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { PyObject *retval = NULL; int err = 0; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { retval = __Pyx_Coroutine_Close(yf); if (!retval) return -1; } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { retval = __Pyx_Coroutine_Close(yf); if (!retval) return -1; } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { retval = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf, NULL); if (!retval) return -1; } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { retval = __Pyx_async_gen_asend_close(yf, NULL); } else if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { retval = __Pyx_async_gen_athrow_close(yf, NULL); } else #endif { PyObject *meth; gen->is_running = 1; meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); if (unlikely(!meth)) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_WriteUnraisable(yf); } PyErr_Clear(); } else { retval = PyObject_CallFunction(meth, NULL); Py_DECREF(meth); if (!retval) err = -1; } gen->is_running = 0; } Py_XDECREF(retval); return err; } static PyObject *__Pyx_Generator_Next(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; PyObject *yf = gen->yieldfrom; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { PyObject *ret; gen->is_running = 1; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Generator_Next(yf); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyGen_CheckExact(yf)) { ret = _PyGen_Send((PyGenObject*)yf, NULL); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif ret = Py_TYPE(yf)->tp_iternext(yf); gen->is_running = 0; if (likely(ret)) { return ret; } return __Pyx_Coroutine_FinishDelegation(gen); } return __Pyx_Coroutine_SendEx(gen, Py_None, 0); } static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) { return __Pyx_Coroutine_Close(self); } static PyObject *__Pyx_Coroutine_Close(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject *retval, *raised_exception; PyObject *yf = gen->yieldfrom; int err = 0; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { Py_INCREF(yf); err = __Pyx_Coroutine_CloseIter(gen, yf); __Pyx_Coroutine_Undelegate(gen); Py_DECREF(yf); } if (err == 0) PyErr_SetNone(PyExc_GeneratorExit); retval = __Pyx_Coroutine_SendEx(gen, NULL, 1); if (unlikely(retval)) { const char *msg; Py_DECREF(retval); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(self)) { msg = "coroutine ignored GeneratorExit"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(self)) { #if PY_VERSION_HEX < 0x03060000 msg = "async generator ignored GeneratorExit - might require Python 3.6+ finalisation (PEP 525)"; #else msg = "async generator ignored GeneratorExit"; #endif #endif } else { msg = "generator ignored GeneratorExit"; } PyErr_SetString(PyExc_RuntimeError, msg); return NULL; } raised_exception = PyErr_Occurred(); if (likely(!raised_exception || __Pyx_PyErr_GivenExceptionMatches2(raised_exception, PyExc_GeneratorExit, PyExc_StopIteration))) { if (raised_exception) PyErr_Clear(); Py_INCREF(Py_None); return Py_None; } return NULL; } static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, PyObject *args, int close_on_genexit) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject *yf = gen->yieldfrom; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { PyObject *ret; Py_INCREF(yf); if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { int err = __Pyx_Coroutine_CloseIter(gen, yf); Py_DECREF(yf); __Pyx_Coroutine_Undelegate(gen); if (err < 0) return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); goto throw_here; } gen->is_running = 1; if (0 #ifdef __Pyx_Generator_USED || __Pyx_Generator_CheckExact(yf) #endif #ifdef __Pyx_Coroutine_USED || __Pyx_Coroutine_Check(yf) #endif ) { ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); #ifdef __Pyx_Coroutine_USED } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); #endif } else { PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); if (unlikely(!meth)) { Py_DECREF(yf); if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { gen->is_running = 0; return NULL; } PyErr_Clear(); __Pyx_Coroutine_Undelegate(gen); gen->is_running = 0; goto throw_here; } if (likely(args)) { ret = PyObject_CallObject(meth, args); } else { ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL); } Py_DECREF(meth); } gen->is_running = 0; Py_DECREF(yf); if (!ret) { ret = __Pyx_Coroutine_FinishDelegation(gen); } return __Pyx_Coroutine_MethodReturn(self, ret); } throw_here: __Pyx_Raise(typ, val, tb, NULL); return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); } static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { PyObject *typ; PyObject *val = NULL; PyObject *tb = NULL; if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) return NULL; return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); } static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { Py_VISIT(exc_state->exc_type); Py_VISIT(exc_state->exc_value); Py_VISIT(exc_state->exc_traceback); return 0; } static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { Py_VISIT(gen->closure); Py_VISIT(gen->classobj); Py_VISIT(gen->yieldfrom); return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); } static int __Pyx_Coroutine_clear(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; Py_CLEAR(gen->closure); Py_CLEAR(gen->classobj); Py_CLEAR(gen->yieldfrom); __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); } #endif Py_CLEAR(gen->gi_code); Py_CLEAR(gen->gi_name); Py_CLEAR(gen->gi_qualname); Py_CLEAR(gen->gi_modulename); return 0; } static void __Pyx_Coroutine_dealloc(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject_GC_UnTrack(gen); if (gen->gi_weakreflist != NULL) PyObject_ClearWeakRefs(self); if (gen->resume_label >= 0) { PyObject_GC_Track(self); #if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE if (PyObject_CallFinalizerFromDealloc(self)) #else Py_TYPE(gen)->tp_del(self); if (self->ob_refcnt > 0) #endif { return; } PyObject_GC_UnTrack(self); } #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { /* We have to handle this case for asynchronous generators right here, because this code has to be between UNTRACK and GC_Del. */ Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); } #endif __Pyx_Coroutine_clear(self); PyObject_GC_Del(gen); } static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; __Pyx_PyThreadState_declare if (gen->resume_label < 0) { return; } #if !CYTHON_USE_TP_FINALIZE assert(self->ob_refcnt == 0); self->ob_refcnt = 1; #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; PyObject *finalizer = agen->ag_finalizer; if (finalizer && !agen->ag_closed) { PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); if (unlikely(!res)) { PyErr_WriteUnraisable(self); } else { Py_DECREF(res); } __Pyx_ErrRestore(error_type, error_value, error_traceback); return; } } #endif if (unlikely(gen->resume_label == 0 && !error_value)) { #ifdef __Pyx_Coroutine_USED #ifdef __Pyx_Generator_USED if (!__Pyx_Generator_CheckExact(self)) #endif { PyObject_GC_UnTrack(self); #if PY_MAJOR_VERSION >= 3 || defined(PyErr_WarnFormat) if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) PyErr_WriteUnraisable(self); #else {PyObject *msg; char *cmsg; #if CYTHON_COMPILING_IN_PYPY msg = NULL; cmsg = (char*) "coroutine was never awaited"; #else char *cname; PyObject *qualname; qualname = gen->gi_qualname; cname = PyString_AS_STRING(qualname); msg = PyString_FromFormat("coroutine '%.50s' was never awaited", cname); if (unlikely(!msg)) { PyErr_Clear(); cmsg = (char*) "coroutine was never awaited"; } else { cmsg = PyString_AS_STRING(msg); } #endif if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0)) PyErr_WriteUnraisable(self); Py_XDECREF(msg);} #endif PyObject_GC_Track(self); } #endif } else { PyObject *res = __Pyx_Coroutine_Close(self); if (unlikely(!res)) { if (PyErr_Occurred()) PyErr_WriteUnraisable(self); } else { Py_DECREF(res); } } __Pyx_ErrRestore(error_type, error_value, error_traceback); #if !CYTHON_USE_TP_FINALIZE assert(self->ob_refcnt > 0); if (--self->ob_refcnt == 0) { return; } { Py_ssize_t refcnt = self->ob_refcnt; _Py_NewReference(self); self->ob_refcnt = refcnt; } #if CYTHON_COMPILING_IN_CPYTHON assert(PyType_IS_GC(self->ob_type) && _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); _Py_DEC_REFTOTAL; #endif #ifdef COUNT_ALLOCS --Py_TYPE(self)->tp_frees; --Py_TYPE(self)->tp_allocs; #endif #endif } static PyObject * __Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) { PyObject *name = self->gi_name; if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int __Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) { 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 = self->gi_name; Py_INCREF(value); self->gi_name = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) { PyObject *name = self->gi_qualname; if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int __Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) { 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 = self->gi_qualname; Py_INCREF(value); self->gi_qualname = value; Py_XDECREF(tmp); return 0; } static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); if (unlikely(!gen)) return NULL; return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); } static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { gen->body = body; gen->closure = closure; Py_XINCREF(closure); gen->is_running = 0; gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; gen->gi_exc_state.exc_type = NULL; gen->gi_exc_state.exc_value = NULL; gen->gi_exc_state.exc_traceback = NULL; #if CYTHON_USE_EXC_INFO_STACK gen->gi_exc_state.previous_item = NULL; #endif gen->gi_weakreflist = NULL; Py_XINCREF(qualname); gen->gi_qualname = qualname; Py_XINCREF(name); gen->gi_name = name; Py_XINCREF(module_name); gen->gi_modulename = module_name; Py_XINCREF(code); gen->gi_code = code; PyObject_GC_Track(gen); return gen; } /* PatchModuleWithCoroutine */ static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) int result; PyObject *globals, *result_obj; globals = PyDict_New(); if (unlikely(!globals)) goto ignore; result = PyDict_SetItemString(globals, "_cython_coroutine_type", #ifdef __Pyx_Coroutine_USED (PyObject*)__pyx_CoroutineType); #else Py_None); #endif if (unlikely(result < 0)) goto ignore; result = PyDict_SetItemString(globals, "_cython_generator_type", #ifdef __Pyx_Generator_USED (PyObject*)__pyx_GeneratorType); #else Py_None); #endif if (unlikely(result < 0)) goto ignore; if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; result_obj = PyRun_String(py_code, Py_file_input, globals, globals); if (unlikely(!result_obj)) goto ignore; Py_DECREF(result_obj); Py_DECREF(globals); return module; ignore: Py_XDECREF(globals); PyErr_WriteUnraisable(module); if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { Py_DECREF(module); module = NULL; } #else py_code++; #endif return module; } /* PatchGeneratorABC */ #ifndef CYTHON_REGISTER_ABCS #define CYTHON_REGISTER_ABCS 1 #endif #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) static PyObject* __Pyx_patch_abc_module(PyObject *module); static PyObject* __Pyx_patch_abc_module(PyObject *module) { module = __Pyx_Coroutine_patch_module( module, "" "if _cython_generator_type is not None:\n" " try: Generator = _module.Generator\n" " except AttributeError: pass\n" " else: Generator.register(_cython_generator_type)\n" "if _cython_coroutine_type is not None:\n" " try: Coroutine = _module.Coroutine\n" " except AttributeError: pass\n" " else: Coroutine.register(_cython_coroutine_type)\n" ); return module; } #endif static int __Pyx_patch_abc(void) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) static int abc_patched = 0; if (CYTHON_REGISTER_ABCS && !abc_patched) { PyObject *module; module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections"); if (!module) { PyErr_WriteUnraisable(NULL); if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, ((PY_MAJOR_VERSION >= 3) ? "Cython module failed to register with collections.abc module" : "Cython module failed to register with collections module"), 1) < 0)) { return -1; } } else { module = __Pyx_patch_abc_module(module); abc_patched = 1; if (unlikely(!module)) return -1; Py_DECREF(module); } module = PyImport_ImportModule("backports_abc"); if (module) { module = __Pyx_patch_abc_module(module); Py_XDECREF(module); } if (!module) { PyErr_Clear(); } } #else if ((0)) __Pyx_Coroutine_patch_module(NULL, NULL); #endif return 0; } /* Generator */ static PyMethodDef __pyx_Generator_methods[] = { {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, {0, 0, 0, 0} }; static PyMemberDef __pyx_Generator_memberlist[] = { {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, {(char*) "gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Generator_getsets[] = { {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, (char*) PyDoc_STR("name of the generator"), 0}, {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, (char*) PyDoc_STR("qualified name of the generator"), 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_GeneratorType_type = { PyVarObject_HEAD_INIT(0, 0) "generator", sizeof(__pyx_CoroutineObject), 0, (destructor) __Pyx_Coroutine_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, 0, (traverseproc) __Pyx_Coroutine_traverse, 0, 0, offsetof(__pyx_CoroutineObject, gi_weakreflist), 0, (iternextfunc) __Pyx_Generator_Next, __pyx_Generator_methods, __pyx_Generator_memberlist, __pyx_Generator_getsets, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if CYTHON_USE_TP_FINALIZE 0, #else __Pyx_Coroutine_del, #endif 0, #if CYTHON_USE_TP_FINALIZE __Pyx_Coroutine_del, #elif PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif }; static int __pyx_Generator_init(void) { __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); if (unlikely(!__pyx_GeneratorType)) { return -1; } return 0; } /* 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) return -1; ++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 CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } 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(b); } #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_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ openfst-1.7.9/src/extensions/python/pywrapfst.pxd000066400000000000000000000362621421600557100223030ustar00rootroot00000000000000#cython: language_level=3 # See www.openfst.org for extensive documentation on this weighted # finite-state transducer library. from libcpp cimport bool from libcpp.memory cimport shared_ptr from libcpp.memory cimport unique_ptr from libcpp.string cimport string from libcpp.utility cimport pair from libcpp.vector cimport vector from cintegral_types cimport int32 from cintegral_types cimport int64 from cintegral_types cimport uint8 from cintegral_types cimport uint64 from cios cimport ostream from cios cimport stringstream cimport cpywrapfst as fst # Exportable helper functions. cdef string tostring(data) except * cdef string weight_tostring(data) except * cdef string path_tostring(data) 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) cpdef bool member(self) cdef Weight _zero(weight_type) cdef Weight _one(weight_type) cdef Weight _no_weight(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 ctypedef const fst.SymbolTable * const_SymbolTable_ptr cdef class SymbolTableView(object): cdef const fst.SymbolTable *_raw(self) cdef void _raise_nonexistent(self) except * cdef const fst.SymbolTable *_raw_ptr_or_raise(self) except * cpdef int64 available_key(self) except * cpdef bytes checksum(self) cpdef SymbolTable copy(self) cpdef int64 get_nth_key(self, ssize_t pos) except * cpdef bytes labeled_checksum(self) cpdef bool member(self, key) except * cpdef string name(self) except * cpdef size_t num_symbols(self) except * cpdef void write(self, source) except * cpdef void write_text(self, source) except * cpdef bytes write_to_string(self) cdef class _EncodeMapperSymbolTableView(SymbolTableView): # Indicates whether this view is of an input or output SymbolTable cdef bool _input_side cdef shared_ptr[fst.EncodeMapperClass] _mapper cdef class _FstSymbolTableView(SymbolTableView): # Indicates whether this view is of an input or output SymbolTable cdef bool _input_side cdef shared_ptr[fst.FstClass] _fst cdef class _MutableSymbolTable(SymbolTableView): cdef fst.SymbolTable *_mutable_raw(self) cdef fst.SymbolTable *_mutable_raw_ptr_or_raise(self) except * cpdef int64 add_symbol(self, symbol, int64 key=?) except * cpdef void add_table(self, SymbolTableView syms) except * cpdef void set_name(self, new_name) except * cdef class _MutableFstSymbolTableView(_MutableSymbolTable): # Indicates whether this view is of an input or output SymbolTable cdef bool _input_side cdef shared_ptr[fst.MutableFstClass] _mfst cdef class SymbolTable(_MutableSymbolTable): cdef unique_ptr[fst.SymbolTable] _smart_table cdef _EncodeMapperSymbolTableView _init_EncodeMapperSymbolTableView( shared_ptr[fst.EncodeMapperClass] encoder, bool input_side) cdef _FstSymbolTableView _init_FstSymbolTableView(shared_ptr[fst.FstClass] ifst, bool input_side) cdef _MutableFstSymbolTableView _init_MutableFstSymbolTableView( shared_ptr[fst.MutableFstClass] ifst, bool input_side) cdef SymbolTable _init_SymbolTable(unique_ptr[fst.SymbolTable] table) cpdef SymbolTable _read_SymbolTable_from_string(string state) cdef class _SymbolTableIterator(object): cdef SymbolTableView _table cdef unique_ptr[fst.SymbolTableIterator] _siter # EncodeMapper. ctypedef fst.EncodeMapperClass * EncodeMapperClass_ptr cdef class EncodeMapper(object): cdef shared_ptr[fst.EncodeMapperClass] _mapper cpdef string arc_type(self) cpdef string weight_type(self) cpdef uint8 flags(self) cpdef void write(self, source) except * cpdef bytes write_to_string(self) cpdef _EncodeMapperSymbolTableView input_symbols(self) cpdef _EncodeMapperSymbolTableView output_symbols(self) cdef void _set_input_symbols(self, SymbolTableView syms) except * cdef void _set_output_symbols(self, SymbolTableView syms) except * cdef EncodeMapper _init_EncodeMapper(EncodeMapperClass_ptr mapper) cpdef EncodeMapper _read_EncodeMapper_from_string(string state) # Fst. ctypedef fst.FstClass * FstClass_ptr ctypedef const fst.FstClass * const_FstClass_ptr ctypedef fst.MutableFstClass * MutableFstClass_ptr ctypedef fst.VectorFstClass * VectorFstClass_ptr cdef class Fst(object): cdef shared_ptr[fst.FstClass] _fst # Google-only... @staticmethod cdef string _server_render_svg(const string &) # ...Google-only. @staticmethod cdef string _local_render_svg(const string &) cpdef string arc_type(self) cpdef ArcIterator arcs(self, int64 state) cpdef Fst copy(self) cpdef void draw(self, source, SymbolTableView isymbols=?, SymbolTableView osymbols=?, SymbolTableView 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=?) except * cpdef Weight final(self, int64 state) cpdef string fst_type(self) cpdef _FstSymbolTableView 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 _FstSymbolTableView output_symbols(self) cpdef string print(self, SymbolTableView isymbols=?, SymbolTableView osymbols=?, SymbolTableView ssymbols=?, bool acceptor=?, bool show_weight_one=?, missing_sym=?) except * cpdef int64 start(self) cpdef StateIterator states(self) cpdef bool verify(self) cpdef string weight_type(self) cpdef void write(self, source) except * cpdef bytes 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) cpdef void add_states(self, size_t) cdef void _arcsort(self, sort_type=?) except * cdef void _closure(self, bool closure_plus=?) cdef void _concat(self, Fst fst2) except * cdef void _connect(self) 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) 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, project_type) except * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except * cdef void _push(self, float delta=?, bool remove_total_weight=?, bool to_final=?) cdef void _relabel_pairs(self, ipairs=?, opairs=?) except * cdef void _relabel_tables(self, SymbolTableView old_isymbols=?, SymbolTableView new_isymbols=?, unknown_isymbol=?, bool attach_new_isymbols=?, SymbolTableView old_osymbols=?, SymbolTableView 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) 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_start(self, int64 state) except * cdef void _set_input_symbols(self, SymbolTableView syms) except * cdef void _set_output_symbols(self, SymbolTableView syms) except * cdef void _topsort(self) cdef class VectorFst(MutableFst): pass # Construction helpers. cdef Fst _init_Fst(FstClass_ptr tfst) cdef MutableFst _init_MutableFst(MutableFstClass_ptr tfst) cdef Fst _init_XFst(FstClass_ptr tfst) cpdef Fst _read_Fst(source) cpdef Fst _read_Fst_from_string(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 uint8 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, uint8 flags, uint8 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 uint8 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, uint8 flags, uint8 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=?, select=?, int32 max_length=?, uint64 seed=?) except * cpdef MutableFst randgen(Fst ifst, int32 npath=?, select=?, int32 max_length=?, bool remove_total_weight=?, bool weighted=?, uint64 seed=?) 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 void _shortestdistance(Fst ifst, vector[fst.WeightClass] *, 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) 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) openfst-1.7.9/src/extensions/python/pywrapfst.pyx000066400000000000000000004332161421600557100223300ustar00rootroot00000000000000#cython: c_string_encoding=utf8, c_string_type=unicode, language_level=3, 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 # * SymbolTableView, _EncodeMapperSymbolTableView, _FstSymbolTableView, # _MutableFstSymbolTableView, SymbolTable, and helpers # * _SymbolTableIterator # * EncodeMapper # * Fst, MutableFst, and VectorFst # * 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. # # 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. # # 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. ## Imports. # 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 # C imports. from libc.stdint cimport INT32_MAX from libc.stdint cimport SIZE_MAX from libc.time cimport time # C++ imports. from libcpp cimport bool from libcpp.cast cimport static_cast from libcpp.memory cimport static_pointer_cast # Missing C++ imports. from cios cimport ofstream from cmemory cimport WrapUnique from cutility cimport move # Python imports. import logging import enum import numbers import os import subprocess import sys # Google-only... # This only works, and is only needed, inside of Colab. try: from colabtools import frontend from colabtools import stubby from google3.visualization.graphviz_server.proto import graphviz_server_pb2 except ImportError: pass # ...Google-only. ## Custom types. # These defintions only ensure that these are defined to avoid attribute errors, # but don't actually contain the type definitions. Those are in pywrapfst.pyi. import typing ArcMapType = """typing.Literal["identity", "input_epsilon", "invert", "output_epsilon", "plus", "power", "quantize", "rmweight", "superfinal", "times", "to_log", # NOTE: Both spellings of "to_std" "to_log64", "to_std", "to_standard"]""" ComposeFilter = """typing.Literal["alt_sequence", "auto", "match", "no_match", "null", "sequence", "trivial"]""" DeterminizeType = """typing.Literal["functional", "nonfunctional", "disambiguate"]""" DrawFloatFormat = """typing.Literal["e", "f", "g"]""" FarType = """typing.Literal[ "fst", "stlist", "sttable", # Google-only... "sstable", # ...Google-only. "default" ]""" ProjectType = """typing.Literal["input", "output"]""" QueueType = """typing.Literal["auto", "fifo", "lifo", "shortest", "state", "top"]""" RandArcSelection = """typing.Literal["uniform", "log_prob", "fast_log_prob"]""" ReplaceLabelType = """typing.Literal["neither", "input", "output", "both"]""" SortType = """typing.Literal["ilabel", "olabel"]""" StateMapType = """typing.Literal["arc_sum", "arc_unique", "identity"]""" WeightLike = "typing.Union[Weight, typing.Union[str, int, float]]" ## Custom exceptions. class FstError(Exception): pass class FstArgError(FstError, ValueError): pass class FstBadWeightError(FstError, ValueError): pass class FstIndexError(FstError, IndexError): pass class FstIOError(FstError, IOError): pass class FstOpError(FstError, RuntimeError): pass ## General helpers. cdef string tostring(data) except *: """Converts strings to bytestrings. This function converts Python 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. Returns: A bytestring. Raises: TypeError: Cannot encode string. This function is not visible to Python users. """ # A Python string can be implicitly cast to a C++ string. if isinstance(data, str): return data raise TypeError(f"Expected {str.__name__} but received " f"{type(data).__name__}: {data!r}") cdef string weight_tostring(data) except *: """Converts strings or numerics to bytestrings. This function converts Python 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 or type which can be converted to a Python float. Returns: A bytestring. Raise: TypeError: Cannot encode string. ValueError: Invalid literal for float. This function is not visible to Python users. """ # A Python string can be implicitly cast to a C++ string. if isinstance(data, str): return data elif isinstance(data, numbers.Number): return str(data) raise TypeError(f"Expected {str.__name__} but received " f"{type(data).__name__}: {data!r}") cdef string path_tostring(data) except *: return tostring(os.fspath(data)) cdef fst.FarType _get_far_type(const string &far_type) except *: """Matches string with the appropriate FarType enum value. Args: far_type: A string indicating the FAR type; one of: "fst", "stlist", "sttable", "sstable", "default". Returns: A FarType enum value. Raises: FstArgError: Unknown FAR type. This function is not visible to Python users. """ cdef fst.FarType _far_type if not fst.GetFarType(far_type, addr(_far_type)): raise FstArgError(f"Unknown FAR type: {far_type!r}") return _far_type 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", "no_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 if not fst.GetComposeFilter(compose_filter, addr(_compose_filter)): raise FstArgError(f"Unknown compose filter type: {compose_filter!r}") return _compose_filter 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 if not fst.GetDeterminizeType(det_type, addr(_det_type)): raise FstArgError(f"Unknown determinization type: {det_type!r}") return _det_type cdef fst.ProjectType _get_project_type(const string &project_type) except *: """Matches string with the appropriate ProjectType enum value. Args: project_type: A string matching a known projection type; one of: "input", "output". Returns: A ProjectType enum value. Raises: FstArgError: Unknown projection type. This function is not visible to Python users. """ cdef fst.ProjectType _project_type if not fst.GetProjectType(project_type, addr(_project_type)): raise FstArgError(f"Unknown projection type: {project_type!r}") return _project_type 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 if not fst.GetQueueType(queue_type, addr(_queue_type)): raise FstArgError(f"Unknown queue type: {queue_type!r}") return _queue_type 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 if not fst.GetRandArcSelection(select, addr(_select)): raise FstArgError(f"Unknown random arc selection type: {select!r}") return _select 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 if not fst.GetReplaceLabelType(replace_label_type, epsilon_on_replace, addr(_replace_label_type)): raise FstArgError(f"Unknown replace label type: {replace_label_type!r}") return _replace_label_type ## Weight and helpers. cdef class Weight: """ 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 f"<{self.type()} Weight {self.to_string()} at 0x{id(self):x}>" 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 not self.member(): raise FstBadWeightError("Invalid weight") cpdef Weight copy(self): """ copy(self) Returns a copy of the Weight. """ cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset(new fst.WeightClass(deref(self._weight))) return _weight # 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 no_weight(cls, weight_type): """ Weight.no_weight(weight_type) Constructs a non-member weight in the semiring. """ return _no_weight(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() cpdef bool member(self): return self._weight.get().Member() cdef Weight _plus(Weight lhs, Weight rhs): cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), deref(rhs._weight)))) return _weight 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 _weight = _plus(lhs, rhs) _weight._check_weight() return _weight cdef Weight _times(Weight lhs, Weight rhs): cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), deref(rhs._weight)))) return _weight 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 _weight = _times(lhs, rhs) _weight._check_weight() return _weight cdef Weight _divide(Weight lhs, Weight rhs): cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), deref(rhs._weight)))) return _weight 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 _weight = _divide(lhs, rhs) _weight._check_weight() return _weight cdef Weight _power(Weight w, size_t n): cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) return _weight 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 _weight = _power(w, n) _weight._check_weight() return _weight 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 _weight if weight is None: _weight = fst.WeightClass.Zero(weight_type) elif isinstance(weight, Weight): _weight = deref( ( weight)._weight.get()) else: _weight = fst.WeightClass(weight_type, weight_tostring(weight)) if not _weight.Member(): raise FstBadWeightError(weight_tostring(weight)) return _weight 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 _weight if weight is None: _weight = fst.WeightClass.One(weight_type) elif isinstance(weight, Weight): _weight = deref( ( weight)._weight.get()) else: _weight = fst.WeightClass(weight_type, weight_tostring(weight)) if not _weight.Member(): raise FstBadWeightError(weight_tostring(weight)) return _weight cdef Weight _zero(weight_type): cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset( new fst.WeightClass(fst.WeightClass.Zero(tostring(weight_type)))) if _weight._weight.get().Type() == b"none": raise FstArgError("Weight type not found") return _weight cdef Weight _one(weight_type): cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset( new fst.WeightClass(fst.WeightClass.One(tostring(weight_type)))) if _weight._weight.get().Type() == b"none": raise FstArgError("Weight type not found") return _weight cdef Weight _no_weight(weight_type): cdef Weight _weight = Weight.__new__(Weight) _weight._weight.reset( new fst.WeightClass(fst.WeightClass.NoWeight(tostring(weight_type)))) return _weight # SymbolTable hierarchy: # # SymbolTableView: abstract base class; has-a SymbolTable* # _EncodeMapperSymbolTableView(SymbolTableView): constant symbol table returned # by EncodeMapper.input_symbols/output_symbols # _FstSymbolTableView(SymbolTableView): constant symbol table returned by # Fst.input_symbols/output_symbols # # _MutableSymbolTable(SymbolTableView): abstract base class adding mutation # methods # _MutableFstSymbolTableView(_MutableSymbolTable): mutable symbol table # returned by MutableFst.mutable_input_symbols/mutable_output_symbols # SymbolTable(_MutableSymbolTable): adds constructor cdef class SymbolTableView: """ (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 NotImplementedError(f"Cannot construct {self.__class__.__name__}") def __iter__(self): return _SymbolTableIterator(self) # Registers the class for pickling. def __reduce__(self): return (_read_SymbolTable_from_string, (self.write_to_string(),)) # Returns a raw const pointer to SymbolTable. # Must be overridden by child classes. # Should not be directly accessed except by `_raw_ptr_or_raise()`. # All other methods should use the safer _raw_ptr_or_raise() instead. cdef const_SymbolTable_ptr _raw(self): return NULL # Raises an FstOpError for a nonexistent SymbolTable. cdef void _raise_nonexistent(self) except *: raise FstOpError("SymbolTable no longer exists") # Internal API method that should be used when a const pointer to an # fst.SymbolTable is required. cdef const_SymbolTable_ptr _raw_ptr_or_raise(self) except *: cdef const_SymbolTable_ptr _raw = self._raw() if _raw == NULL: self._raise_nonexistent() return _raw cpdef int64 available_key(self) except *: """ available_key(self) Returns an integer indicating the next available key index in the table. """ return self._raw_ptr_or_raise().AvailableKey() cpdef bytes checksum(self): """ checksum(self) Returns a bytestring indicating the label-independent MD5 checksum. """ return self._raw_ptr_or_raise().CheckSum() cpdef SymbolTable copy(self): """ copy(self) Returns a mutable copy of the SymbolTable. """ return _init_SymbolTable(WrapUnique(self._raw_ptr_or_raise().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. """ cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() try: return _raw.FindIndex(tostring(key)) except TypeError: return _raw.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._raw_ptr_or_raise().GetNthKey(pos) cpdef bytes labeled_checksum(self): """ labeled_checksum(self) Returns a bytestring indicating the label-dependent MD5 checksum. """ return self._raw_ptr_or_raise().LabeledCheckSum() cpdef bool member(self, key) except *: """ 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. """ cdef const_SymbolTable_ptr _raw = self._raw_ptr_or_raise() try: return _raw.MemberSymbol(tostring(key)) except TypeError: return _raw.MemberIndex(key) cpdef string name(self) except *: """ name(self) Returns the symbol table's name. """ return self._raw_ptr_or_raise().Name() cpdef size_t num_symbols(self) except *: """ num_symbols(self) Returns the number of symbols in the symbol table. """ return self._raw_ptr_or_raise().NumSymbols() cpdef void write(self, source) except *: """ write(self, source) Serializes symbol table to a file. This methods writes the SymbolTable to a file in binary format. Args: source: The string location of the output file. Raises: FstIOError: Write failed. """ if not self._raw_ptr_or_raise().Write(path_tostring(source)): raise FstIOError(f"Write failed: {source!r}") cpdef void write_text(self, source) except *: """ write_text(self, source) Writes symbol table to text file. This method writes the SymbolTable to a file in human-readable format. Args: source: The string location of the output file. Raises: FstIOError: Write failed. """ if not self._raw_ptr_or_raise().WriteText(path_tostring(source)): raise FstIOError(f"Write failed: {source!r}") cpdef bytes write_to_string(self): """ write_to_string(self) Serializes SymbolTable to a string. Returns: A bytestring. Raises: FstIOError: Write to string failed. """ cdef stringstream _sstrm if not self._raw_ptr_or_raise().Write(_sstrm): raise FstIOError("Write to string failed") return _sstrm.str() cdef class _EncodeMapperSymbolTableView(SymbolTableView): """ (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 (f"") cdef const_SymbolTable_ptr _raw(self): return (self._mapper.get().InputSymbols() if self._input_side else self._mapper.get().OutputSymbols()) cdef class _FstSymbolTableView(SymbolTableView): """ (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 (f"") cdef const_SymbolTable_ptr _raw(self): return (self._fst.get().InputSymbols() if self._input_side else self._fst.get().OutputSymbols()) cdef class _MutableSymbolTable(SymbolTableView): """ (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. """ cdef const_SymbolTable_ptr _raw(self): return self._mutable_raw() # Returns a mutable raw pointer to SymbolTable. # Must be overridden by child classes. # Should not be directly accessed except by `_mutable__raw_ptr_or_raise()`. # All other methods should use the safer _mutable__raw_ptr_or_raise() instead. cdef SymbolTable_ptr _mutable_raw(self): return NULL # Internal API method that should be used when a mutable pointer to an # fst.SymbolTable is required. cdef SymbolTable_ptr _mutable_raw_ptr_or_raise(self) except *: cdef SymbolTable_ptr mutable_raw = self._mutable_raw() if mutable_raw == NULL: self._raise_nonexistent() return mutable_raw cpdef int64 add_symbol(self, symbol, int64 key=fst.kNoSymbol) except *: """ 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 SymbolTable_ptr _mutable_raw = self._mutable_raw_ptr_or_raise() cdef string _symbol = tostring(symbol) if key != fst.kNoSymbol: return _mutable_raw.AddSymbol(_symbol, key) else: return _mutable_raw.AddSymbol(_symbol) cpdef void add_table(self, SymbolTableView symbols) except *: """ add_table(self, symbols) 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: symbols: A SymbolTable to be merged with the current table. """ self._mutable_raw_ptr_or_raise().AddTable( deref(symbols._raw_ptr_or_raise())) cpdef void set_name(self, new_name) except *: self._mutable_raw_ptr_or_raise().SetName(tostring(new_name)) cdef class _MutableFstSymbolTableView(_MutableSymbolTable): """ (No constructor.) Mutable SymbolTable assigned to an FST. """ def __repr__(self): return f"" cdef SymbolTable_ptr _mutable_raw(self): return (self._mfst.get().MutableInputSymbols() if self._input_side else self._mfst.get().MutableOutputSymbols()) 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 f"" def __init__(self, name=""): self._smart_table.reset(new fst.SymbolTable(tostring(name))) cdef SymbolTable_ptr _mutable_raw(self): return self._smart_table.get() @classmethod def read(cls, source): """ SymbolTable.read(source) Reads symbol table from binary file. This class method creates a new SymbolTable from a symbol table binary file. Args: source: The string location of the input binary file. Returns: A new SymbolTable instance. """ cdef unique_ptr[fst.SymbolTable] _symbols _symbols.reset(fst.SymbolTable.Read(path_tostring(source))) if _symbols.get() == NULL: raise FstIOError(f"Read failed: {source!r}") return _init_SymbolTable(move(_symbols)) @classmethod def read_text(cls, source, bool allow_negative_labels=False): """ SymbolTable.read_text(source) Reads symbol table from text file. This class method creates a new SymbolTable from a symbol table text file. Args: source: 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. """ cdef unique_ptr[fst.SymbolTableTextOptions] _opts _opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) cdef unique_ptr[fst.SymbolTable] _symbols _symbols.reset(fst.SymbolTable.ReadText(path_tostring(source), deref(_opts))) if _symbols.get() == NULL: raise FstIOError(f"Read failed: {source!r}") return _init_SymbolTable(move(_symbols)) @classmethod def read_fst(cls, source, bool input_table): """ SymbolTable.read_fst(source, 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: source: 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. """ cdef unique_ptr[fst.SymbolTable] _symbols _symbols.reset(fst.FstReadSymbols(path_tostring(source), input_table)) if _symbols.get() == NULL: raise FstIOError(f"Read from FST failed: {source!r}") return _init_SymbolTable(move(_symbols)) cdef _EncodeMapperSymbolTableView _init_EncodeMapperSymbolTableView( shared_ptr[fst.EncodeMapperClass] mapper, bool input_side): cdef _EncodeMapperSymbolTableView _symbols = ( _EncodeMapperSymbolTableView.__new__(_EncodeMapperSymbolTableView)) _symbols._mapper = move(mapper) _symbols._input_side = input_side return _symbols cdef _FstSymbolTableView _init_FstSymbolTableView(shared_ptr[fst.FstClass] ifst, bool input_side): cdef _FstSymbolTableView _symbols = ( _FstSymbolTableView.__new__(_FstSymbolTableView)) _symbols._fst = move(ifst) _symbols._input_side = input_side return _symbols cdef _MutableFstSymbolTableView _init_MutableFstSymbolTableView( shared_ptr[fst.MutableFstClass] ifst, bool input_side): cdef _MutableFstSymbolTableView _symbols = ( _MutableFstSymbolTableView.__new__(_MutableFstSymbolTableView)) _symbols._mfst = move(ifst) _symbols._input_side = input_side return _symbols cdef SymbolTable _init_SymbolTable(unique_ptr[fst.SymbolTable] symbols): cdef SymbolTable _symbols = SymbolTable.__new__(SymbolTable) _symbols._smart_table = move(symbols) return _symbols cpdef SymbolTable _read_SymbolTable_from_string(string state): cdef stringstream _sstrm _sstrm << state cdef unique_ptr[fst.SymbolTable] _symbols _symbols.reset(fst.SymbolTable.ReadStream(_sstrm, b"")) if _symbols.get() == NULL: raise FstIOError("Read from string failed") return _init_SymbolTable(move(_symbols)) # Constructive SymbolTable operations. cpdef SymbolTable compact_symbol_table(SymbolTableView symbols): """ compact_symbol_table(symbols) Constructively relabels a SymbolTable to make it a contiguous mapping. Args: symbols: Input SymbolTable. Returns: A new compacted SymbolTable. """ return _init_SymbolTable(WrapUnique(fst.CompactSymbolTable( deref(symbols._raw_ptr_or_raise())))) cpdef SymbolTable merge_symbol_table(SymbolTableView lhs, SymbolTableView 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. """ return _init_SymbolTable(WrapUnique(fst.MergeSymbolTable( deref(lhs._raw_ptr_or_raise()), deref(rhs._raw_ptr_or_raise()), NULL))) ## _SymbolTableIterator. cdef class _SymbolTableIterator: """ _SymbolTableIterator(symbols) This class is used for iterating over a symbol table. """ def __repr__(self): return f"<_SymbolTableIterator at 0x{id(self):x}>" def __init__(self, SymbolTableView symbols): self._table = symbols self._siter.reset( new fst.SymbolTableIterator(self._table._raw_ptr_or_raise().begin())) # 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._table._raw_ptr_or_raise().end() == deref(self._siter): raise StopIteration cdef int64 _label = self._siter.get().Pair().Label() cdef string _symbol = self._siter.get().Pair().Symbol() inc(deref(self._siter)) return (_label, _symbol) ## EncodeMapper. cdef class EncodeMapper: """ EncodeMapper(arc_type="standard", encode_labels=False, encode_weights=False) Arc mapper 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 mapper 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 f"" def __init__(self, arc_type="standard", bool encode_labels=False, bool encode_weights=False): cdef uint8 _flags = fst.GetEncodeFlags(encode_labels, encode_weights) self._mapper.reset( new fst.EncodeMapperClass(tostring(arc_type), _flags, fst.ENCODE)) if self._mapper.get() == NULL: raise FstOpError(f"Unknown arc type: {arc_type!r}") # Python's equivalent to operator(). def __call__(self, Arc arc): """ self(state, ilabel, olabel, weight, nextstate) Uses the mapper 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._mapper.get().__call__(deref(arc._arc))) # Registers the class for pickling. def __reduce__(self): return (_read_EncodeMapper_from_string, (self.write_to_string(),)) cpdef string arc_type(self): """ arc_type(self) Returns a string indicating the arc type. """ return self._mapper.get().ArcType() cpdef string weight_type(self): """ weight_type(self) Returns a string indicating the weight type. """ return self._mapper.get().WeightType() cpdef uint8 flags(self): """ flags(self) Returns the mapper's flags. """ return self._mapper.get().Flags() def properties(self, mask): """ properties(self, mask) Provides property bits. This method provides user access to the properties of the mapper. Args: mask: The property mask to be compared to the mapper's properties. Returns: A 64-bit bitmask representing the requested properties. """ return FstProperties(self._mapper.get().Properties(mask.value)) @classmethod def read(cls, source): """ EncodeMapper.read(source) Reads encode mapper from binary file. This class method creates a new EncodeMapper from an encode mapper binary file. Args: source: The string location of the input binary file. Returns: A new EncodeMapper instance. """ cdef unique_ptr[fst.EncodeMapperClass] _mapper _mapper.reset(fst.EncodeMapperClass.Read(path_tostring(source))) if _mapper.get() == NULL: raise FstIOError(f"Read failed: {source!r}") return _init_EncodeMapper(_mapper.release()) @staticmethod def read_from_string(state): """ read_from_string(state) Reads an EncodeMapper from a serialized string. Args: state: A string containing the serialized EncodeMapper. Returns: An EncodeMapper object. Raises: FstIOError: Read failed. """ return _read_EncodeMapper_from_string(state) cpdef void write(self, source) except *: """ write(self, source) Serializes mapper to a file. This method writes the mapper to a file in a binary format. Args: source: The string location of the output file. Raises: FstIOError: Write failed. """ if not self._mapper.get().Write(path_tostring(source)): raise FstIOError(f"Write failed: {source!r}") cpdef bytes write_to_string(self): """ write_to_string(self) Serializes mapper to a string. Returns: A bytestring. Raises: FstIOError: Write to string failed. """ cdef stringstream _sstrm if not self._mapper.get().WriteStream(_sstrm, b""): raise FstIOError("Write to string failed") return _sstrm.str() cpdef _EncodeMapperSymbolTableView input_symbols(self): """ input_symbols(self) Returns the mapper's input symbol table, or None if none is present. """ if self._mapper.get().InputSymbols() == NULL: return return _init_EncodeMapperSymbolTableView(self._mapper, input_side=True) cpdef _EncodeMapperSymbolTableView output_symbols(self): """ output_symbols(self) Returns the mapper's output symbol table, or None if none is present. """ if self._mapper.get().OutputSymbols() == NULL: return return _init_EncodeMapperSymbolTableView(self._mapper, input_side=False) cdef void _set_input_symbols(self, SymbolTableView symbols) except *: if symbols is None: self._mapper.get().SetInputSymbols(NULL) return self._mapper.get().SetInputSymbols(symbols._raw_ptr_or_raise()) def set_input_symbols(self, SymbolTableView symbols): """ set_input_symbols(self, symbols) Sets the mapper's input symbol table. Passing None as a value will delete the input symbol table. Args: symbols: A SymbolTable. Returns: self. """ self._set_input_symbols(symbols) return self cdef void _set_output_symbols(self, SymbolTableView symbols) except *: if symbols is None: self._mapper.get().SetOutputSymbols(NULL) return self._mapper.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) def set_output_symbols(self, SymbolTableView symbols): """ set_output_symbols(self, symbols) Sets the mapper's output symbol table. Passing None as a value will delete the output symbol table. Args: symbols: A SymbolTable. Returns: self. """ self._set_output_symbols(symbols) return self cdef EncodeMapper _init_EncodeMapper(EncodeMapperClass_ptr mapper): cdef EncodeMapper result = EncodeMapper.__new__(EncodeMapper) result._mapper.reset(mapper) return result cpdef EncodeMapper _read_EncodeMapper_from_string(string state): cdef stringstream _sstrm _sstrm << state cdef unique_ptr[fst.EncodeMapperClass] _mapper _mapper.reset(fst.EncodeMapperClass.ReadStream(_sstrm, b"")) if _mapper.get() == NULL: raise FstIOError("Read from string failed") return _init_EncodeMapper(_mapper.release()) ## Fst and MutableFst. # # Fst hierarchy: # # Fst: base class; has-a FstClass*. # MutableFst(Fst): adds mutable methods. # VectorFst(MutableFst): add constructor. cdef class Fst: """ (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. # Google-only... @staticmethod cdef string _server_render_svg(const string &dot): # Creates request. request = graphviz_server_pb2.RenderRequest() request.graph.dot = dot request.return_bytes = True # Makes request and returns SVG rendering. response = stubby.Call("blade:graphviz-server", "RenderServer.Render", request) return response.rendered_graph.rendered_bytes # ...Google-only. @staticmethod cdef string _local_render_svg(const string &dot): proc = subprocess.Popen(("dot", "-Tsvg"), stdin=subprocess.PIPE, stdout=subprocess.PIPE) return proc.communicate(dot.encode("utf8"))[0] 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. """ cdef stringstream _sstrm cdef bool acceptor = (self._fst.get().Properties(fst.kAcceptor, True) == fst.kAcceptor) fst.Draw(deref(self._fst), self._fst.get().InputSymbols(), self._fst.get().OutputSymbols(), NULL, acceptor, b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, b"g", False, _sstrm, b"") # Google-only... try: return Fst._server_render_svg(_sstrm.str()) except Exception as e: frontend.DisplayToast("GraphViz server request failed: " + str(e)) logging.error("Graphviz server requested failed: %s", e) # ...Google-only. try: return Fst._local_render_svg(_sstrm.str()) except Exception as e: logging.error("Dot rendering failed: %s", e) def __init__(self): raise NotImplementedError(f"Cannot construct {self._class__.__name__}") # Registers the class for pickling; must be repeated in any subclass which # can't be derived by _init_XFst. def __reduce__(self): return (_read_Fst_from_string, (self.write_to_string(),)) def __repr__(self): return f"<{self.fst_type()} Fst at 0x{id(self):x}>" def __str__(self): return self.print() 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. """ 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, source, SymbolTableView isymbols=None, SymbolTableView osymbols=None, SymbolTableView ssymbols=None, bool acceptor=False, title="", 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="g", bool show_weight_one=False) except *: """ draw(self, source, 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: source: 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? """ cdef string _source = path_tostring(source) cdef unique_ptr[ostream] _fstrm _fstrm.reset(new ofstream(_source)) cdef const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() if isymbols is not None: _isymbols = isymbols._raw_ptr_or_raise() cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() if osymbols is not None: _osymbols = osymbols._raw_ptr_or_raise() cdef const fst.SymbolTable *_ssymbols = NULL if ssymbols is not None: _ssymbols = ssymbols._raw_ptr_or_raise() fst.Draw(deref(self._fst), _isymbols, _osymbols, _ssymbols, acceptor, tostring(title), width, height, portrait, vertical, ranksep, nodesep, fontsize, precision, tostring(float_format), show_weight_one, deref(_fstrm), _source) 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))) if not _weight.member(): raise FstIndexError("State index out of range") return _weight cpdef string fst_type(self): """ fst_type(self) Returns a string indicating the FST type. """ return self._fst.get().FstType() cpdef _FstSymbolTableView input_symbols(self): """ input_symbols(self) Returns the FST's input symbol table, or None if none is present. """ if self._fst.get().InputSymbols() == NULL: return return _init_FstSymbolTableView(self._fst, input_side=True) 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. """ 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. """ 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. """ cdef size_t _result = self._fst.get().NumOutputEpsilons(state) if _result == SIZE_MAX: raise FstIndexError("State index out of range") return _result cpdef _FstSymbolTableView output_symbols(self): """ output_symbols(self) Returns the FST's output symbol table, or None if none is present. """ if self._fst.get().OutputSymbols() == NULL: return return _init_FstSymbolTableView(self._fst, input_side=False) cpdef string print(self, SymbolTableView isymbols=None, SymbolTableView osymbols=None, SymbolTableView ssymbols=None, bool acceptor=False, bool show_weight_one=False, missing_sym="") except *: """ print(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 const fst.SymbolTable *_isymbols = self._fst.get().InputSymbols() if isymbols is not None: _isymbols = isymbols._raw_ptr_or_raise() cdef const fst.SymbolTable *_osymbols = self._fst.get().OutputSymbols() if osymbols is not None: _osymbols = osymbols._raw_ptr_or_raise() cdef const fst.SymbolTable *_ssymbols = NULL if ssymbols is not None: _ssymbols = ssymbols._raw_ptr_or_raise() cdef stringstream _sstrm fst.Print(deref(self._fst), _sstrm, b"", _isymbols, _osymbols, _ssymbols, acceptor, show_weight_one, tostring(missing_sym)) return _sstrm.str() def properties(self, 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 FstProperties representing a 64-bit bitmask of the requested properties. """ return FstProperties(self._fst.get().Properties(mask.value, test)) @classmethod def read(cls, source): """ read(source) Reads an FST from a file. Args: source: The string location of the input file. Returns: An FST object. Raises: FstIOError: Read failed. """ return _read_Fst(source) @classmethod def read_from_string(cls, state): """ read_from_string(state) Reads an FST from a serialized string. Args: state: A string containing the serialized FST. Returns: An FST object. Raises: FstIOError: Read failed. """ return _read_Fst_from_string(state) 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. """ return StateIterator(self) 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, source) except *: """ write(self, source) Serializes FST to a file. This method writes the FST to a file in a binary format. Args: source: The string location of the output file. Raises: FstIOError: Write failed. """ if not self._fst.get().Write(path_tostring(source)): raise FstIOError(f"Write failed: {source!r}") cpdef bytes write_to_string(self): """ write_to_string(self) Serializes FST to a string. Returns: A bytestring. Raises: FstIOError: Write to string failed. """ cdef stringstream _sstrm if not self._fst.get().Write(_sstrm, b""): 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") 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. """ self._add_arc(state, arc) return self cpdef int64 add_state(self): """ add_state(self) Adds a new state to the FST and returns the state ID. Returns: The integer index of the new state. """ return self._mfst.get().AddState() cpdef void add_states(self, size_t n): """ add_states(self, n) Adds n new states to the FST. Args: n: The number of states to add. """ self._mfst.get().AddStates(n) cdef void _arcsort(self, sort_type="ilabel") except *: cdef fst.ArcSortType _sort_type if not fst.GetArcSortType(tostring(sort_type), addr(_sort_type)): raise FstArgError(f"Unknown sort type: {sort_type!r}") fst.ArcSort(self._mfst.get(), _sort_type) def arcsort(self, sort_type="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. """ self._arcsort(sort_type) return self cdef void _closure(self, bool closure_plus=False): fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) 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 fst2) except *: fst.Concat(self._mfst.get(), deref(fst2._fst)) self._check_mutating_imethod() def concat(self, Fst fst2): """ concat(self, fst2) 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: fst2: The second input FST. Returns: self. """ self._concat(fst2) return self cdef void _connect(self): fst.Connect(self._mfst.get()) 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 mapper) except *: fst.Decode(self._mfst.get(), deref(mapper._mapper)) self._check_mutating_imethod() def decode(self, EncodeMapper mapper): """ decode(self, mapper) Decodes encoded labels and/or weights. This operation reverses the encoding performed by `encode`. Args: mapper: An EncodeMapper object used to encode the FST. Returns: self. """ self._decode(mapper) 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. """ 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. """ self._delete_states(states) return self cdef void _encode(self, EncodeMapper mapper) except *: fst.Encode(self._mfst.get(), mapper._mapper.get()) self._check_mutating_imethod() def encode(self, EncodeMapper mapper): """ encode(self, mapper) 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: mapper: An EncodeMapper object to be used as the mapper. Returns: self. """ self._encode(mapper) return self cdef void _invert(self): fst.Invert(self._mfst.get()) 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. """ 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. """ if self._mfst.get().MutableInputSymbols() == NULL: return return _init_MutableFstSymbolTableView(self._mfst, input_side=True) def mutable_output_symbols(self): """ mutable_output_symbols(self) Returns the FST's (mutable) output symbol table, or None if none is present. """ if self._mfst.get().MutableOutputSymbols() == NULL: return return _init_MutableFstSymbolTableView(self._mfst, input_side=False) cpdef int64 num_states(self): """ num_states(self) Returns the number of states. """ return self._mfst.get().NumStates() cdef void _project(self, project_type) except *: fst.Project(self._mfst.get(), _get_project_type(tostring(project_type))) def project(self, project_type): """ project(self, project_type) 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_type: A string matching a known projection type; one of: "input", "output". Returns: self. """ self._project(project_type) 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 _weight = _get_WeightClass_or_zero(self.weight_type(), weight) fst.Prune(self._mfst.get(), _weight, 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. """ self._prune(delta, nstate, weight) return self cdef void _push(self, float delta=fst.kShortestDelta, bool remove_total_weight=False, bool to_final=False): fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, remove_total_weight) def push(self, float delta=fst.kShortestDelta, bool remove_total_weight=False, bool to_final=False): """ push(self, delta=1-e6, 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. """ self._push(delta, remove_total_weight, to_final) return self cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: cdef vector[fst.LabelPair] _ipairs cdef vector[fst.LabelPair] _opairs if ipairs: for (before, after) in ipairs: _ipairs.push_back(fst.LabelPair(before, after)) if opairs: for (before, after) in opairs: _opairs.push_back(fst.LabelPair(before, after)) if _ipairs.empty() and _opairs.empty(): raise FstArgError("No relabeling pairs specified") fst.Relabel(self._mfst.get(), _ipairs, _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. """ self._relabel_pairs(ipairs, opairs) return self cdef void _relabel_tables(self, SymbolTableView old_isymbols=None, SymbolTableView new_isymbols=None, unknown_isymbol="", bool attach_new_isymbols=True, SymbolTableView old_osymbols=None, SymbolTableView new_osymbols=None, unknown_osymbol="", bool attach_new_osymbols=True) except *: if new_isymbols is None and new_osymbols is None: raise FstArgError("No new SymbolTables specified") cdef const fst.SymbolTable *_old_isymbols = self._fst.get().InputSymbols() if old_isymbols is not None: _old_isymbols = old_isymbols._raw_ptr_or_raise() cdef const fst.SymbolTable *_old_osymbols = self._fst.get().OutputSymbols() if old_osymbols is not None: _old_osymbols = old_osymbols._raw_ptr_or_raise() cdef const fst.SymbolTable *_new_isymbols = NULL if new_isymbols is not None: _new_isymbols = new_isymbols._raw_ptr_or_raise() cdef const fst.SymbolTable *_new_osymbols = NULL if new_osymbols is not None: _new_osymbols = new_osymbols._raw_ptr_or_raise() fst.Relabel(self._mfst.get(), _old_isymbols, _new_isymbols, tostring(unknown_isymbol), attach_new_isymbols, _old_osymbols, _new_osymbols, tostring(unknown_osymbol), attach_new_osymbols) self._check_mutating_imethod() def relabel_tables(self, SymbolTableView old_isymbols=None, SymbolTableView new_isymbols=None, unknown_isymbol="", bool attach_new_isymbols=True, SymbolTableView old_osymbols=None, SymbolTableView new_osymbols=None, unknown_osymbol="", 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. """ 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. """ self._reserve_arcs(state, n) return self cdef void _reserve_states(self, int64 n): self._mfst.get().ReserveStates(n) 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. """ self._reserve_states(n) return self cdef void _reweight(self, potentials, bool to_final=False) except *: cdef string _weight_type = self.weight_type() cdef vector[fst.WeightClass] _potentials for weight in potentials: _potentials.push_back(_get_WeightClass_or_one(_weight_type, weight)) fst.Reweight(self._mfst.get(), _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="auto", bool connect=True, weight=None, int64 nstate=fst.kNoStateId, float delta=fst.kShortestDelta) except *: cdef fst.WeightClass _weight = _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, _weight, nstate, delta)) fst.RmEpsilon(self._mfst.get(), deref(_opts)) self._check_mutating_imethod() def rmepsilon(self, queue_type="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 _weight = _get_WeightClass_or_one(self.weight_type(), weight) if not self._mfst.get().SetFinal(state, _weight): 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. """ self._set_final(state, weight) return self cdef void _set_input_symbols(self, SymbolTableView symbols) except *: if symbols is None: self._mfst.get().SetInputSymbols(NULL) return self._mfst.get().SetInputSymbols(symbols._raw_ptr_or_raise()) def set_input_symbols(self, SymbolTableView symbols): """ set_input_symbols(self, symbols) Sets the input symbol table. Passing None as a value will delete the input symbol table. Args: symbols: A SymbolTable. Returns: self. """ self._set_input_symbols(symbols) return self cdef void _set_output_symbols(self, SymbolTableView symbols) except *: if symbols is None: self._mfst.get().SetOutputSymbols(NULL) return self._mfst.get().SetOutputSymbols(symbols._raw_ptr_or_raise()) def set_output_symbols(self, SymbolTableView symbols): """ set_output_symbols(self, symbols) Sets the output symbol table. Passing None as a value will delete the output symbol table. Args: symbols: A SymbolTable. Returns: self. """ self._set_output_symbols(symbols) return self def set_properties(self, props, 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._mfst.get().SetProperties(props.value, mask.value) return self cdef void _set_start(self, int64 state) except *: if not self._mfst.get().SetStart(state): raise FstIndexError("State index out of range") 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. """ self._set_start(state) return self cdef void _topsort(self): # 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") 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. """ self._topsort() return self def union(self, *fsts2): """ union(self, *fsts2) Computes the union (sum) of two or more FSTs. This operation computes the union of two or more 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: *fsts2: One or more input FSTs. Returns: self. """ cdef Fst _fst2 cdef vector[const_FstClass_ptr] _fsts2 for _fst2 in fsts2: _fsts2.push_back(_fst2._fst.get()) fst.Union(self._mfst.get(), _fsts2) self._check_mutating_imethod() return self cdef class VectorFst(MutableFst): """ VectorFst(arc_type="standard") Constructs a concrete, empty, mutable FST. Args: arc_type: A string indicating the arc type. Raises: FstOpError: Unknown arc type. """ def __init__(self, arc_type="standard"): cdef unique_ptr[fst.MutableFstClass] _tfst _tfst.reset(new fst.VectorFstClass(tostring(arc_type))) if _tfst.get().Properties(fst.kError, True) == fst.kError: raise FstOpError(f"Unknown arc type: {arc_type!r}") self._fst.reset(_tfst.release()) self._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](self._fst) # 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). # # _read_Fst reads an FST from disk, performing FST conversion if requested, and # then passes this pointer to _init_XFst. # # _read_Fst_from_string reads an FST serialization directly from a string. cdef Fst _init_Fst(FstClass_ptr tfst): if tfst.Properties(fst.kError, True) == fst.kError: 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) == fst.kError: 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) == fst.kMutable: return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) else: return _init_Fst(tfst) cpdef Fst _read_Fst(source): cdef unique_ptr[fst.FstClass] _tfst _tfst.reset(fst.FstClass.Read(path_tostring(source))) if _tfst.get() == NULL: raise FstIOError(f"Read failed: {source!r}") return _init_XFst(_tfst.release()) cpdef Fst _read_Fst_from_string(string state): cdef stringstream _sstrm _sstrm << state cdef unique_ptr[fst.FstClass] _tfst _tfst.reset(fst.FstClass.ReadStream(_sstrm, b"")) if _tfst.get() == NULL: raise FstIOError("Read from string failed") return _init_XFst(_tfst.release()) ## FST constants. NO_LABEL = fst.kNoLabel NO_STATE_ID = fst.kNoStateId NO_SYMBOL = fst.kNoSymbol ## FST properties. class FstProperties(enum.Flag): 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 # TODO(wolfsonkin): Figure out how to keep the composite properties (all the # below properties) out of the `repr`, but still available as an attribute on # the class. I think this could be done with `property`. 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 for name, member in FstProperties.__members__.items(): globals()[name] = member ## 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: """ 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 f"" def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): cdef fst.WeightClass _weight = _get_WeightClass_or_one(b"tropical", weight) self._arc.reset(new fst.ArcClass(ilabel, olabel, _weight, 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: """ ArcIterator(ifst, state) This class is used for iterating over the arcs leaving some state of an FST. """ def __repr__(self): return f"" 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 uint8 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, uint8 flags, uint8 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: """ 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 f"" 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)) # Magic method used to get a Pythonic Iterator API out of the C++ API. def __iter__(self): while not self.done(): yield self.value() self.next() 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 uint8 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, uint8 flags, uint8 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: """ StateIterator(ifst) This class is used for iterating over the states in an FST. """ def __repr__(self): return f"" 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="identity", double power=1., weight=None): cdef fst.MapType _map_type if not fst.GetMapType(tostring(map_type), addr(_map_type)): raise FstArgError(f"Unknown map type: {map_type!r}") cdef fst.WeightClass _weight if _map_type == fst.TIMES_MAPPER: _weight = _get_WeightClass_or_one(ifst.weight_type(), weight) else: _weight = _get_WeightClass_or_zero(ifst.weight_type(), weight) return _init_XFst(fst.Map(deref(ifst._fst), _map_type, delta, power, _weight)) cpdef Fst arcmap(Fst ifst, float delta=fst.kDelta, map_type="identity", double power=1., weight=None): """ arcmap(ifst, delta=0.0009765625, map_type="identity", power=1., 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. * output_epsilon: replaces all output labels with epsilon. * quantize: quantizes weights. * plus: adds a constant to all weights. * power: raises all weights to a power. * rmweight: replaces all non-Zero weights with 1. * superfinal: redirects final states to a new superfinal state. * times: right-multiplies a constant by all weights. * to_log: converts weights to the log semiring. * to_log64: converts weights to the log64 semiring. * to_std: converts weights to the tropical 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 `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. """ return _map(ifst, delta, map_type, power, weight) cpdef MutableFst compose(Fst ifst1, Fst ifst2, compose_filter="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", "no_match", "null", "sequence", "trivial". connect: Should output be trimmed? Returns: An 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.Compose(deref(ifst1._fst), deref(ifst2._fst), _tfst.get(), deref(_opts)) return _init_MutableFst(_tfst.release()) cpdef Fst convert(Fst ifst, fst_type=""): """ convert(ifst, fst_type="") 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 an empty string if no conversion is desired. Returns: The input FST converted to the desired FST type. Raises: FstOpError: Conversion failed. """ cdef string _fst_type = tostring(fst_type) cdef unique_ptr[fst.FstClass] _tfst _tfst.reset(fst.Convert(deref(ifst._fst), _fst_type)) # Script-land Convert returns a null pointer to signal failure. if _tfst.get() == NULL: raise FstOpError(f"Conversion to {fst_type!r} failed") return _init_XFst(_tfst.release()) cpdef MutableFst determinize(Fst ifst, float delta=fst.kShortestDelta, det_type="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. """ 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 _weight = _get_WeightClass_or_zero(ifst.weight_type(), weight) cdef fst.DeterminizeType _det_type if not fst.GetDeterminizeType(tostring(det_type), addr(_det_type)): raise FstArgError(f"Unknown determinization type: {det_type!r}") cdef unique_ptr[fst.DeterminizeOptions] _opts _opts.reset( new fst.DeterminizeOptions(delta, _weight, nstate, subsequential_label, _det_type, 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="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", "no_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. """ 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 _weight = _get_WeightClass_or_zero(ifst.weight_type(), weight) cdef unique_ptr[fst.DisambiguateOptions] _opts _opts.reset( new fst.DisambiguateOptions(delta, _weight, 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. """ 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. """ return fst.Equal(deref(ifst1._fst), deref(ifst2._fst), delta) cpdef bool equivalent(Fst ifst1, Fst ifst2, float delta=fst.kDelta): """ 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. """ return fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta) cpdef MutableFst intersect(Fst ifst1, Fst ifst2, compose_filter="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", "no_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. """ 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. """ cdef unique_ptr[fst.VectorFstClass] _tfst _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) cdef fst.WeightClass _weight = _get_WeightClass_or_zero(ifst.weight_type(), weight) fst.Prune(deref(ifst._fst), _tfst.get(), _weight, 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. """ cdef unique_ptr[fst.VectorFstClass] _tfst _tfst.reset(new fst.VectorFstClass(ifst.arc_type())) cdef uint8 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, select="uniform", int32 max_length=INT32_MAX, uint64 seed=0) except *: """ randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, select="uniform", max_length=2147483647, seed=0) 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. """ cdef fst.RandArcSelection _select = _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](_select, max_length, 1, False, False)) if seed == 0: seed = time(NULL) return fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), npath, deref(_opts), delta, seed) cpdef MutableFst randgen(Fst ifst, int32 npath=1, select="uniform", int32 max_length=INT32_MAX, bool weighted=False, bool remove_total_weight=False, uint64 seed=0): """ randgen(ifst, npath=1, seed=0, select="uniform", max_length=2147483647, weighted=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. """ cdef fst.RandArcSelection _select = _get_rand_arc_selection(tostring(select)) cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] _opts _opts.reset( new fst.RandGenOptions[fst.RandArcSelection](_select, 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) fst.RandGen(deref(ifst._fst), _tfst.get(), deref(_opts), seed) return _init_MutableFst(_tfst.release()) cpdef MutableFst replace(pairs, call_arc_labeling="input", return_arc_labeling="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 int64 _label cdef Fst _pfst cdef vector[fst.LabelFstClassPair] _pairs for (_label, _pfst) in pairs: _pairs.push_back(fst.LabelFstClassPair(_label, _pfst._fst.get())) cdef unique_ptr[fst.VectorFstClass] _tfst _tfst.reset(new fst.VectorFstClass(_pairs[0].second.ArcType())) 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(_pairs[0].first, _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 void _shortestdistance(Fst ifst, vector[fst.WeightClass] *distance, float delta=fst.kShortestDelta, int64 nstate=fst.kNoStateId, queue_type="auto", bool reverse=False) except *: 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, 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, deref(_opts)) def shortestdistance(Fst ifst, float delta=fst.kShortestDelta, int64 nstate=fst.kNoStateId, queue_type="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 vector[fst.WeightClass] _distance _shortestdistance(ifst, addr(_distance), delta, nstate, queue_type, reverse) return [Weight(ifst._fst.get().WeightType(), weight.ToString()) for weight in _distance] cpdef MutableFst shortestpath(Fst ifst, float delta=fst.kShortestDelta, int32 nshortest=1, int64 nstate=fst.kNoStateId, queue_type="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 _weight = _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, _weight, 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 using one of the following: * arc_sum: sums weights of identically-labeled multi-arcs. * arc_unique: deletes non-unique identically-labeled multi-arcs. * identity: maps to self. Args: ifst: The input FST. map_type: A string matching a known mapping operation; one of: "arc_sum", "arc_unique", "identity". Returns: An FST with states remapped. Raises: FstArgError: Unknown map type. """ 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: """ 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_symbols, osymbols=ascii_symbols) Once constructed, Compiler instances behave like a file handle opened for writing: # /ba+/ compiler.write("0 1 50 50") compiler.write("1 2 49 49") compiler.write("2 2 49 49") compiler.write("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, str fst_type="vector", str arc_type="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._raw_ptr_or_raise() self._osymbols = NULL if osymbols is not None: self._osymbols = osymbols._raw_ptr_or_raise() self._ssymbols = NULL if ssymbols is not None: self._ssymbols = ssymbols._raw_ptr_or_raise() 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() compiler.write("0 0 49 49") compiler.write("0") Args: expression: A string expression to add to compiler string buffer. """ cdef string _line = tostring(expression) if not _line.empty() and _line.back() != b'\n': _line.append(b'\n') deref(self._sstrm) << _line ## FarReader and FarWriter. cdef class FarReader: """ (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 NotImplementedError(f"Cannot construct {self.__class__.__name__}") def __repr__(self): return f"<{self.far_type()} FarReader at 0x{id(self):x}>" @classmethod def open(cls, *sources): """ FarReader.open(*sources) Creates a FarReader object. This class method creates a FarReader given the string location of one or more FAR files on disk. Args: *sources: The string location of one or more input FAR files. Returns: A new FarReader instance. Raises: FstIOError: Read failed. """ cdef vector[string] _sources = [path_tostring(source) for source in sources] cdef unique_ptr[fst.FarReaderClass] _tfar _tfar.reset(fst.FarReaderClass.Open(_sources)) if _tfar.get() == NULL: raise FstIOError(f"Read failed: {sources!r}") cdef FarReader reader = FarReader.__new__(FarReader) reader._reader.reset(_tfar.release()) return reader 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): """ 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): if self._reader.get().Find(tostring(key)): return self.get_fst() else: raise KeyError(key) def __next__(self): if self.done(): raise StopIteration cdef string _key = self.get_key() cdef Fst _fst = self.get_fst() self.next() return (_key, _fst) # This just registers this class as a possible iterator. def __iter__(self): return self cdef class FarWriter: """ (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 NotImplementedError(f"Cannot construct {self.__class__.__name__}") def __repr__(self): return f"<{self.far_type()} FarWriter at 0x{id(self):x}>" @classmethod def create(cls, source, arc_type="standard", far_type="default"): """ FarWriter. Creates a FarWriter object. This class method creates a FarWriter given the desired output location, arc type, and FAR type. Args: source: 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 unique_ptr[fst.FarWriterClass] _tfar _tfar.reset(fst.FarWriterClass.Create( path_tostring(source), tostring(arc_type), _get_far_type(tostring(far_type)))) if _tfar.get() == NULL: raise FstIOError(f"Open failed: {source!r}") cdef FarWriter writer = FarWriter.__new__(FarWriter) writer._writer = move(_tfar) return writer # 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: 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") 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) # Masks fst_error_fatal in-module. fst.FLAGS_fst_error_fatal = False openfst-1.7.9/src/extensions/special/000077500000000000000000000000001421600557100176155ustar00rootroot00000000000000openfst-1.7.9/src/extensions/special/Makefile.am000066400000000000000000000014221421600557100216500ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../../include -I$(srcdir)/../../bin $(ICU_CPPFLAGS) LIBS = ../../lib/libfst.la -lm $(DL_LIBS) if HAVE_BIN bin_PROGRAMS = fstspecial fstspecial_SOURCES = fstspecial.cc phi-fst.cc rho-fst.cc sigma-fst.cc fstspecial_CPPFLAGS = $(AM_CPPFLAGS) fstspecial_LDADD = ../../script/libfstscript.la 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 22:0:0 phi_fst_la_SOURCES = phi-fst.cc phi_fst_la_LDFLAGS = -avoid-version -module rho_fst_la_SOURCES = rho-fst.cc rho_fst_la_LDFLAGS = -avoid-version -module sigma_fst_la_SOURCES = sigma-fst.cc sigma_fst_la_LDFLAGS = -avoid-version -module openfst-1.7.9/src/extensions/special/Makefile.in000066400000000000000000001105761421600557100216740ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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)" "$(DESTDIR)$(libdir)" \ "$(DESTDIR)$(libfstdir)" PROGRAMS = $(bin_PROGRAMS) 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; }; \ } LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES) libfstspecial_la_LIBADD = 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_LIBADD = 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_LIBADD = 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_LIBADD = 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 $@ am__fstspecial_SOURCES_DIST = fstspecial.cc phi-fst.cc rho-fst.cc \ sigma-fst.cc @HAVE_BIN_TRUE@am_fstspecial_OBJECTS = \ @HAVE_BIN_TRUE@ fstspecial-fstspecial.$(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) @HAVE_BIN_TRUE@fstspecial_DEPENDENCIES = ../../script/libfstscript.la 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/fstspecial-fstspecial.Po \ ./$(DEPDIR)/fstspecial-phi-fst.Po \ ./$(DEPDIR)/fstspecial-rho-fst.Po \ ./$(DEPDIR)/fstspecial-sigma-fst.Po ./$(DEPDIR)/phi-fst.Plo \ ./$(DEPDIR)/rho-fst.Plo ./$(DEPDIR)/sigma-fst.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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 = ../../lib/libfst.la -lm $(DL_LIBS) LIBTOOL = @LIBTOOL@ LIPO = @LIPO@ LN_S = @LN_S@ LTLIBOBJS = @LTLIBOBJS@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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)/../../bin $(ICU_CPPFLAGS) @HAVE_BIN_TRUE@fstspecial_SOURCES = fstspecial.cc phi-fst.cc rho-fst.cc sigma-fst.cc @HAVE_BIN_TRUE@fstspecial_CPPFLAGS = $(AM_CPPFLAGS) @HAVE_BIN_TRUE@fstspecial_LDADD = ../../script/libfstscript.la 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 22:0:0 phi_fst_la_SOURCES = phi-fst.cc phi_fst_la_LDFLAGS = -avoid-version -module rho_fst_la_SOURCES = rho-fst.cc rho_fst_la_LDFLAGS = -avoid-version -module sigma_fst_la_SOURCES = sigma-fst.cc sigma_fst_la_LDFLAGS = -avoid-version -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/special/Makefile'; \ $(am__cd) $(top_srcdir) && \ $(AUTOMAKE) --foreign src/extensions/special/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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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 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) 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) distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-fstspecial.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-phi-fst.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-rho-fst.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-sigma-fst.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/phi-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rho-fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sigma-fst.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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 $@ $< fstspecial-fstspecial.o: fstspecial.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-fstspecial.o -MD -MP -MF $(DEPDIR)/fstspecial-fstspecial.Tpo -c -o fstspecial-fstspecial.o `test -f 'fstspecial.cc' || echo '$(srcdir)/'`fstspecial.cc @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-fstspecial.Tpo $(DEPDIR)/fstspecial-fstspecial.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='fstspecial.cc' object='fstspecial-fstspecial.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-fstspecial.o `test -f 'fstspecial.cc' || echo '$(srcdir)/'`fstspecial.cc fstspecial-fstspecial.obj: fstspecial.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-fstspecial.obj -MD -MP -MF $(DEPDIR)/fstspecial-fstspecial.Tpo -c -o fstspecial-fstspecial.obj `if test -f 'fstspecial.cc'; then $(CYGPATH_W) 'fstspecial.cc'; else $(CYGPATH_W) '$(srcdir)/fstspecial.cc'; fi` @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-fstspecial.Tpo $(DEPDIR)/fstspecial-fstspecial.Po @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='fstspecial.cc' object='fstspecial-fstspecial.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-fstspecial.obj `if test -f 'fstspecial.cc'; then $(CYGPATH_W) 'fstspecial.cc'; else $(CYGPATH_W) '$(srcdir)/fstspecial.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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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) $(LTLIBRARIES) install-binPROGRAMS: install-libLTLIBRARIES installdirs: for dir in "$(DESTDIR)$(bindir)" "$(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-binPROGRAMS clean-generic clean-libLTLIBRARIES \ clean-libfstLTLIBRARIES clean-libtool mostlyclean-am distclean: distclean-am -rm -f ./$(DEPDIR)/fstspecial-fstspecial.Po -rm -f ./$(DEPDIR)/fstspecial-phi-fst.Po -rm -f ./$(DEPDIR)/fstspecial-rho-fst.Po -rm -f ./$(DEPDIR)/fstspecial-sigma-fst.Po -rm -f ./$(DEPDIR)/phi-fst.Plo -rm -f ./$(DEPDIR)/rho-fst.Plo -rm -f ./$(DEPDIR)/sigma-fst.Plo -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 -f ./$(DEPDIR)/fstspecial-fstspecial.Po -rm -f ./$(DEPDIR)/fstspecial-phi-fst.Po -rm -f ./$(DEPDIR)/fstspecial-rho-fst.Po -rm -f ./$(DEPDIR)/fstspecial-sigma-fst.Po -rm -f ./$(DEPDIR)/phi-fst.Plo -rm -f ./$(DEPDIR)/rho-fst.Plo -rm -f ./$(DEPDIR)/sigma-fst.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/extensions/special/fstspecial.cc000066400000000000000000000004131421600557100222570ustar00rootroot00000000000000// Work-around to correctly build (e.g. distclean) with autotools // using files in another directory that are also built there. // See https://stackoverflow.com/questions/30379837. #include "fstconvert-main.cc" // NOLINT #include "fstconvert.cc" // NOLINT openfst-1.7.9/src/extensions/special/phi-fst.cc000066400000000000000000000021301421600557100214720ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #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"; REGISTER_FST(PhiFst, StdArc); REGISTER_FST(PhiFst, LogArc); REGISTER_FST(PhiFst, Log64Arc); REGISTER_FST(InputPhiFst, StdArc); REGISTER_FST(InputPhiFst, LogArc); REGISTER_FST(InputPhiFst, Log64Arc); REGISTER_FST(OutputPhiFst, StdArc); REGISTER_FST(OutputPhiFst, LogArc); REGISTER_FST(OutputPhiFst, Log64Arc); } // namespace fst openfst-1.7.9/src/extensions/special/rho-fst.cc000066400000000000000000000017641421600557100215160ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #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"; REGISTER_FST(RhoFst, StdArc); REGISTER_FST(RhoFst, LogArc); REGISTER_FST(RhoFst, Log64Arc); REGISTER_FST(InputRhoFst, StdArc); REGISTER_FST(InputRhoFst, LogArc); REGISTER_FST(InputRhoFst, Log64Arc); REGISTER_FST(OutputRhoFst, StdArc); REGISTER_FST(OutputRhoFst, LogArc); REGISTER_FST(OutputRhoFst, Log64Arc); } // namespace fst openfst-1.7.9/src/extensions/special/sigma-fst.cc000066400000000000000000000020331421600557100220140ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include #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"; REGISTER_FST(SigmaFst, StdArc); REGISTER_FST(SigmaFst, LogArc); REGISTER_FST(SigmaFst, Log64Arc); REGISTER_FST(InputSigmaFst, StdArc); REGISTER_FST(InputSigmaFst, LogArc); REGISTER_FST(InputSigmaFst, Log64Arc); REGISTER_FST(OutputSigmaFst, StdArc); REGISTER_FST(OutputSigmaFst, LogArc); REGISTER_FST(OutputSigmaFst, Log64Arc); } // namespace fst openfst-1.7.9/src/include/000077500000000000000000000000001421600557100154215ustar00rootroot00000000000000openfst-1.7.9/src/include/Makefile.am000066400000000000000000000150001421600557100174510ustar00rootroot00000000000000if HAVE_COMPRESS compress_include_headers = fst/extensions/compress/compress.h \ fst/extensions/compress/compressscript.h fst/extensions/compress/elias.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/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 test_include_headers = fst/test/algo_test.h fst/test/compactors.h \ fst/test/fst_test.h fst/test/rand-fst.h fst/test/weight-tester.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/expander-cache.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/power-weight-mappers.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/windows_defs.inc 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) \ $(test_include_headers) openfst-1.7.9/src/include/Makefile.in000066400000000000000000000720111421600557100174670ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__nobase_include_HEADERS_DIST) \ $(am__DIST_COMMON) 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/expander-cache.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/power-weight-mappers.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/windows_defs.inc fst/weight.h \ fst/extensions/compress/compress.h \ fst/extensions/compress/compressscript.h \ fst/extensions/compress/elias.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/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 fst/test/algo_test.h \ fst/test/compactors.h fst/test/fst_test.h fst/test/rand-fst.h \ fst/test/weight-tester.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 am__DIST_COMMON = $(srcdir)/Makefile.in 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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/compressscript.h fst/extensions/compress/elias.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/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 test_include_headers = fst/test/algo_test.h fst/test/compactors.h \ fst/test/fst_test.h fst/test/rand-fst.h fst/test/weight-tester.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/expander-cache.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/power-weight-mappers.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/windows_defs.inc 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) \ $(test_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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/include/fst/000077500000000000000000000000001421600557100162155ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/accumulator.h000066400000000000000000000723171421600557100207170ustar00rootroot00000000000000// 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(). // Sum(w, aiter, begin, end) has time complexity O(begin - end). 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. // Sum(w, aiter, begin, end) has time complexity O(begin - end). 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))); } } const WeightConvert to_log_weight_{}; const 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. // Sum(w, aiter, begin, end) has time complexity O(arc_limit_) or O(arc_period_) // depending on whether the state has more than arc_limit_ arcs // Space complexity is O(CountStates(fst) + CountArcs(fst) / arc_period_). 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_.emplace(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. Space complexity is O(gc_limit). 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)); } } } const WeightConvert to_log_weight_{}; const 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] = fst::make_unique(); 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_ = fst::make_unique>>(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_ openfst-1.7.9/src/include/fst/add-on.h000066400000000000000000000162451421600557100175400ustar00rootroot00000000000000// 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 #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) { bool have_addon1 = false; ReadType(istrm, &have_addon1); std::unique_ptr a1; if (have_addon1) a1 = fst::WrapUnique(A1::Read(istrm, opts)); bool have_addon2 = false; ReadType(istrm, &have_addon2); std::unique_ptr a2; if (have_addon2) a2 = fst::WrapUnique(A2::Read(istrm, opts)); return new AddOnPair(std::move(a1), std::move(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 FstType = FST; 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 std::string &type, std::shared_ptr t = nullptr) : 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 std::string &type, std::shared_ptr t = nullptr) : 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 std::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_ openfst-1.7.9/src/include/fst/arc-arena.h000066400000000000000000000146671421600557100202350ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Allocators for contiguous arrays of arcs. #ifndef FST_ARC_ARENA_H_ #define FST_ARC_ARENA_H_ #include #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 ©) : 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; class State { public: Weight Final() const { return final_weight_; } 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 final_weight, int32 niepsilons, int32 noepsilons, int32 narcs, const Arc *arcs) : final_weight_(std::move(final_weight)), niepsilons_(niepsilons), noepsilons_(noepsilons), narcs_(narcs), arcs_(arcs) {} Weight final_weight_; 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_weight_, 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_(Weight::Zero()), narcs_(0) {} void SetFinal(Weight weight) { final_weight_ = 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_weight_; size_t narcs_; }; std::unordered_map cache_; std::deque states_; ArcArena arena_; }; } // namespace fst #endif // FST_ARC_ARENA_H_ openfst-1.7.9/src/include/fst/arc-map.h000066400000000000000000001162331421600557100177140ustar00rootroot00000000000000// 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 #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 apply to each arc separately // and do not change the number of arcs (except 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 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); } 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); } final_arc.nextstate = superfinal; fst->AddArc(state, std::move(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; 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); } 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) + (final_action != MAP_NO_SUPERFINAL ? 1 : 0)); 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); } final_arc.nextstate = superfinal; ofst->AddArc(s, std::move(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::EmplaceArc; using CacheImpl::HasArcs; using CacheImpl::HasFinal; using CacheImpl::HasStart; using CacheImpl::PushArc; 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); } 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); PushArc(s, (*mapper_)(aarc)); } // 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, std::move(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()) { EmplaceArc(s, 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 = ArcMapFstOptions()) : ImplToFst(std::make_shared(fst, mapper, opts)) {} ArcMapFst(const Fst &fst, C *mapper, const ArcMapFstOptions &opts = ArcMapFstOptions()) : ImplToFst(std::make_shared(fst, mapper, opts)) {} // 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); } // Constructs and returns an ArcMapFst. This allows constructing ArcMapFsts // without specifying all the types. The template argument is typically // not specified, so a call looks like: MakeArcMapFst(fst, Mapper(...)). template ArcMapFst MakeArcMapFst(const Fst &fst, const ArcMapper &mapper) { return ArcMapFst(fst, mapper); } // Constructs and returns an ArcMapFst. As above, but using the // ArcMapFst(..., ArcMapper *) constructor. template ArcMapFst MakeArcMapFst(const Fst &fst, ArcMapper *mapper) { return ArcMapFst(fst, mapper); } // Utility Mappers. // Mapper that returns its input. template class IdentityArcMapper { public: using FromArc = A; using ToArc = A; constexpr 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; } constexpr 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; constexpr 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; } constexpr uint64 Properties(uint64 props) const { return (props & kSetArcProperties) | kIEpsilons | kILabelSorted; } }; // Mapper that converts all output symbols to epsilon. template class OutputEpsilonMapper { public: using FromArc = A; using ToArc = A; constexpr 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; } constexpr uint64 Properties(uint64 props) const { return (props & kSetArcProperties) | kOEpsilons | kOLabelSorted; } }; // 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. constexpr 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: const 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; constexpr explicit WeightConvertMapper(const Converter &c = Converter()) : convert_weight_(c) {} constexpr 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; } constexpr uint64 Properties(uint64 props) const { return props; } private: const 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 = AW::Zero(); 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_); if (osymbols_) { std::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_.emplace(w1, kNoLabel); if (!insert_result.second) { l = insert_result.first->second; } else { l = ++lmax_; insert_result.first->second = l; StringWeightIterator iter1(w1); StateId n; std::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(), 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; constexpr 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; } constexpr 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; constexpr 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; } constexpr 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; } constexpr 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; } constexpr 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; } constexpr 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; } constexpr 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; constexpr 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; } constexpr uint64 Properties(uint64 props) const { return props; } }; } // namespace fst #endif // FST_ARC_MAP_H_ openfst-1.7.9/src/include/fst/arc.h000066400000000000000000000232361421600557100171410ustar00rootroot00000000000000// 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 #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() noexcept(std::is_nothrow_default_constructible::value) {} template ArcTpl(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. ArcTpl(Label ilabel, Label olabel, StateId nextstate) : ArcTpl(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const auto *const type = new std::string( Weight::Type() == "tropical" ? "standard" : Weight::Type()); return *type; } }; using StdArc = ArcTpl; using LogArc = ArcTpl; using Log64Arc = ArcTpl; using RealArc = ArcTpl; using Real64Arc = 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; template StringArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. StringArc(Label ilabel, Label olabel, StateId nextstate) : StringArc(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const auto *const type = new std::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; template GallicArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. GallicArc(Label ilabel, Label olabel, StateId nextstate) : GallicArc(ilabel, olabel, Weight::One(), nextstate) {} explicit GallicArc(const Arc &arc) : ilabel(arc.ilabel), olabel(arc.ilabel), weight(arc.olabel, arc.weight), nextstate(arc.nextstate) {} static const std::string &Type() { static const auto *const type = new std::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 Weight = typename Arc::Weight::ReverseWeight; Label ilabel; Label olabel; Weight weight; StateId nextstate; ReverseArc() = default; template ReverseArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. ReverseArc(Label ilabel, Label olabel, StateId nextstate) : ReverseArc(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const auto *const type = new std::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; template LexicographicArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. LexicographicArc(Label ilabel, Label olabel, StateId nextstate) : LexicographicArc(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const std::string *const type = new std::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; template ProductArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. ProductArc(Label ilabel, Label olabel, StateId nextstate) : ProductArc(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const auto *const type = new std::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; template PowerArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. PowerArc(Label ilabel, Label olabel, StateId nextstate) : PowerArc(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const auto *const type = new std::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; template SparsePowerArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. SparsePowerArc(Label ilabel, Label olabel, StateId nextstate) : SparsePowerArc(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const std::string *const type = [] { std::string type = Arc::Type() + "_^n"; if (sizeof(K) != sizeof(uint32)) { type += "_" + std::to_string(CHAR_BIT * sizeof(K)); } return new std::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; template ExpectationArc(Label ilabel, Label olabel, T &&weight, StateId nextstate) : ilabel(ilabel), olabel(olabel), weight(std::forward(weight)), nextstate(nextstate) {} // Arc with weight One. ExpectationArc(Label ilabel, Label olabel, StateId nextstate) : ExpectationArc(ilabel, olabel, Weight::One(), nextstate) {} static const std::string &Type() { static const auto *const type = new std::string("expectation_" + Arc::Type() + "_" + X2::Type()); return *type; } }; } // namespace fst #endif // FST_ARC_H_ openfst-1.7.9/src/include/fst/arcfilter.h000066400000000000000000000044121421600557100203420ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/arcsort.h000066400000000000000000000151211421600557100200430ustar00rootroot00000000000000// 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 #include namespace fst { template class ArcSortMapper { public: using FromArc = Arc; using ToArc = Arc; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; constexpr 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: constexpr ILabelCompare() {} constexpr bool operator()(const Arc &lhs, const Arc &rhs) const { return std::forward_as_tuple(lhs.ilabel, lhs.olabel) < std::forward_as_tuple(rhs.ilabel, rhs.olabel); } constexpr 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: constexpr OLabelCompare() {} constexpr bool operator()(const Arc &lhs, const Arc &rhs) const { return std::forward_as_tuple(lhs.olabel, lhs.ilabel) < std::forward_as_tuple(rhs.olabel, rhs.ilabel); } constexpr 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_ openfst-1.7.9/src/include/fst/bi-table.h000066400000000000000000000337111421600557100200520ustar00rootroot00000000000000// 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 #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. template > class HashBiTable { public: // Reserves space for table_size elements. explicit HashBiTable(size_t table_size = 0, const H &h = H(), const E &e = E()) : hash_func_(h), hash_equal_(e), entry2id_(table_size, hash_func_, hash_equal_) { if (table_size) id2entry_.reserve(table_size); } HashBiTable(const HashBiTable &table) : hash_func_(table.hash_func_), hash_equal_(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: H hash_func_; E 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. template , HSType HS = HS_FLAT> class CompactHashBiTable { static_assert(HS == HS_STL || HS == HS_FLAT, "Unsupported hash set type"); public: friend class HashFunc; friend class HashEqual; // Reserves space for table_size elements. explicit CompactHashBiTable(size_t table_size = 0, const H &h = H(), const E &e = E()) : hash_func_(h), hash_equal_(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_(table.hash_func_), hash_equal_(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_assert(std::is_signed::value, "I must be a signed type"); // ... otherwise >= kCurrentKey comparisons as used below don't work. // TODO(rybach): (1) don't use >= for key comparison, (2) allow unsigned key // types. static constexpr I kCurrentKey = -1; 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]; } } H hash_func_; E hash_equal_; HashFunc compact_hash_func_; HashEqual compact_hash_equal_; KeyHashSet keys_; std::vector id2entry_; const T *current_entry_; }; template constexpr I CompactHashBiTable::kCurrentKey; // 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. template class VectorBiTable { public: // Reserves table_size cells of space. explicit VectorBiTable(const FP &fp = FP(), size_t table_size = 0) : fp_(fp) { if (table_size) id2entry_.reserve(table_size); } VectorBiTable(const VectorBiTable &table) : 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: FP 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. template class VectorHashBiTable { public: friend class HashFunc; friend class HashEqual; explicit VectorHashBiTable(const S &s = S(), const FP &fp = FP(), const H &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_(table.s_), fp_(table.fp_), 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]; } } S selector_; // True if entry hashed into vector. FP fp_; // Fingerprint used for hashing into vector. H 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_ openfst-1.7.9/src/include/fst/cache.h000066400000000000000000001240121421600557100174310ustar00rootroot00000000000000// 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 #include #include #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 uint8 kCacheFinal = 0x01; // Final weight has been cached. constexpr uint8 kCacheArcs = 0x02; // Arcs have been cached. constexpr uint8 kCacheInit = 0x04; // Initialized by GC. constexpr uint8 kCacheRecent = 0x08; // Visited since GC. constexpr uint8 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_(Weight::Zero()), niepsilons_(0), noepsilons_(0), arcs_(alloc), flags_(0), ref_count_(0) {} CacheState(const CacheState &state, const ArcAllocator &alloc) : final_weight_(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_ = Weight::Zero(); niepsilons_ = 0; noepsilons_ = 0; ref_count_ = 0; flags_ = 0; arcs_.clear(); } Weight Final() const { return final_weight_; } 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. uint8 Flags() const { return flags_; } // Accesses ref count; used by the caller. int RefCount() const { return ref_count_; } void SetFinal(Weight weight = Weight::One()) { final_weight_ = 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) { IncrementNumEpsilons(arc); arcs_.push_back(arc); } void AddArc(Arc &&arc) { IncrementNumEpsilons(arc); arcs_.push_back(std::move(arc)); } // Adds one arc at a time with delayed book-keeping; finalize with SetArcs(). void PushArc(const Arc &arc) { arcs_.push_back(arc); } void PushArc(Arc &&arc) { arcs_.push_back(std::move(arc)); } // Adds one arc at a time with delayed book-keeping; finalize with SetArcs(). template void EmplaceArc(T &&... ctor_args) { arcs_.emplace_back(std::forward(ctor_args)...); } // Finalizes arcs book-keeping; call only once. void SetArcs() { for (const auto &arc : arcs_) { IncrementNumEpsilons(arc); } } // Modifies nth arc. void SetArc(const Arc &arc, size_t n) { if (arcs_[n].ilabel == 0) --niepsilons_; if (arcs_[n].olabel == 0) --noepsilons_; IncrementNumEpsilons(arc); 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(uint8 flags, uint8 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: // Update the number of epsilons as a result of having added an arc. void IncrementNumEpsilons(const Arc &arc) { if (arc.ilabel == 0) ++niepsilons_; if (arc.olabel == 0) ++noepsilons_; } Weight final_weight_; // Final weight. size_t niepsilons_; // # of input epsilons. size_t noepsilons_; // # of output epsilons. std::vector arcs_; // Arcs representation. mutable uint8 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(); // // // Number of cached states. // StateId CountStates(); // // // 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; } bool InBounds(StateId s) const { return s < static_cast(state_vec_.size()); } // Returns nullptr if state is not stored. const State *GetState(StateId s) const { return InBounds(s) ? state_vec_[s] : nullptr; } // Creates state if state is not stored. State *GetMutableState(StateId s) { State *state = nullptr; if (InBounds(s)) { state = state_vec_[s]; } else { state_vec_.resize(s + 1, nullptr); } 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 (State *s : state_vec_) { State::Destroy(s, &state_alloc_); } state_vec_.clear(); state_list_.clear(); } StateId CountStates() const { return std::count_if(state_vec_.begin(), state_vec_.end(), [](const State *s) { return s != nullptr; }); } // 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 (size_t 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(); } StateId CountStates() const { return state_map_.size(); } // 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; } StateId CountStates() const { return store_.CountStates(); } // 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; } StateId CountStates() const { return store_.CountStates(); } // 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 = Weight::One()) { 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 and EmplaceArc 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); } void PushArc(StateId s, Arc &&arc) { auto *state = cache_store_->GetMutableState(s); state->PushArc(std::move(arc)); } // Adds a single arc to a state but delays cache book-keeping. SetArcs must // be called when all PushArc and EmplaceArc calls at a state are complete. // Do not mix with calls to AddArc. template void EmplaceArc(StateId s, T &&... ctor_args) { auto *state = cache_store_->GetMutableState(s); state->EmplaceArc(std::forward(ctor_args)...); } // 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() <= static_cast(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 uint8 Flags() const { return kArcValueFlags; } void SetFlags(uint8 flags, uint8 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_); } uint8 Flags() const final { return kArcValueFlags; } void SetFlags(uint8, uint8) 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 AddArc(Arc &&arc) { state->PushArc(std::move(arc)); } void SetFinal(Weight weight = Weight::One()) { state->SetFinal(std::move(weight)); } }; }; } // namespace fst #endif // FST_CACHE_H_ openfst-1.7.9/src/include/fst/closure.h000066400000000000000000000102561421600557100200460ustar00rootroot00000000000000// 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 #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 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); if (start != kNoLabel) fst->AddArc(nstart, Arc(0, 0, 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; explicit 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_ openfst-1.7.9/src/include/fst/compact-fst.h000066400000000000000000001610151421600557100206120ustar00rootroot00000000000000// 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 #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 (Fst) Compactor interface - used by CompactFst. This interface // allows complete flexibility in how the compaction is accomplished. // // class Compactor { // public: // // Constructor from the Fst to be compacted. If compactor is present, // // only optional state should be copied from it. Examples of this // // optional state include compression level or ArcCompactors. // explicit Compactor(const Fst &fst, // shared_ptr compactor = nullptr); // // Copy constructor. Must make a thread-safe copy suitable for use by // // by Fst::Copy(/*safe=*/true). Only thread-unsafe data structures // // need to be deeply copied. Ideally, this constructor is O(1) and any // // large structures are thread-safe and shared, while small ones may // // need to be copied. // Compactor(const Compactor &compactor); // // 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. // // This constructor may, of course, also take a const Compactor * // // for the first argument. It is recommended to use const Compactor * // // if possible, but this can be Compactor * if necessary. // State(Compactor *c, StateId s); // Accessor for StateId 's'. // StateId GetStateId() const; // Weight Final() const; // size_t NumArcs() const; // // Gets the 'i'th arc for the state. Requires i < NumArcs(). // // Flags are a bitmask of the kArc*Value flags that ArcIterator uses. // Arc GetArc(size_t i, uint8 flags) 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. // template // bool IsCompatible(const Fst &fst) const; // // // Returns the properties that are always when an FST with the // // specified properties is compacted using this compactor. // // This function should clear bits for properties that no longer // // hold and set those for properties that are known to hold. // uint64 Properties(uint64 props) const; // // // Returns a string identifying the type of compactor. // static const std::string &Type(); // // // Returns true if an error has occurred. // 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 ArcCompactor Interface: // // This interface is not deprecated; it, along with CompactArcStore and // other Stores that implement its interface, is simply more constrained // by essentially forcing the implementation to use an index array // and an arc array, but giving flexibility in how those are implemented. // This interface may still be useful and more convenient if that is the // desired representation. // // 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: // // Default constructor (optional, see comment below). // ArcCompactor(); // // // Copy constructor. Must make a thread-safe copy suitable for use by // // by Fst::Copy(/*safe=*/true). Only thread-unsafe data structures // // need to be deeply copied. // ArcCompactor(const ArcCompactor &); // // // 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. Any Fst with the inverse of these properties should // // be incompatible. // uint64 Properties() const; // // // Returns a string identifying the type of compactor. // static const std::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); // }; // // 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 CompactArcCompactor. Only old-style // ArcCompactors are supported because the CompactArcStore constructors // use the old API. // // DefaultCompact store is thread-compatible, but not thread-safe. // The copy constructor makes a thread-safe copy. // // The implementation contains two arrays: 'states_' and 'compacts_'. // // For fixed out-degree compactors, the 'states_' array is unallocated. The // 'compacts_' array 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 a superfinal transition when 's' is final), are stored // in positions ['s*compactor.Size()', '(s+1)*compactor.Size()'). // // For variable out-degree compactors, the states_ array has size // 'nstates_ + 1' and contains positions in the 'compacts_' array. 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 CompactArcStore { public: CompactArcStore() = default; // Makes a thread-safe copy. O(1). CompactArcStore(const CompactArcStore &) = default; template CompactArcStore(const Fst &fst, const ArcCompactor &arc_compactor); template CompactArcStore(const Iterator begin, const Iterator end, const ArcCompactor &arc_compactor); ~CompactArcStore() = default; template static CompactArcStore *Read(std::istream &strm, const FstReadOptions &opts, const FstHeader &hdr, const ArcCompactor &arc_compactor); bool Write(std::ostream &strm, const FstWriteOptions &opts) const; // Returns the starting index in 'compacts_' of the transitions // for state 'i'. See class-level comment for further details. // Requires that the CompactArcStore was constructed with a // variable out-degree compactor. Requires 0 <= i <= NumStates(). // By convention, States(NumStates()) == NumCompacts(). Unsigned States(ssize_t i) const { return states_[i]; } // Returns the compacted Element at position i. See class-level comment // for further details. Requires 0 <= i < NumCompacts(). 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 std::string &Type(); private: std::shared_ptr states_region_; std::shared_ptr compacts_region_; // Unowned pointer into states_region_. Unsigned *states_ = nullptr; // Unowned pointer into compacts_region_. Element *compacts_ = nullptr; size_t nstates_ = 0; size_t ncompacts_ = 0; size_t narcs_ = 0; ssize_t start_ = kNoStateId; bool error_ = false; }; template template CompactArcStore::CompactArcStore( const Fst &fst, const ArcCompactor &arc_compactor) { 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(); narcs_ += fst.NumArcs(s); if (fst.Final(s) != Weight::Zero()) ++nfinals; } if (arc_compactor.Size() == -1) { states_region_ = fst::WrapUnique(MappedFile::Allocate( sizeof(states_[0]) * (nstates_ + 1), alignof(decltype(states_[0])))); states_ = static_cast(states_region_->mutable_data()); ncompacts_ = narcs_ + nfinals; compacts_region_ = fst::WrapUnique(MappedFile::Allocate( sizeof(compacts_[0]) * ncompacts_, alignof(decltype(compacts_[0])))); compacts_ = static_cast(compacts_region_->mutable_data()); states_[nstates_] = ncompacts_; } else { states_ = nullptr; ncompacts_ = nstates_ * arc_compactor.Size(); if ((narcs_ + nfinals) != ncompacts_) { FSTERROR() << "CompactArcStore: ArcCompactor incompatible with FST"; error_ = true; return; } compacts_region_ = fst::WrapUnique(MappedFile::Allocate( sizeof(compacts_[0]) * ncompacts_, alignof(decltype(compacts_[0])))); compacts_ = static_cast(compacts_region_->mutable_data()); } size_t pos = 0; size_t fpos = 0; for (size_t s = 0; s < nstates_; ++s) { fpos = pos; if (arc_compactor.Size() == -1) states_[s] = pos; if (fst.Final(s) != Weight::Zero()) { compacts_[pos++] = arc_compactor.Compact( s, Arc(kNoLabel, kNoLabel, fst.Final(s), kNoStateId)); } for (ArcIterator> aiter(fst, s); !aiter.Done(); aiter.Next()) { compacts_[pos++] = arc_compactor.Compact(s, aiter.Value()); } if ((arc_compactor.Size() != -1) && (pos != fpos + arc_compactor.Size())) { FSTERROR() << "CompactArcStore: ArcCompactor incompatible with FST"; error_ = true; return; } } if (pos != ncompacts_) { FSTERROR() << "CompactArcStore: ArcCompactor incompatible with FST"; error_ = true; return; } } template template CompactArcStore::CompactArcStore( const Iterator begin, const Iterator end, const ArcCompactor &arc_compactor) { using Arc = typename ArcCompactor::Arc; using Weight = typename Arc::Weight; if (arc_compactor.Size() != -1) { ncompacts_ = std::distance(begin, end); if (arc_compactor.Size() == 1) { // For strings, allows implicit final weight. Empty input is the empty // string. if (ncompacts_ == 0) { ++ncompacts_; } else { const auto arc = arc_compactor.Expand(ncompacts_ - 1, *(begin + (ncompacts_ - 1))); if (arc.ilabel != kNoLabel) ++ncompacts_; } } if (ncompacts_ % arc_compactor.Size()) { FSTERROR() << "CompactArcStore: Size of input container incompatible" << " with arc compactor"; error_ = true; return; } if (ncompacts_ == 0) return; start_ = 0; nstates_ = ncompacts_ / arc_compactor.Size(); compacts_region_ = fst::WrapUnique(MappedFile::Allocate( sizeof(compacts_[0]) * ncompacts_, alignof(decltype(compacts_[0])))); compacts_ = static_cast(compacts_region_->mutable_data()); size_t i = 0; Iterator it = begin; for (; it != end; ++it, ++i) { compacts_[i] = *it; if (arc_compactor.Expand(i, *it).ilabel != kNoLabel) ++narcs_; } if (i < ncompacts_) { compacts_[i] = arc_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 = arc_compactor.Expand(i, *it); if (arc.ilabel != kNoLabel) { ++narcs_; ++ncompacts_; } else { ++nstates_; if (arc.weight != Weight::Zero()) ++ncompacts_; } } start_ = 0; compacts_region_ = fst::WrapUnique(MappedFile::Allocate( sizeof(compacts_[0]) * ncompacts_, alignof(decltype(compacts_[0])))); compacts_ = static_cast(compacts_region_->mutable_data()); states_region_ = fst::WrapUnique(MappedFile::Allocate( sizeof(states_[0]) * (nstates_ + 1), alignof(decltype(states_[0])))); states_ = static_cast(states_region_->mutable_data()); states_[nstates_] = ncompacts_; size_t i = 0; size_t s = 0; for (it = begin; it != end; ++it) { const auto arc = 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() << "CompactArcStore: Ill-formed input container"; error_ = true; return; } } } template template CompactArcStore *CompactArcStore::Read( std::istream &strm, const FstReadOptions &opts, const FstHeader &hdr, const ArcCompactor &arc_compactor) { std::unique_ptr data(new CompactArcStore); data->start_ = hdr.Start(); data->nstates_ = hdr.NumStates(); data->narcs_ = hdr.NumArcs(); if (arc_compactor.Size() == -1) { if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) { LOG(ERROR) << "CompactArcStore::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) << "CompactArcStore::Read: Read failed: " << opts.source; return nullptr; } data->states_ = static_cast(data->states_region_->mutable_data()); } else { data->states_ = nullptr; } data->ncompacts_ = arc_compactor.Size() == -1 ? data->states_[data->nstates_] : data->nstates_ * arc_compactor.Size(); if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) { LOG(ERROR) << "CompactArcStore::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) << "CompactArcStore::Read: Read failed: " << opts.source; return nullptr; } data->compacts_ = static_cast(data->compacts_region_->mutable_data()); return data.release(); } template bool CompactArcStore::Write( std::ostream &strm, const FstWriteOptions &opts) const { if (states_) { if (opts.align && !AlignOutput(strm)) { LOG(ERROR) << "CompactArcStore::Write: Alignment failed: " << opts.source; return false; } strm.write(reinterpret_cast(states_), (nstates_ + 1) * sizeof(Unsigned)); } if (opts.align && !AlignOutput(strm)) { LOG(ERROR) << "CompactArcStore::Write: Alignment failed: " << opts.source; return false; } strm.write(reinterpret_cast(compacts_), ncompacts_ * sizeof(Element)); strm.flush(); if (!strm) { LOG(ERROR) << "CompactArcStore::Write: Write failed: " << opts.source; return false; } return true; } template const std::string &CompactArcStore::Type() { static const std::string *const type = new std::string("compact"); return *type; } template class CompactArcState; // Wraps an old-style arc compactor and a compact store as a new Fst compactor. // The copy constructors of AC and S must make thread-safe copies and should // be O(1). template */> class CompactArcCompactor { public: using ArcCompactor = AC; using Unsigned = U; using CompactStore = S; using Element = typename AC::Element; using Arc = typename AC::Arc; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; using State = CompactArcState; friend State; CompactArcCompactor() : arc_compactor_(nullptr), compact_store_(nullptr) {} // Constructs from Fst. explicit CompactArcCompactor(const Fst &fst, ArcCompactor &&arc_compactor = ArcCompactor()) : CompactArcCompactor( fst, std::make_shared(std::move(arc_compactor))) {} CompactArcCompactor(const Fst &fst, std::shared_ptr arc_compactor) : arc_compactor_(std::move(arc_compactor)), compact_store_(std::make_shared(fst, *arc_compactor_)) {} CompactArcCompactor(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. CompactArcCompactor(std::shared_ptr arc_compactor, std::shared_ptr compact_store) : arc_compactor_(std::move(arc_compactor)), compact_store_(std::move(compact_store)) {} // 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 arc compactors. // // - For fixed out-degree arc compactors, the final weight (encoded as a // compacted transition) needs to be given only for final states. All strings // (arc 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 arc 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 CompactArcFst // without first creating a more memory-hungry regular FST. This is useful // when memory usage is severely constrained. // // Usage: // CompactArcFst<...> fst( // std::make_shared::Compactor>(b, e)); template CompactArcCompactor(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_)) {} template CompactArcCompactor(const Iterator b, const Iterator e) : CompactArcCompactor(b, e, std::make_shared()) {} // Copy constructor. This makes a thread-safe copy, so requires that // The ArcCompactor and CompactStore copy constructors make thread-safe // copies. CompactArcCompactor(const CompactArcCompactor &compactor) : arc_compactor_( compactor.GetArcCompactor() == nullptr ? nullptr : std::make_shared(*compactor.GetArcCompactor())), compact_store_(compactor.GetCompactStore() == nullptr ? nullptr : std::make_shared( *compactor.GetCompactStore())) {} template explicit CompactArcCompactor( const CompactArcCompactor &compactor) : arc_compactor_( compactor.GetArcCompactor() == nullptr ? nullptr : std::make_shared(*compactor.GetArcCompactor())), compact_store_(compactor.GetCompactStore() == nullptr ? nullptr : std::make_shared( *compactor.GetCompactStore())) {} 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 CompactArcCompactor *Read(std::istream &strm, const FstReadOptions &opts, const FstHeader &hdr) { std::shared_ptr arc_compactor(ArcCompactor::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 CompactArcCompactor(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(uint64 props) const { // ArcCompactor properties can just be or-ed in since it is assumed that // if the ArcCompactor sets a property, any FST with the inverse // property is incompatible. return arc_compactor_->Properties() | props; } 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 std::string &Type() { static const std::string *const type = [] { std::string type = "compact"; if (sizeof(U) != sizeof(uint32)) type += std::to_string(8 * sizeof(U)); type += "_"; type += ArcCompactor::Type(); if (CompactStore::Type() != "compact") { type += "_"; type += CompactStore::Type(); } return new std::string(type); }(); return *type; } const ArcCompactor *GetArcCompactor() const { return arc_compactor_.get(); } const CompactStore *GetCompactStore() const { return compact_store_.get(); } ArcCompactor *MutableArcCompactor() { return arc_compactor_.get(); } CompactStore *MutableCompactStore() { return compact_store_.get(); } std::shared_ptr SharedArcCompactor() { return arc_compactor_; } std::shared_ptr SharedCompactStore() { return compact_store_; } // TODO(allauzen): remove dependencies on this method and make private. Arc ComputeArc(StateId s, Unsigned i, uint8 flags) const { return arc_compactor_->Expand(s, compact_store_->Compacts(i), flags); } 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 // CompactArcCompactor. Use of efficient specialization strongly encouraged. template class CompactArcState { public: using Arc = typename ArcCompactor::Arc; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; using Compactor = CompactArcCompactor; CompactArcState() = default; CompactArcState(const Compactor *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 Compactor *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, uint8 flags) const { return compactor_->ComputeArc(s_, range_.first + i, flags); } private: const Compactor *compactor_ = nullptr; // borrowed ref. StateId s_ = kNoStateId; std::pair range_ = {0, 0}; bool has_final_ = false; }; // Specialization for CompactArcStore. template class CompactArcState> { public: using Arc = typename ArcCompactor::Arc; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; using CompactStore = CompactArcStore; using Compactor = CompactArcCompactor; CompactArcState() = default; CompactArcState(const Compactor *compactor, StateId s) : arc_compactor_(compactor->GetArcCompactor()), s_(s) { Init(compactor); } void Set(const Compactor *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, uint8 flags) const { return arc_compactor_->Expand(s_, compacts_[i], flags); } private: void Init(const Compactor *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 ArcCompactor *arc_compactor_ = nullptr; // Borrowed reference. const typename ArcCompactor::Element *compacts_ = nullptr; // Borrowed reference. StateId s_ = kNoStateId; U num_arcs_ = 0; bool has_final_ = false; }; template void Cast(const F &, G *); template bool WriteCompactArcFst( const FST &fst, const typename CompactArcFST::Compactor::ArcCompactor &arc_compactor, std::ostream &strm, const FstWriteOptions &opts); namespace internal { // Implementation class for CompactFst, which contains parametrizeable // Fst data storage (CompactArcStore by default) and Fst cache. // C's copy constructor must make a thread-safe copy. 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::HasArcs; using ImplBase::HasFinal; using ImplBase::HasStart; using ImplBase::PushArc; using ImplBase::SetArcs; using ImplBase::SetFinal; using ImplBase::SetStart; CompactFstImpl() : ImplBase(CompactFstOptions()), compactor_() { SetType(Compactor::Type()); SetProperties(kNullProperties | kStaticProperties); } // Constructs a CompactFstImpl, creating a new Compactor using // Compactor(fst, compactor); this uses the compactor arg only for optional // information, such as compression level. See the Compactor interface // description. CompactFstImpl(const Fst &fst, std::shared_ptr compactor, const CompactFstOptions &opts) : ImplBase(opts), compactor_(std::make_shared(fst, std::move(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(compactor_->Properties(copy_properties) | kStaticProperties); } CompactFstImpl(std::shared_ptr compactor, const CompactFstOptions &opts) : ImplBase(opts), compactor_(std::move(compactor)) { SetType(Compactor::Type()); SetProperties(kStaticProperties | compactor_->Properties(0)); if (compactor_->Error()) SetProperties(kError, kError); } // Makes a thread-safe copy; requires that Compactor's copy constructor // does so as well. 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 OtherCacheStore to CacheStore. template explicit 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 uint8 flags = output_epsilons ? kArcOLabelValue : kArcILabelValue; size_t num_eps = 0; const size_t num_arcs = state_.NumArcs(); for (size_t i = 0; i < num_arcs; ++i) { const auto &arc = state_.GetArc(i, flags); 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_); const size_t num_arcs = state_.NumArcs(); for (size_t i = 0; i < num_arcs; ++i) PushArc(s, state_.GetArc(i, kArcValueFlags)); SetArcs(s); if (!HasFinal(s)) SetFinal(s, state_.Final()); } const Compactor *GetCompactor() const { return compactor_.get(); } Compactor *MutableCompactor() { return compactor_.get(); } std::shared_ptr SharedCompactor() { 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_ = std::move(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: // For k*Version constants. template friend bool ::fst::WriteCompactArcFst( const FST &fst, const typename CompactArcFST::Compactor::ArcCompactor &arc_compactor, std::ostream &strm, const FstWriteOptions &opts); // 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; // Returns the compactor for the CompactFst; intended to be called as // GetCompactor(fst), which returns the compactor only if it // is of the specified type and otherwise nullptr (via the overload below). template const Compactor *GetCompactor(const CompactFst &fst) { return fst.GetCompactor(); } template const Compactor *GetCompactor(const Fst &fst) { return nullptr; } } // namespace internal // This class attaches interface to implementation and handles reference // counting, delegating most methods to ImplToExpandedFst. // (Template argument defaults are declared in fst-decl.h.) template class CompactFst : public ImplToExpandedFst> { public: template void friend Cast(const F &, G *); using Arc = A; using StateId = typename Arc::StateId; using Compactor = C; using Impl = internal::CompactFstImpl; using Store = CacheStore; // for CacheArcIterator friend class StateIterator; friend class ArcIterator; CompactFst() : ImplToExpandedFst(std::make_shared()) {} explicit CompactFst(const Fst &fst, const CompactFstOptions &opts = CompactFstOptions()) : CompactFst(fst, std::make_shared(fst), opts) {} // Constructs a CompactFst, creating a new Compactor using // Compactor(fst, compactor); this uses the compactor arg only for optional // information, such as compression level. See the Compactor interface // description. CompactFst(const Fst &fst, std::shared_ptr compactor, const CompactFstOptions &opts = CompactFstOptions()) : ImplToExpandedFst( std::make_shared(fst, std::move(compactor), opts)) {} // Convenience constructor taking a Compactor rvalue ref. Avoids // clutter of make_shared at call site. // Constructs a CompactFst, creating a new Compactor using // Compactor(fst, compactor); this uses the compactor arg only for optional // information, such as compression level. See the Compactor interface // description. CompactFst(const Fst &fst, Compactor &&compactor, const CompactFstOptions &opts = CompactFstOptions()) : CompactFst(fst, std::make_shared(std::move(compactor)), opts) {} explicit CompactFst(std::shared_ptr compactor, const CompactFstOptions &opts = CompactFstOptions()) : ImplToExpandedFst( std::make_shared(std::move(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 source reads from standard input static CompactFst *Read(const std::string &source) { auto *impl = ImplToExpandedFst::Read(source); 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 std::string &source) const override { return Fst::WriteFile(source); } 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(*this, match_type); } const Compactor *GetCompactor() const { return GetImpl()->GetCompactor(); } void SetCompactor(std::shared_ptr compactor) { GetMutableImpl()->SetCompactor(std::move(compactor)); } private: using ImplToFst>::GetImpl; using ImplToFst>::GetMutableImpl; explicit CompactFst(std::shared_ptr impl) : ImplToExpandedFst(std::move(impl)) {} CompactFst &operator=(const CompactFst &fst) = delete; }; // Writes FST in ArcCompacted format, with a possible pass over the machine // before writing to compute the number of states and arcs. template bool WriteCompactArcFst( const FST &fst, const typename CompactArcFST::Compactor::ArcCompactor &arc_compactor, std::ostream &strm, const FstWriteOptions &opts) { using Arc = typename CompactArcFST::Arc; using Compactor = typename CompactArcFST::Compactor; using ArcCompactor = typename Compactor::ArcCompactor; using CompactStore = typename Compactor::CompactStore; using Element = typename ArcCompactor::Element; using Impl = typename CompactArcFST::Impl; using Unsigned = typename Compactor::Unsigned; using Weight = typename Arc::Weight; const auto file_version = opts.align ? Impl::kAlignedFileVersion : Impl::kFileVersion; size_t num_arcs = -1; size_t num_states = -1; auto first_pass_arc_compactor = arc_compactor; // Note that GetCompactor will only return non-null if the compactor has the // exact type Compactor == CompactArcFst::Compactor. This is what we want; // other types must do an extra pass to set the arc compactor state. if (const Compactor *const compactor = internal::GetCompactor(fst)) { num_arcs = compactor->NumArcs(); num_states = compactor->NumStates(); first_pass_arc_compactor = *compactor->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_arc_compactor.Compact( s, Arc(kNoLabel, kNoLabel, fst.Final(s), kNoStateId)); } for (ArcIterator aiter(fst, s); !aiter.Done(); aiter.Next()) { ++num_arcs; first_pass_arc_compactor.Compact(s, aiter.Value()); } } } FstHeader hdr; hdr.SetStart(fst.Start()); hdr.SetNumStates(num_states); hdr.SetNumArcs(num_arcs); std::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) || !arc_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_arc_compactor.Write(strm); if (first_pass_arc_compactor.Size() == -1) { if (opts.align && !AlignOutput(strm)) { LOG(ERROR) << "WriteCompactArcFst: 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_arc_compactor = arc_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_arc_compactor.Compact( s, Arc(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_arc_compactor.Compact(s, aiter.Value()); strm.write(reinterpret_cast(&element), sizeof(element)); } } strm.flush(); if (!strm) { LOG(ERROR) << "WriteCompactArcFst: 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> { public: using StateId = typename Arc::StateId; explicit StateIterator(const CompactFst &fst) : nstates_(fst.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 State = typename Compactor::State; ArcIterator(const CompactFst &fst, StateId s) : state_(fst.GetMutableImpl()->MutableCompactor(), s), pos_(0), num_arcs_(state_.NumArcs()), flags_(kArcValueFlags) {} bool Done() const { return pos_ >= num_arcs_; } 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; } uint8 Flags() const { return flags_; } void SetFlags(uint8 flags, uint8 mask) { flags_ &= ~mask; flags_ |= (flags & kArcValueFlags); } private: State state_; size_t pos_; // Cache the value of NumArcs(), since it is used in Done() and may be slow. size_t num_arcs_; mutable Arc arc_; uint8 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, uint8 flags = 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 kCompiledStringProperties; } bool Compatible(const Fst &fst) const { const auto props = Properties(); return fst.Properties(props, true) == props; } static const std::string &Type() { static const std::string *const type = new std::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, uint8 flags = 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 std::string &Type() { static const std::string *const type = new std::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, uint8 flags = 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 std::string &Type() { static const std::string *const type = new std::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, uint8 flags = 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 std::string &Type() { static const std::string *const type = new std::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, uint8 flags = 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 std::string &Type() { static const std::string *const type = new std::string("unweighted"); return *type; } bool Write(std::ostream &strm) const { return true; } static UnweightedCompactor *Read(std::istream &strm) { return new UnweightedCompactor; } }; template using CompactStringFst = CompactArcFst, Unsigned>; template using CompactWeightedStringFst = CompactArcFst, Unsigned>; template using CompactAcceptorFst = CompactArcFst, Unsigned>; template using CompactUnweightedFst = CompactArcFst, Unsigned>; template using CompactUnweightedAcceptorFst = CompactArcFst, Unsigned>; using StdCompactStringFst = CompactStringFst; using StdCompactWeightedStringFst = CompactWeightedStringFst; using StdCompactAcceptorFst = CompactAcceptorFst; using StdCompactUnweightedFst = CompactUnweightedFst; using StdCompactUnweightedAcceptorFst = CompactUnweightedAcceptorFst; // Convenience function to make a CompactStringFst from a sequence // of Arc::Labels. LabelIterator must be an input iterator. template inline CompactStringFst MakeCompactStringFst( const LabelIterator begin, const LabelIterator end) { using CompactStringFst = CompactStringFst; using Compactor = typename CompactStringFst::Compactor; return CompactStringFst(std::make_shared(begin, end)); } template inline StdCompactStringFst MakeStdCompactStringFst(const LabelIterator begin, const LabelIterator end) { return MakeCompactStringFst(begin, end); } } // namespace fst #endif // FST_COMPACT_FST_H_ openfst-1.7.9/src/include/fst/compat.h000066400000000000000000000114571421600557100176610ustar00rootroot00000000000000// 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 #include #include #include #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 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; } // Checksums. class CheckSummer { public: CheckSummer(); void Reset(); void Update(void const *data, int size); void Update(std::string const &data); std::string Digest() { return check_sum_; } private: constexpr static int kCheckSumLength = 32; int count_; std::string check_sum_; CheckSummer(const CheckSummer &) = delete; CheckSummer &operator=(const CheckSummer &) = delete; }; // Defines make_unique and make_unique_default_init using a standard definition // that should be compatible with the C++14 and C++20 (respectively) // definitions. // TODO(kbg): Remove these once we migrate to C++14 and C++20. template std::unique_ptr make_unique(Args &&... args) { return std::unique_ptr(new T(std::forward(args)...)); } template std::unique_ptr make_unique(size_t n) { return std::unique_ptr(new typename std::remove_extent::type[n]()); } template std::unique_ptr make_unique_default_init() { return std::unique_ptr(new T); } template std::unique_ptr make_unique_default_init(size_t n) { return std::unique_ptr(new typename std::remove_extent::type[n]); } template std::unique_ptr WrapUnique(T *ptr) { return std::unique_ptr(ptr); } // Range utilities // A range adaptor for a pair of iterators. // // This just wraps two iterators into a range-compatible interface. Nothing // fancy at all. template class iterator_range { public: using iterator = IteratorT; using const_iterator = IteratorT; using value_type = typename std::iterator_traits::value_type; iterator_range() : begin_iterator_(), end_iterator_() {} iterator_range(IteratorT begin_iterator, IteratorT end_iterator) : begin_iterator_(std::move(begin_iterator)), end_iterator_(std::move(end_iterator)) {} IteratorT begin() const { return begin_iterator_; } IteratorT end() const { return end_iterator_; } private: IteratorT begin_iterator_, end_iterator_; }; // Convenience function for iterating over sub-ranges. // // This provides a bit of syntactic sugar to make using sub-ranges // in for loops a bit easier. Analogous to std::make_pair(). template iterator_range make_range(T x, T y) { return iterator_range(std::move(x), std::move(y)); } // String munging. std::string StringJoin(const std::vector &elements, const std::string &delim); std::string StringJoin(const std::vector &elements, const char *delim); std::string StringJoin(const std::vector &elements, char delim); std::vector StringSplit(const std::string &full, const std::string &delim); std::vector StringSplit(const std::string &full, const char *delim); std::vector StringSplit(const std::string &full, char delim); void StripTrailingAsciiWhitespace(std::string *full); std::string StripTrailingAsciiWhitespace(const std::string &full); } // namespace fst #endif // FST_LIB_COMPAT_H_ openfst-1.7.9/src/include/fst/complement.h000066400000000000000000000171211421600557100205330ustar00rootroot00000000000000// 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 #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"); const auto 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; const 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_ = fst::make_unique>>(*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; } uint8 Flags() const final { return kArcValueFlags; } void SetFlags(uint8, uint8) 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_ openfst-1.7.9/src/include/fst/compose-filter.h000066400000000000000000000465701421600557100213320ustar00rootroot00000000000000// 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 #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 disallows matching epsilons on FST1 with epsilons on FST2, // but allows all other 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 NoMatchComposeFilter { 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; NoMatchComposeFilter(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()) {} NoMatchComposeFilter(const NoMatchComposeFilter &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 FilterState(arc1->olabel != 0 || arc2->ilabel != 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_; }; // 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_ openfst-1.7.9/src/include/fst/compose.h000066400000000000000000001141641421600557100200420ustar00rootroot00000000000000// 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 #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::HasArcs; using CacheImpl::HasFinal; using CacheImpl::HasStart; using CacheImpl::SetFinal; using CacheImpl::SetStart; explicit ComposeFstImplBase(const CacheImplOptions &opts) : CacheImpl(opts) {} explicit 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(&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); CacheImpl::EmplaceArc(s, arc1.ilabel, arc2.olabel, Times(arc1.weight, arc2.weight), state_table_->FindState(tuple)); } 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) { 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. auto arca = matchera->Value(); 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 (match_type_ == MATCH_INPUT) { return MatchArc(s_, &arca, &arcb); } else { return MatchArc(s_, &arcb, &arca); } } } // 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, NO_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 NO_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_ openfst-1.7.9/src/include/fst/concat.h000066400000000000000000000167411421600557100176460ustar00rootroot00000000000000// 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 #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 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 // 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 // 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 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()); } } // Same as the above but can handle arbitrarily many left-hand-side FSTs, // preallocating the states. template void Concat(const std::vector *> &fsts1, MutableFst *fst2) { fst2->ReserveStates(CountStates(fsts1) + fst2->NumStates()); for (const auto *fst1 : fsts1) Concat(*fst1, fst2); } // 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_ openfst-1.7.9/src/include/fst/config.h000066400000000000000000000006351421600557100176370ustar00rootroot00000000000000/* 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 openfst-1.7.9/src/include/fst/config.h.in000066400000000000000000000005141421600557100202400ustar00rootroot00000000000000// 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 openfst-1.7.9/src/include/fst/connect.h000066400000000000000000000233671421600557100200320ustar00rootroot00000000000000// 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 #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 (size_t 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_ = fst::make_unique>(); lowlink_ = fst::make_unique>(); onstack_ = fst::make_unique>(); scc_stack_ = fst::make_unique>(); } template inline bool SccVisitor::InitState(StateId s, StateId root) { scc_stack_->push_back(s); if (static_cast(dfnumber_->size()) <= s) { if (scc_) scc_->resize(s + 1, -1); if (access_) access_->resize(s + 1, false); coaccess_->resize(s + 1, false); dfnumber_->resize(s + 1, -1); lowlink_->resize(s + 1, -1); onstack_->resize(s + 1, 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; dstates.reserve(access.size()); 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); const auto iter = std::max_element(scc->cbegin(), scc->cend()); if (iter == scc->cend()) return; const StateId num_condensed_states = 1 + *iter; ofst->ReserveStates(num_condensed_states); for (StateId c = 0; c < num_condensed_states; ++c) { ofst->AddState(); } for (StateId s = 0; s < scc->size(); ++s) { const auto c = (*scc)[s]; 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()) { const auto &arc = aiter.Value(); const auto nextc = (*scc)[arc.nextstate]; if (nextc != c) { Arc condensed_arc = arc; condensed_arc.nextstate = nextc; ofst->AddArc(c, std::move(condensed_arc)); } } } ofst->SetProperties(kAcyclic | kInitialAcyclic, kAcyclic | kInitialAcyclic); } } // namespace fst #endif // FST_CONNECT_H_ openfst-1.7.9/src/include/fst/const-fst.h000066400000000000000000000361561421600557100203210ustar00rootroot00000000000000// 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 #include #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() { std::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].final_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 final_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() : final_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_ = nullptr; // States representation. Arc *arcs_ = nullptr; // Arcs representation. size_t narcs_ = 0; // Number of arcs. StateId nstates_ = 0; // Number of states. StateId start_ = kNoStateId; // 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) { std::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_; narcs_ += fst.NumArcs(siter.Value()); } states_region_.reset(MappedFile::AllocateType(nstates_)); arcs_region_.reset(MappedFile::AllocateType(narcs_)); states_ = static_cast(states_region_->mutable_data()); arcs_ = static_cast(arcs_region_->mutable_data()); size_t pos = 0; for (StateId s = 0; s < nstates_; ++s) { states_[s].final_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) { 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_ = static_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_ = static_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). // // ConstFst is thread-safe. 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 unused_safe = false) : ImplToExpandedFst(fst.GetSharedImpl()) {} // 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 source reads // from standard input. static ConstFst *Read(const std::string &source) { auto *impl = ImplToExpandedFst::Read(source); 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 std::string &source) const override { return Fst::WriteFile(source); } 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. std::streamoff 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); std::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; ConstState state; for (StateIterator siter(fst); !siter.Done(); siter.Next()) { const auto s = siter.Value(); state.final_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(); 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 uint8 Flags() const { return kArcValueFlags; } void SetFlags(uint8, uint8) {} 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_ openfst-1.7.9/src/include/fst/determinize.h000066400000000000000000001167211421600557100207150ustar00rootroot00000000000000// 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 #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, 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(std::move(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; auto *tuple = new StateTuple; tuple->subset.emplace_front(s, Weight::One()); 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, std::move(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(); Element dest_element(arc.nextstate, Times(src_element.weight, arc.weight)); filter_->FilterArc(arc, src_element, std::move(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, DetArc &&det_arc) { CacheImpl::EmplaceArc(s, det_arc.label, det_arc.label, std::move(det_arc.weight), FindState(det_arc.dest_tuple)); } 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. static const CommonDivisor common_divisor_; std::unique_ptr filter_; std::unique_ptr state_table_; }; template const CommonDivisor DeterminizeFsaImpl::common_divisor_{}; // 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 explicit 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_ = fst::make_unique(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_ openfst-1.7.9/src/include/fst/dfs-visit.h000066400000000000000000000150621421600557100203020ustar00rootroot00000000000000// 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) { 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 >= static_cast(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 >= static_cast(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_ openfst-1.7.9/src/include/fst/difference.h000066400000000000000000000154451421600557100204710ustar00rootroot00000000000000// 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>; // 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 = DifferenceFst(ifst1, ifst2, nopts); break; } case SEQUENCE_FILTER: { DifferenceFstOptions dopts; dopts.gc_limit = 0; *ofst = DifferenceFst(ifst1, ifst2, dopts); break; } case ALT_SEQUENCE_FILTER: { DifferenceFstOptions> dopts; dopts.gc_limit = 0; *ofst = DifferenceFst(ifst1, ifst2, dopts); break; } case MATCH_FILTER: { DifferenceFstOptions> dopts; dopts.gc_limit = 0; *ofst = DifferenceFst(ifst1, ifst2, dopts); break; } case NO_MATCH_FILTER: { DifferenceFstOptions> dopts; dopts.gc_limit = 0; *ofst = DifferenceFst(ifst1, ifst2, dopts); break; } case NULL_FILTER: { DifferenceFstOptions> dopts; dopts.gc_limit = 0; *ofst = DifferenceFst(ifst1, ifst2, dopts); break; } case TRIVIAL_FILTER: { DifferenceFstOptions> dopts; dopts.gc_limit = 0; *ofst = DifferenceFst(ifst1, ifst2, dopts); break; } } if (opts.connect) Connect(ofst); } } // namespace fst #endif // FST_DIFFERENCE_H_ openfst-1.7.9/src/include/fst/disambiguate.h000066400000000000000000000500611421600557100210260ustar00rootroot00000000000000// 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 #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->emplace(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, ProjectType::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_ = fst::make_unique(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_ = fst::make_unique>(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_ openfst-1.7.9/src/include/fst/edit-fst.h000066400000000000000000000656111421600557100201160ustar00rootroot00000000000000// 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 #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 { // Serializes all private data members of this class. FstWriteOptions edits_opts(opts); edits_opts.write_header = true; // Forces 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()) { const 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 { const auto it = GetEditedIdMapIterator(s); return it == NotInEditedMap() ? wrapped->NumArcs(s) : edits_.NumArcs(it->second); } size_t NumInputEpsilons(StateId s, const WrappedFstT *wrapped) const { const auto it = GetEditedIdMapIterator(s); return it == NotInEditedMap() ? wrapped->NumInputEpsilons(s) : edits_.NumInputEpsilons(it->second); } size_t NumOutputEpsilons(StateId s, const WrappedFstT *wrapped) const { 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 weight, const WrappedFstT *wrapped) { const auto old_weight = Final(s, wrapped); const 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] = weight; } else { edits_.SetFinal(GetEditableInternalId(s, wrapped), weight); } return old_weight; } // Adds a new state to this FST. StateId AddState(StateId curr_num_states) { external_to_internal_ids_[curr_num_states] = edits_.AddState(); ++num_new_states_; return curr_num_states; } // Adds new states to this FST. void AddStates(StateId curr_num_states, size_t n) { for (size_t i = 0; i < n; ++i) { curr_num_states = AddState(curr_num_states); } } // 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) { // Grabs 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 { const auto it = GetEditedIdMapIterator(s); if (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: " << it->second << ")"; edits_.InitArcIterator(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 IDs (for debugging // purposes). void PrintMap() { for (auto it = external_to_internal_ids_.begin(); it != NotInEditedMap(); ++it) { LOG(INFO) << "(external,internal)=(" << it->first << "," << it->second << ")"; } } private: // Returns the iterator of the map from external to internal state IDs // of edits_ for the specified external state IDs. 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 FSTs (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); // Serializes the wrapped FST to stream. FstWriteOptions wrapped_opts(opts); // Forces 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. StateId AddState() { MutateCheck(); SetProperties(AddStateProperties(FstImpl::Properties())); return data_->AddState(NumStates()); } // Adds new states to this FST. void AddStates(size_t n) { MutateCheck(); SetProperties(AddStateProperties(FstImpl::Properties())); return data_->AddStates(NumStates(), n); } // 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_ = fst::make_unique(); 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. // // EditFst is thread-compatible. 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 source // argument is an empty string, it reads from standard input. static EditFst *Read(const std::string &source) { auto *impl = ImplToExpandedFst>::Read(source); 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 std::string &source) const override { return Fst::WriteFile(source); } 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_ openfst-1.7.9/src/include/fst/encode.h000066400000000000000000000442451421600557100176340ustar00rootroot00000000000000// 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 #include #include namespace fst { enum EncodeType { ENCODE = 1, DECODE = 2 }; static constexpr uint8 kEncodeLabels = 0x01; static constexpr uint8 kEncodeWeights = 0x02; static constexpr uint8 kEncodeFlags = 0x03; namespace internal { // Bits storing whether or not an encode table has input and/or output symbol // tables, for internal use only. static constexpr uint8 kEncodeHasISymbols = 0x04; static constexpr uint8 kEncodeHasOSymbols = 0x08; // Identifies stream data as an encode table (and its endianity). static const int32 kEncodeMagicNumber = 2128178506; // TODO(b/141172858): deprecated, remove by 2020-01-01. static const int32 kEncodeDeprecatedMagicNumber = 2129983209; } // namespace internal // Header for the encoder table. class EncodeTableHeader { public: EncodeTableHeader() = default; // Getters. const std::string &ArcType() const { return arctype_; } uint8 Flags() const { return flags_; } size_t Size() const { return size_; } // Setters. void SetArcType(const std::string &arctype) { arctype_ = arctype; } void SetFlags(uint8 flags) { flags_ = flags; } void SetSize(size_t size) { size_ = size; } // IO. bool Read(std::istream &strm, const std::string &source); bool Write(std::ostream &strm, const std::string &source) const; private: std::string arctype_; uint8 flags_; size_t size_; }; namespace internal { // The following class encapsulates implementation details for the encoding and // decoding of label/weight triples used for encoding and decoding of FSTs. The // EncodeTable is bidirectional, i.e, it stores both the Triple 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 Triple { Triple() = default; Triple(Label ilabel, Label olabel, Weight weight) : ilabel(ilabel), olabel(olabel), weight(std::move(weight)) {} // Constructs from arc and flags. Triple(const Arc &arc, uint8 flags) : ilabel(arc.ilabel), olabel(flags & kEncodeLabels ? arc.olabel : 0), weight(flags & kEncodeWeights ? arc.weight : Weight::One()) {} static std::unique_ptr Read(std::istream &strm) { auto triple = fst::make_unique(); ReadType(strm, &triple->ilabel); ReadType(strm, &triple->olabel); ReadType(strm, &triple->weight); return triple; } // Exploited below for TripleEqual functor. bool operator==(const Triple &other) const { return (ilabel == other.ilabel && olabel == other.olabel && weight == other.weight); } Label ilabel; Label olabel; Weight weight; }; // Equality functor for two Triple pointers. struct TripleEqual { bool operator()(const Triple *x, const Triple *y) const { return *x == *y; } }; // Hash functor for one Triple pointer. class TripleHash { public: explicit TripleHash(uint8 flags) : flags_(flags) {} size_t operator()(const Triple *triple) const { size_t hash = triple->ilabel; static constexpr int lshift = 5; static constexpr int rshift = CHAR_BIT * sizeof(size_t) - 5; if (flags_ & kEncodeLabels) { hash = hash << lshift ^ hash >> rshift ^ triple->olabel; } if (flags_ & kEncodeWeights) { hash = hash << lshift ^ hash >> rshift ^ triple->weight.Hash(); } return hash; } private: uint8 flags_; }; explicit EncodeTable(uint8 flags) : flags_(flags), triple2label_(1024, TripleHash(flags)) {} // Given an arc, encodes either input/output labels or input/costs or both. Label Encode(const Arc &arc) { // Encoding weights of a weighted superfinal transition could result in // a clash with a true epsilon arc; to avoid this we hallucinate kNoLabel // labels instead. if (arc.nextstate == kNoStateId && (flags_ & kEncodeWeights)) { return Encode(fst::make_unique(kNoLabel, kNoLabel, arc.weight)); } else { return Encode(fst::make_unique(arc, flags_)); } } // Given an encoded arc label, decodes back to input/output labels and costs. const Triple *Decode(Label label) const { if (label < 1 || label > triples_.size()) { LOG(ERROR) << "EncodeTable::Decode: Unknown decode label: " << label; return nullptr; } return triples_[label - 1].get(); } size_t Size() const { return triples_.size(); } static EncodeTable *Read(std::istream &strm, const std::string &source); bool Write(std::ostream &strm, const std::string &source) const; // This is masked to hide internal-only isymbol and osymbol bits. uint8 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: Label Encode(std::unique_ptr triple) { auto insert_result = triple2label_.emplace(triple.get(), triples_.size() + 1); if (insert_result.second) triples_.push_back(std::move(triple)); return insert_result.first->second; } uint8 flags_; std::vector> triples_; std::unordered_map triple2label_; std::unique_ptr isymbols_; std::unique_ptr osymbols_; EncodeTable(const EncodeTable &) = delete; EncodeTable &operator=(const EncodeTable &) = delete; }; template EncodeTable *EncodeTable::Read(std::istream &strm, const std::string &source) { EncodeTableHeader hdr; if (!hdr.Read(strm, source)) return nullptr; const auto flags = hdr.Flags(); const auto size = hdr.Size(); auto table = fst::make_unique(flags); for (int64 i = 0; i < size; ++i) { table->triples_.emplace_back(std::move(Triple::Read(strm))); table->triple2label_[table->triples_.back().get()] = table->triples_.size(); } if (flags & kEncodeHasISymbols) { table->isymbols_.reset(SymbolTable::Read(strm, source)); } if (flags & kEncodeHasOSymbols) { table->osymbols_.reset(SymbolTable::Read(strm, source)); } if (!strm) { LOG(ERROR) << "EncodeTable::Read: Read failed: " << source; return nullptr; } return table.release(); } template bool EncodeTable::Write(std::ostream &strm, const std::string &source) const { EncodeTableHeader hdr; hdr.SetArcType(Arc::Type()); hdr.SetFlags(flags_); // Real flags, not masked ones. hdr.SetSize(Size()); if (!hdr.Write(strm, source)) return false; for (const auto &triple : triples_) { WriteType(strm, triple->ilabel); WriteType(strm, triple->olabel); WriteType(strm, triple->weight); } 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; } } // 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: explicit EncodeMapper(uint8 flags, EncodeType type = ENCODE) : 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; } uint8 Flags() const { return flags_; } 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; } EncodeType Type() const { return type_; } static EncodeMapper *Read(std::istream &strm, const std::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 std::string &source, EncodeType type = ENCODE) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "EncodeMapper: Can't open file: " << source; return nullptr; } return Read(strm, source, type); } bool Write(std::ostream &strm, const std::string &source) const { return table_->Write(strm, source); } bool Write(const std::string &source) const { std::ofstream strm(source, std::ios_base::out | std::ios_base::binary); if (!strm) { LOG(ERROR) << "EncodeMapper: Can't open file: " << source; return false; } return Write(strm, source); } 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: uint8 flags_; EncodeType type_; std::shared_ptr> table_; bool error_; explicit EncodeMapper(uint8 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 this arc is a hallucinated final state, and we're either not encoding // weights, or we're encoding weights but this is non-final, we use an // identity-encoding. if (arc.nextstate == kNoStateId && ((!(flags_ & kEncodeWeights) || ((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 triple = table_->Decode(arc.ilabel); if (!triple) { FSTERROR() << "EncodeMapper: Decode failed"; error_ = true; return Arc(kNoLabel, kNoLabel, Weight::NoWeight(), arc.nextstate); } else if (triple->ilabel == kNoLabel) { // Hallucinated kNoLabel from a weighted superfinal transition. return Arc(0, 0, triple->weight, arc.nextstate); } else { return Arc(triple->ilabel, flags_ & kEncodeLabels ? triple->olabel : arc.olabel, flags_ & kEncodeWeights ? triple->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; 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::GetImpl; 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_ openfst-1.7.9/src/include/fst/epsnormalize.h000066400000000000000000000040771421600557100211060ustar00rootroot00000000000000// 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, except allows specifying explicitly the gallic weight type. template void EpsNormalize(const Fst &ifst, MutableFst *ofst, EpsNormalizeType type) { VectorFst> gfst; std::unique_ptr symbols; if (type == EPS_NORM_INPUT) { ArcMap(ifst, &gfst, ToGallicMapper()); if (ifst.OutputSymbols()) symbols.reset(ifst.OutputSymbols()->Copy()); } else { // type == EPS_NORM_OUTPUT ArcMap(InvertFst(ifst), &gfst, ToGallicMapper()); if (ifst.InputSymbols()) symbols.reset(ifst.InputSymbols()->Copy()); } RmEpsilon(&gfst); FactorWeightFst, GallicFactor> fwfst(gfst); ArcMap(fwfst, ofst, FromGallicMapper()); ofst->SetOutputSymbols(symbols.get()); if (type == EPS_NORM_OUTPUT) Invert(ofst); } } // namespace fst #endif // FST_EPSNORMALIZE_H_ openfst-1.7.9/src/include/fst/equal.h000066400000000000000000000137751421600557100175120ustar00rootroot00000000000000// 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 uint8 kEqualFsts = 0x01; constexpr uint8 kEqualFstTypes = 0x02; constexpr uint8 kEqualCompatProperties = 0x04; constexpr uint8 kEqualCompatSymbols = 0x08; constexpr uint8 kEqualAll = kEqualFsts | kEqualFstTypes | kEqualCompatProperties | kEqualCompatSymbols; class WeightApproxEqual { public: explicit WeightApproxEqual(float delta) : delta_(delta) {} // We use two weight types to avoid some conflicts caused by // conversions. template bool operator()(const Weight1 &w1, const Weight2 &w2) const { return ApproxEqual(w1, w2, delta_); } private: const float delta_; }; // Tests if two FSTs have the same states and arcs in the same order (when // etype & kEqualFst); optionally, also 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, WeightEqual weight_equal, uint8 etype = kEqualFsts) { if ((etype & kEqualFstTypes) && (fst1.Type() != fst2.Type())) { VLOG(1) << "Equal: Mismatched FST types (" << fst1.Type() << " != " << fst2.Type() << ")"; return false; } if ((etype & kEqualCompatProperties) && !internal::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 (!weight_equal(final1, final2)) { 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 (!weight_equal(arc1.weight, arc2.weight)) { 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; } template bool Equal(const Fst &fst1, const Fst &fst2, float delta = kDelta, uint8 etype = kEqualFsts) { return Equal(fst1, fst2, WeightApproxEqual(delta), etype); } // Support double deltas without forcing all clients to cast to float. // Without this overload, Equal will be chosen, // since it is a better match than double -> float narrowing, but // the instantiation will fail. template bool Equal(const Fst &fst1, const Fst &fst2, double delta, uint8 etype = kEqualFsts) { return Equal(fst1, fst2, WeightApproxEqual(static_cast(delta)), etype); } } // namespace fst #endif // FST_EQUAL_H_ openfst-1.7.9/src/include/fst/equivalent.h000066400000000000000000000211571421600557100205510ustar00rootroot00000000000000// 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.emplace_back(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_ openfst-1.7.9/src/include/fst/expanded-fst.h000066400000000000000000000127631421600557100207610ustar00rootroot00000000000000// 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 #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 source reads from standard input. static ExpandedFst *Read(const std::string &source) { if (!source.empty()) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "ExpandedFst::Read: Can't open file: " << source; return nullptr; } return Read(strm, FstReadOptions(source)); } 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; StateId NumStates() const override { return GetImpl()->NumStates(); } protected: using ImplToFst::GetImpl; explicit ImplToExpandedFst(std::shared_ptr impl) : ImplToFst(impl) {} 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 source reads from standard input. static Impl *Read(const std::string &source) { if (!source.empty()) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "ExpandedFst::Read: Can't open file: " << source; return nullptr; } return Impl::Read(strm, FstReadOptions(source)); } 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 states in a vector of FSTs, counting them if // necessary. template typename Arc::StateId CountStates(const std::vector *> &fsts) { typename Arc::StateId nstates = 0; for (const auto *fst : fsts) nstates += CountStates(*fst); return nstates; } // Function to return the number of arcs in an FST. template size_t CountArcs(const F &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_ openfst-1.7.9/src/include/fst/expander-cache.h000066400000000000000000000137171421600557100212460ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Cache implementations for ExpanderFst. // // Expander caches must expose a State type and a FindOrExpand template method: // // class ExpanderCache { // public: // class State; // // template // State* FindOrExpander(Expander& expander, StateId id) { // if (id is found in cache) return cached_state; // // // Use the provided expander to create a new cached state and cache it. // expander.Expand(id, &new_state); // insert new_state into cache; // return new_state; // } // }; // // Cache implementations must be copyable and assignable. It is up to the // implementation whether this means it will discard the contents of the cache, // copy all of the cache, share some of the cache etc. It is *REQUIRED* that the // copy be "safe", the copy and the original must be usable from concurrent // threads without accessing any internally shared state. #ifndef FST_EXPANDER_CACHE_H_ #define FST_EXPANDER_CACHE_H_ #include #include #include #include #include #include #include #include namespace fst { // Stateful allocators can't be used without careful handling in threaded // contexts, so arbitrary stl allocators aren't supported here. template class SimpleVectorCacheState { public: using Arc = A; using Weight = typename Arc::Weight; using StateId = typename Arc::StateId; void Reset() { final_weight_ = Weight::Zero(); niepsilons_ = 0; noepsilons_ = 0; arcs_.clear(); } Weight Final() const { return final_weight_; } 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() ? nullptr : &arcs_[0]; } void SetFinal(Weight weight) { final_weight_ = weight; } void ReserveArcs(size_t n) { arcs_.reserve(n); } void AddArc(const Arc &arc) { if (arc.ilabel == 0) ++niepsilons_; if (arc.olabel == 0) ++noepsilons_; arcs_.push_back(arc); } void AddArc(Arc &&arc) { if (arc.ilabel == 0) ++niepsilons_; if (arc.olabel == 0) ++noepsilons_; arcs_.push_back(std::move(arc)); } int *MutableRefCount() const { return nullptr; } private: Weight final_weight_ = Weight::Zero(); size_t niepsilons_ = 0; // Number of input epsilons. size_t noepsilons_ = 0; // Number of output epsilons. std::vector arcs_; }; template class NoGcKeepOneExpanderCache { public: using Arc = A; using StateId = typename Arc::StateId; // Reference-counted state. class State : public SimpleVectorCacheState { public: int *MutableRefCount() { return &ref_count_; } void Reset() { SimpleVectorCacheState::Reset(); ref_count_ = 0; } private: int ref_count_ = 0; friend class NoGcKeepOneExpanderCache; }; NoGcKeepOneExpanderCache() : state_(new State) {} NoGcKeepOneExpanderCache(const NoGcKeepOneExpanderCache ©) : state_(new State(*copy.state_)) {} template State *FindOrExpand(Expander &expander, StateId state_id) { if (state_id == state_id_) return state_.get(); if (state_->ref_count_ > 0) cache_[state_id_] = std::move(state_); state_id_ = state_id; if (cache_.empty()) { state_->Reset(); expander.Expand(state_id_, state_.get()); return state_.get(); } auto i = cache_.find(state_id_); if (i != cache_.end()) state_ = std::move(i->second); if (state_ == nullptr) { state_ = fst::make_unique(); expander.Expand(state_id_, state_.get()); } return state_.get(); } StateId state_id_ = kNoStateId; std::unique_ptr state_; std::unordered_map> cache_; }; template class HashExpanderCache { public: using Arc = A; using StateId = typename Arc::StateId; using State = SimpleVectorCacheState; HashExpanderCache(const HashExpanderCache ©) { *this = copy; } HashExpanderCache &operator=(const HashExpanderCache ©) { for (const auto &kv : copy.cache_) cache_[kv.first] = new State(*kv.second); return *this; } ~HashExpanderCache() { for (auto i : cache_) delete i.second; } 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; auto *state = new State; it.first->second = state; expander.Expand(state_id, state); return state; } private: std::unordered_map cache_; }; template class VectorExpanderCache { public: using Arc = A; using StateId = typename Arc::StateId; using State = SimpleVectorCacheState; VectorExpanderCache() : vec_(0, nullptr) {} VectorExpanderCache(const VectorExpanderCache ©) { *this = copy; } VectorExpanderCache &operator=(const VectorExpanderCache ©) { vec_.resize(copy.vec_.size()); for (StateId i = 0; i < copy.vec_.size(); ++i) { const auto *state = copy.vec_[i]; if (state != nullptr) { states_.emplace_back(*state); vec_[i] = &states_.back(); } } return *this; } template State *FindOrExpand(Expander &expander, StateId state_id) { // NOLINT if (state_id >= vec_.size()) vec_.resize(state_id + 1); auto **slot = &vec_[state_id]; if (*slot == nullptr) { states_.emplace_back(); *slot = &states_.back(); expander.Expand(state_id, *slot); } return *slot; } private: std::deque states_; std::vector vec_; }; template using DefaultExpanderCache = VectorExpanderCache; } // namespace fst #endif // FST_EXPANDER_CACHE_H_ openfst-1.7.9/src/include/fst/expectation-weight.h000066400000000000000000000123261421600557100222020ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Expectation semiring, as described in: // // Eisner, J. 2002. Parameter estimation for probabilistic finite-state // transducers. In Proceedings of the 40th Annual Meeting of the // Association for Computational Linguistics, pages 1-8. // // Multiplex semiring operations and identities: // // One: // Zero: // Plus: + = <(a1 + a2), (b1 + b2)> // Times: + = <(a1 * a2), [(a1 * b2) + (a2 * b1)]> // Division: Undefined. // // It is commonly used to store a probability, random variable pair so that // the shortest distance gives the posterior probability and the associated // expected value. #ifndef FST_EXPECTATION_WEIGHT_H_ #define FST_EXPECTATION_WEIGHT_H_ #include #include #include #include namespace fst { // W1 is usually a probability weight like LogWeight. // W2 is usually a random variable or vector (see SignedLogWeight or // SparsePowerWeight). // // If W1 is distinct from W2, it is required that there is an external product // between W1 and W2 and if both semriring are commutative, or left or right // semirings, then the 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()) {} explicit ExpectationWeight(const PairWeight &weight) : PairWeight(weight) {} ExpectationWeight(const W1 &w1, const W2 &w2) : PairWeight(w1, w2) {} static const ExpectationWeight &Zero() { static const ExpectationWeight zero(W1::Zero(), W2::Zero()); return zero; } static const ExpectationWeight &One() { static const ExpectationWeight one(W1::One(), W2::Zero()); return one; } static const ExpectationWeight &NoWeight() { static const ExpectationWeight no_weight(W1::NoWeight(), W2::NoWeight()); return no_weight; } static const std::string &Type() { static const std::string *const type = new std::string("expectation_" + W1::Type() + "_" + W2::Type()); return *type; } ExpectationWeight Quantize(float delta = kDelta) const { return ExpectationWeight(PairWeight::Quantize(delta)); } ReverseWeight Reverse() const { return ReverseWeight(PairWeight::Reverse()); } bool Member() const { return PairWeight::Member(); } static constexpr uint64 Properties() { return W1::Properties() & W2::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(); } // Specialization for enpectation weight. template class Adder> { public: using Weight = ExpectationWeight; Adder() = default; explicit Adder(Weight w) : adder1_(w.Value1()), adder2_(w.Value2()) {} Weight Add(const Weight &w) { adder1_.Add(w.Value1()); adder2_.Add(w.Value2()); return Sum(); } Weight Sum() const { return Weight(adder1_.Sum(), adder2_.Sum()); } void Reset(Weight w = Weight::Zero()) { adder1_.Reset(w.Value1()); adder2_.Reset(w.Value2()); } private: Adder adder1_; Adder adder2_; }; // 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: using Weight = ExpectationWeight; using Generate = WeightGenerate>; explicit WeightGenerate(uint64 seed = std::random_device()(), bool allow_zero = true) : generate_(seed, allow_zero) {} Weight operator()() const { return Weight(generate_()); } private: const Generate generate_; }; } // namespace fst #endif // FST_EXPECTATION_WEIGHT_H_ openfst-1.7.9/src/include/fst/extensions/000077500000000000000000000000001421600557100204145ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/extensions/compress/000077500000000000000000000000001421600557100222475ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/extensions/compress/compress.h000066400000000000000000000630261421600557100242620ustar00rootroot00000000000000// 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 #include #include #include #include #include #include namespace fst { // Identifies stream data as a vanilla compressed FST. static const int32 kCompressMagicNumber = 1858869554; namespace internal { // Expands a Lempel Ziv code and returns the set of code words where // 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; } auto &codeword = (*expanded_code)[i]; if (code[i].first == 0) { codeword.resize(1, code[i].second); } else { const auto &other_codeword = (*expanded_code)[code[i].first - 1]; codeword.resize(other_codeword.size() + 1); std::copy(other_codeword.cbegin(), other_codeword.cend(), codeword.begin()); codeword[other_codeword.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. template class LempelZiv { public: LempelZiv() : dict_number_(0), default_edge_() { root_.current_number = dict_number_++; root_.current_edge = default_edge_; decode_vector_.emplace_back(0, default_edge_); } // Encodes a vector input into output. void BatchEncode(const std::vector &input, std::vector> *output); // Decodes codedvector to output, returning false if the index exceeds the // size. bool BatchDecode(const std::vector> &input, std::vector *output); // Decodes a single dictionary element, returning 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); } } private: 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_; std::vector> decode_vector_; Edge default_edge_; }; template void LempelZiv::BatchEncode( const std::vector &input, std::vector> *output) { for (auto it = input.cbegin(); it != input.cend(); ++it) { auto *temp_node = &root_; while (it != input.cend()) { auto next = temp_node->next_number.find(*it); if (next != temp_node->next_number.cend()) { temp_node = next->second; ++it; } else { break; } } if (it == input.cend() && temp_node->current_number != 0) { output->emplace_back(temp_node->current_number, default_edge_); } else if (it != input.cend()) { output->emplace_back(temp_node->current_number, *it); auto *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.cend()) break; } } template bool LempelZiv::BatchDecode( const std::vector> &input, std::vector *output) { for (auto it = input.cbegin(); it != input.cend(); ++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); } auto 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->cend(), temp_output.begin(), temp_output.end()); } } return true; } template class Compressor { public: using Label = typename Arc::Label; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; Compressor() = default; // Compresses an FST into a boolean vector code, returning true on success. bool Compress(const Fst &fst, std::ostream &strm); // Decompresses the boolean vector into an FST, returning true on success. bool Decompress(std::istream &strm, const std::string &source, MutableFst *fst); // Computes the BFS order of a FST. void BfsOrder(const ExpandedFst &fst, std::vector *order); // Preprocessing step to convert an FST to a isomorphic FST. void Preprocess(const Fst &fst, MutableFst *preprocessedfst, EncodeMapper *encoder); // Performs Lempel Ziv and outputs a stream of integers. void EncodeProcessedFst(const ExpandedFst &fst, std::ostream &strm); // Decodes FST from the stream. void DecodeProcessedFst(const std::vector &input, MutableFst *fst, bool unweighted); // 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, but doesn't remove the final epsilons. void DecodeForCompress(MutableFst *fst, const EncodeMapper &mapper); // Updates buffer_code_. template void WriteToBuffer(CVar input) { std::vector current_code; Elias::DeltaEncode(input, ¤t_code); buffer_code_.insert(buffer_code_.cend(), 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; } } }; 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; } }; 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; } } }; std::vector buffer_code_; std::vector arc_weight_; std::vector final_weight_; }; template void Compressor::DecodeForCompress(MutableFst *fst, const EncodeMapper &mapper) { ArcMap(fst, EncodeMapper(mapper, DECODE)); fst->SetInputSymbols(mapper.InputSymbols()); fst->SetOutputSymbols(mapper.OutputSymbols()); } template void Compressor::BfsOrder(const ExpandedFst &fst, std::vector *order) { class BfsVisitor { public: // Requires order->size() >= fst.NumStates(). explicit BfsVisitor(std::vector *order) : order_(order) {} void InitVisit(const Fst &fst) {} bool InitState(StateId s, StateId) { order_->at(s) = num_bfs_states_++; return true; } bool WhiteArc(StateId s, const Arc &arc) { return true; } bool GreyArc(StateId s, const Arc &arc) { return true; } bool BlackArc(StateId s, const Arc &arc) { return true; } void FinishState(StateId s) {} void FinishVisit() {} private: std::vector *order_ = nullptr; StateId num_bfs_states_ = 0; }; order->assign(fst.NumStates(), kNoStateId); BfsVisitor visitor(order); FifoQueue queue; Visit(fst, &visitor, &queue, AnyArcFilter()); } 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; const auto number_of_states = fst.NumStates(); StateId seen_states = 0; // Adds 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; // Collects the final states. if (fst.Final(state) != Weight::Zero()) { final_states.push_back(state); final_weight_.push_back(fst.Final(state)); } // Reads the states. for (ArcIterator> aiter(fst, state); !aiter.Done(); aiter.Next()) { const auto &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); } } // Adds new states. dict_new.BatchEncode(current_new_input, ¤t_new_output); WriteToBuffer(current_new_output.size()); for (auto it = current_new_output.cbegin(); it != current_new_output.cend(); ++it) { WriteToBuffer(it->first); WriteToBuffer. // See the FarReader interface in far.h for the exact semantics. class FarReaderImplBase { public: virtual const std::string &ArcType() const = 0; virtual bool Done() const = 0; virtual bool Error() const = 0; virtual const std::string &GetKey() const = 0; virtual const FstClass *GetFstClass() const = 0; virtual bool Find(const std::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 std::string &source) : impl_(FarReader::Open(source)) {} explicit FarReaderClassImpl(const std::vector &sources) : impl_(FarReader::Open(sources)) {} const std::string &ArcType() const final { return Arc::Type(); } bool Done() const final { return impl_->Done(); } bool Error() const final { return impl_->Error(); } bool Find(const std::string &key) final { return impl_->Find(key); } const FstClass *GetFstClass() const final { fstc_ = fst::make_unique(*impl_->GetFst()); return fstc_.get(); } const std::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 OpenFarReaderClassArgs = WithReturnValue &>; // Untemplated user-facing class holding a templated pimpl. class FarReaderClass { public: const std::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 std::string &key) { return impl_->Find(key); } const FstClass *GetFstClass() const { return impl_->GetFstClass(); } const std::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(OpenFarReaderClassArgs *args); // Defined in the CC. static FarReaderClass *Open(const std::string &source); static FarReaderClass *Open(const std::vector &sources); 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(OpenFarReaderClassArgs *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 std::string &key, const FstClass &fst) = 0; virtual const std::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 std::string &source, FarType type = FarType::DEFAULT) : impl_(FarWriter::Create(source, type)) {} bool Add(const std::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 std::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 std::string &source, const std::string &arc_type, FarType type = FarType::DEFAULT); bool Add(const std::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 std::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_ openfst-1.7.9/src/include/fst/extensions/far/far.h000066400000000000000000000321611421600557100221100ustar00rootroot00000000000000// 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 class FarEntryType { LINE, FILE }; inline bool IsFst(const std::string &source) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) return false; return IsFstHeader(strm, source); } // FST archive header class class FarHeader { public: const std::string &ArcType() const { return arctype_; } const std::string &FarType() const { return fartype_; } bool Read(const std::string &source) { FstHeader fsthdr; if (source.empty()) { // Header reading unsupported on stdin. Assumes STList and StdArc. fartype_ = "stlist"; arctype_ = "standard"; return true; } else if (IsSTTable(source)) { // Checks if STTable. ReadSTTableHeader(source, &fsthdr); fartype_ = "sttable"; arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType(); return true; } else if (IsSTList(source)) { // Checks if STList. ReadSTListHeader(source, &fsthdr); fartype_ = "stlist"; arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType(); return true; } else if (IsFst(source)) { // Checks if FST. std::ifstream istrm(source, std::ios_base::in | std::ios_base::binary); fsthdr.Read(istrm, source); fartype_ = "fst"; arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType(); return true; } return false; } private: std::string fartype_; std::string arctype_; }; enum class FarType { DEFAULT = 0, STTABLE = 1, STLIST = 2, 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 std::string &source, FarType type = FarType::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 std::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 std::string &source); // 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 &sources); // 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 std::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 std::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 std::string &source) { auto *writer = STTableWriter, FstWriter>::Create(source); return new STTableFarWriter(writer); } void Add(const std::string &key, const Fst &fst) final { writer_->Add(key, fst); } FarType Type() const final { return FarType::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 std::string &source) { auto *writer = STListWriter, FstWriter>::Create(source); return new STListFarWriter(writer); } void Add(const std::string &key, const Fst &fst) final { writer_->Add(key, fst); } FarType Type() const final { return FarType::STLIST; } bool Error() const final { return writer_->Error(); } private: explicit STListFarWriter(STListWriter, FstWriter> *writer) : writer_(writer) {} std::unique_ptr, FstWriter>> writer_; }; template class FstFarWriter final : public FarWriter { public: using Arc = A; explicit FstFarWriter(const std::string &source) : source_(source), error_(false), written_(false) {} static FstFarWriter *Create(const std::string &source) { return new FstFarWriter(source); } void Add(const std::string &key, const Fst &fst) final { if (written_) { LOG(WARNING) << "FstFarWriter::Add: only one FST supported," << " subsequent entries discarded."; } else { error_ = !fst.Write(source_); written_ = true; } } FarType Type() const final { return FarType::FST; } bool Error() const final { return error_; } ~FstFarWriter() final {} private: std::string source_; bool error_; bool written_; }; template FarWriter *FarWriter::Create(const std::string &source, FarType type) { switch (type) { case FarType::DEFAULT: if (source.empty()) return STListFarWriter::Create(source); case FarType::STTABLE: return STTableFarWriter::Create(source); case FarType::STLIST: return STListFarWriter::Create(source); case FarType::FST: return FstFarWriter::Create(source); default: LOG(ERROR) << "FarWriter::Create: Unknown FAR type"; return nullptr; } } template class FstReader { public: Fst *operator()(std::istream &strm, const FstReadOptions &options = FstReadOptions()) const { return Fst::Read(strm, options); } }; template class STTableFarReader : public FarReader { public: using Arc = A; static STTableFarReader *Open(const std::string &source) { auto *reader = STTableReader, FstReader>::Open(source); if (!reader || reader->Error()) return nullptr; return new STTableFarReader(reader); } static STTableFarReader *Open(const std::vector &sources) { auto *reader = STTableReader, FstReader>::Open(sources); if (!reader || reader->Error()) return nullptr; return new STTableFarReader(reader); } void Reset() final { reader_->Reset(); } bool Find(const std::string &key) final { return reader_->Find(key); } bool Done() const final { return reader_->Done(); } void Next() final { return reader_->Next(); } const std::string &GetKey() const final { return reader_->GetKey(); } const Fst *GetFst() const final { return reader_->GetEntry(); } FarType Type() const final { return FarType::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 std::string &source) { auto *reader = STListReader, FstReader>::Open(source); if (!reader || reader->Error()) return nullptr; return new STListFarReader(reader); } static STListFarReader *Open(const std::vector &sources) { auto *reader = STListReader, FstReader>::Open(sources); if (!reader || reader->Error()) return nullptr; return new STListFarReader(reader); } void Reset() final { reader_->Reset(); } bool Find(const std::string &key) final { return reader_->Find(key); } bool Done() const final { return reader_->Done(); } void Next() final { return reader_->Next(); } const std::string &GetKey() const final { return reader_->GetKey(); } const Fst *GetFst() const final { return reader_->GetEntry(); } FarType Type() const final { return FarType::STLIST; } bool Error() const final { return reader_->Error(); } private: explicit STListFarReader(STListReader, FstReader> *reader) : reader_(reader) {} std::unique_ptr, FstReader>> reader_; }; template class FstFarReader final : public FarReader { public: using Arc = A; static FstFarReader *Open(const std::string &source) { std::vector sources; sources.push_back(source); return new FstFarReader(sources); } static FstFarReader *Open(const std::vector &sources) { return new FstFarReader(sources); } explicit FstFarReader(const std::vector &sources) : keys_(sources), has_stdin_(false), pos_(0), error_(false) { std::sort(keys_.begin(), keys_.end()); streams_.resize(keys_.size(), nullptr); for (size_t i = 0; i < keys_.size(); ++i) { if (keys_[i].empty()) { if (!has_stdin_) { streams_[i] = &std::cin; 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 (streams_[i]->fail()) { FSTERROR() << "FstFarReader::FstFarReader: Error reading file: " << sources[i]; error_ = true; return; } } } 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 std::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 std::string &GetKey() const final { return keys_[pos_]; } const Fst *GetFst() const final { return fst_.get(); } FarType Type() const final { return FarType::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 std::string &source) { if (source.empty()) return STListFarReader::Open(source); else if (IsSTTable(source)) return STTableFarReader::Open(source); else if (IsSTList(source)) return STListFarReader::Open(source); else if (IsFst(source)) return FstFarReader::Open(source); return nullptr; } template FarReader *FarReader::Open(const std::vector &sources) { if (!sources.empty() && sources[0].empty()) return STListFarReader::Open(sources); else if (!sources.empty() && IsSTTable(sources[0])) return STTableFarReader::Open(sources); else if (!sources.empty() && IsSTList(sources[0])) return STListFarReader::Open(sources); else if (!sources.empty() && IsFst(sources[0])) return FstFarReader::Open(sources); return nullptr; } } // namespace fst #endif // FST_EXTENSIONS_FAR_FAR_H_ openfst-1.7.9/src/include/fst/extensions/far/farlib.h000066400000000000000000000013261421600557100225760ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/extensions/far/farscript.h000066400000000000000000000265131421600557100233410ustar00rootroot00000000000000// 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_sources; const std::string &out_source; const std::string &fst_type; const FarType &far_type; const int32 generate_keys; const FarEntryType fet; const TokenType tt; const std::string &symbols_source; const std::string &unknown_symbol; const bool keep_symbols; const bool initial_symbols; const bool allow_negative_labels; const std::string &key_prefix; const std::string &key_suffix; FarCompileStringsArgs(const std::vector &in_sources, const std::string &out_source, const std::string &fst_type, const FarType &far_type, int32 generate_keys, FarEntryType fet, TokenType tt, const std::string &symbols_source, const std::string &unknown_symbol, bool keep_symbols, bool initial_symbols, bool allow_negative_labels, const std::string &key_prefix, const std::string &key_suffix) : in_sources(in_sources), out_source(out_source), fst_type(fst_type), far_type(far_type), generate_keys(generate_keys), fet(fet), tt(tt), symbols_source(symbols_source), 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_sources, args->out_source, args->fst_type, args->far_type, args->generate_keys, args->fet, args->tt, args->symbols_source, 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_sources, const std::string &out_source, const std::string &arc_type, const std::string &fst_type, const FarType &far_type, int32 generate_keys, FarEntryType fet, TokenType tt, const std::string &symbols_source, const std::string &unknown_symbol, bool keep_symbols, bool initial_symbols, bool allow_negative_labels, const std::string &key_prefix, const std::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_sources; const std::string &out_source; const int32 generate_keys; const FarType &far_type; const std::string &key_prefix; const std::string &key_suffix; FarCreateArgs(const std::vector &in_sources, const std::string &out_source, const int32 generate_keys, const FarType &far_type, const std::string &key_prefix, const std::string &key_suffix) : in_sources(in_sources), out_source(out_source), generate_keys(generate_keys), far_type(far_type), key_prefix(key_prefix), key_suffix(key_suffix) {} }; template void FarCreate(FarCreateArgs *args) { FarCreate(args->in_sources, args->out_source, args->generate_keys, args->far_type, args->key_prefix, args->key_suffix); } void FarCreate(const std::vector &in_sources, const std::string &out_source, const std::string &arc_type, const int32 generate_keys, const FarType &far_type, const std::string &key_prefix, const std::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 std::string &source1, const std::string &source2, const std::string &arc_type, float delta = kDelta, const std::string &begin_key = std::string(), const std::string &end_key = std::string()); using FarExtractArgs = std::tuple &, int32, const std::string &, const std::string &, const std::string &, const std::string &, const std::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 &isources, const std::string &arc_type, int32 generate_sources, const std::string &keys, const std::string &key_separator, const std::string &range_delimiter, const std::string &source_prefix, const std::string &source_suffix); using FarInfoArgs = std::tuple &, const std::string &, const std::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 &sources, const std::string &arc_type, const std::string &begin_key, const std::string &end_key, const bool list_fsts); using GetFarInfoArgs = std::tuple &, const std::string &, const std::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 &sources, const std::string &arc_type, const std::string &begin_key, const std::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 std::string &source1, const std::string &source2, const std::string &arc_type, float delta = kDelta, const std::string &begin_key = std::string(), const std::string &end_key = std::string()); struct FarPrintStringsArgs { const std::vector &isources; const FarEntryType entry_type; const TokenType token_type; const std::string &begin_key; const std::string &end_key; const bool print_key; const bool print_weight; const std::string &symbols_source; const bool initial_symbols; const int32 generate_sources; const std::string &source_prefix; const std::string &source_suffix; FarPrintStringsArgs(const std::vector &isources, const FarEntryType entry_type, const TokenType token_type, const std::string &begin_key, const std::string &end_key, const bool print_key, const bool print_weight, const std::string &symbols_source, const bool initial_symbols, const int32 generate_sources, const std::string &source_prefix, const std::string &source_suffix) : isources(isources), 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_source(symbols_source), initial_symbols(initial_symbols), generate_sources(generate_sources), source_prefix(source_prefix), source_suffix(source_suffix) {} }; template void FarPrintStrings(FarPrintStringsArgs *args) { fst::FarPrintStrings( args->isources, args->entry_type, args->token_type, args->begin_key, args->end_key, args->print_key, args->print_weight, args->symbols_source, args->initial_symbols, args->generate_sources, args->source_prefix, args->source_suffix); } void FarPrintStrings(const std::vector &isources, const std::string &arc_type, const FarEntryType entry_type, const TokenType token_type, const std::string &begin_key, const std::string &end_key, const bool print_key, const bool print_weight, const std::string &symbols_source, const bool initial_symbols, const int32 generate_sources, const std::string &source_prefix, const std::string &source_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_ openfst-1.7.9/src/include/fst/extensions/far/getters.h000066400000000000000000000013761421600557100230210ustar00rootroot00000000000000// 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 #include namespace fst { namespace script { bool GetFarType(const std::string &str, FarType *far_type); bool GetFarEntryType(const std::string &str, FarEntryType *entry_type); void ExpandArgs(int argc, char **argv, int *argcp, char ***argvp); } // namespace script std::string GetFarTypeString(FarType far_type); } // namespace fst #endif // FST_EXTENSIONS_FAR_GETTERS_H_ openfst-1.7.9/src/include/fst/extensions/far/info.h000066400000000000000000000116561421600557100223010ustar00rootroot00000000000000// 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 { std::string key; std::string type; size_t nstate = 0; size_t narc = 0; size_t nfinal = 0; }; struct FarInfoData { std::vector key_infos; std::string far_type; std::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 &sources, const std::string &begin_key, const std::string &end_key, const bool list_fsts, FarInfoData *far_info) { *far_info = FarInfoData(); std::unique_ptr> reader(FarReader::Open(sources)); 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 &sources, const std::string &begin_key, const std::string &end_key, const bool list_fsts) { FarInfoData info; GetFarInfo(sources, 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_ openfst-1.7.9/src/include/fst/extensions/far/isomorphic.h000066400000000000000000000044311421600557100235130ustar00rootroot00000000000000// 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 std::string &source1, const std::string &source2, float delta = kDelta, const std::string &begin_key = std::string(), const std::string &end_key = std::string()) { std::unique_ptr> reader1(FarReader::Open(source1)); if (!reader1) { LOG(ERROR) << "FarIsomorphic: Cannot open FAR file " << source1; return false; } std::unique_ptr> reader2(FarReader::Open(source2)); if (!reader2) { LOG(ERROR) << "FarIsomorphic: Cannot open FAR file " << source2; 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_ openfst-1.7.9/src/include/fst/extensions/far/print-strings.h000066400000000000000000000062331421600557100241640ustar00rootroot00000000000000// 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 &isources, FarEntryType entry_type, TokenType token_type, const std::string &begin_key, const std::string &end_key, bool print_key, bool print_weight, const std::string &symbols_source, bool initial_symbols, int32 generate_sources, const std::string &source_prefix, const std::string &source_suffix) { std::unique_ptr syms; if (!symbols_source.empty()) { // TODO(kbg): Allow negative flag? const SymbolTableTextOptions opts(true); syms.reset(SymbolTable::ReadText(symbols_source, opts)); if (!syms) { LOG(ERROR) << "FarPrintStrings: Error reading symbol table " << symbols_source; return; } } std::unique_ptr> far_reader(FarReader::Open(isources)); if (!far_reader) return; if (!begin_key.empty()) far_reader->Find(begin_key); std::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()); } std::string str; VLOG(2) << "Handling key: " << key; const StringPrinter printer(token_type, syms ? syms.get() : fst->InputSymbols(), /*omit_epsilon=*/false); printer(*fst, &str); if (entry_type == FarEntryType::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 == FarEntryType::FILE) { std::stringstream sstrm; if (generate_sources) { sstrm.fill('0'); sstrm << std::right << std::setw(generate_sources) << i; } else { sstrm << key; if (nrep > 0) sstrm << "." << nrep; } std::string source; source = source_prefix + sstrm.str() + source_suffix; std::ofstream ostrm(source); if (!ostrm) { LOG(ERROR) << "FarPrintStrings: Can't open file: " << source; return; } ostrm << str; if (token_type == TokenType::SYMBOL) ostrm << "\n"; } } } } // namespace fst #endif // FST_EXTENSIONS_FAR_PRINT_STRINGS_H_ openfst-1.7.9/src/include/fst/extensions/far/script-impl.h000066400000000000000000000011451421600557100236010ustar00rootroot00000000000000// 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 { std::string LoadArcTypeFromFar(const std::string &far_source); std::string LoadArcTypeFromFst(const std::string &fst_source); } // namespace script } // namespace fst #endif // FST_EXTENSIONS_FAR_SCRIPT_IMPL_H_ openfst-1.7.9/src/include/fst/extensions/far/stlist.h000066400000000000000000000202761421600557100226660ustar00rootroot00000000000000// 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 std::string &source) : stream_(source.empty() ? &std::cout : new std::ofstream( source, 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: " << source; error_ = true; } } static STListWriter *Create(const std::string &source) { return new STListWriter(source); } void Add(const std::string &key, const T &t) { if (key.empty()) { 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_, std::string()); if (stream_ != &std::cout) delete stream_; } private: Writer entry_writer_; std::ostream *stream_; // Output stream. std::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 &sources) : sources_(sources), error_(false) { streams_.resize(sources.size(), nullptr); bool has_stdin = false; for (size_t i = 0; i < sources.size(); ++i) { if (sources[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( sources[i], std::ios_base::in | std::ios_base::binary); if (streams_[i]->fail()) { FSTERROR() << "STListReader::STListReader: Error reading file: " << sources[i]; error_ = true; return; } } 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: " << sources[i]; error_ = true; return; } if (file_version != kSTListFileVersion) { FSTERROR() << "STListReader::STListReader: Wrong file version: " << sources[i]; error_ = true; return; } std::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 std::string &source) { std::vector sources; sources.push_back(source); return new STListReader(sources); } static STListReader *Open( const std::vector &sources) { return new STListReader(sources); } void Reset() { FSTERROR() << "STListReader::Reset: Operation not supported"; error_ = true; } bool Find(const std::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; std::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 std::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 sources. std::priority_queue, 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 &source); // }; template bool ReadSTListHeader(const std::string &source, Header *header) { if (source.empty()) { LOG(ERROR) << "ReadSTListHeader: Can't read header from standard input"; return false; } std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "ReadSTListHeader: Could not open file: " << source; 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: " << source; return false; } if (file_version != kSTListFileVersion) { LOG(ERROR) << "ReadSTListHeader: Wrong file version: " << source; return false; } std::string key; ReadType(strm, &key); header->Read(strm, source + ":" + key); if (!strm) { LOG(ERROR) << "ReadSTListHeader: Error reading file: " << source; return false; } return true; } bool IsSTList(const std::string &source); } // namespace fst #endif // FST_EXTENSIONS_FAR_STLIST_H_ openfst-1.7.9/src/include/fst/extensions/far/sttable.h000066400000000000000000000256641421600557100230100ustar00rootroot00000000000000// 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 std::string &source) : stream_(source, 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: " << source; error_ = true; } } static STTableWriter *Create(const std::string &source) { if (source.empty()) { LOG(ERROR) << "STTableWriter: Writing to standard out unsupported."; return nullptr; } return new STTableWriter(source); } void Add(const std::string &key, const T &t) { if (key.empty()) { 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. std::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 &sources) : sources_(sources), error_(false) { compare_.reset(new Compare(&keys_)); keys_.resize(sources.size()); streams_.resize(sources.size(), nullptr); positions_.resize(sources.size()); for (size_t i = 0; i < sources.size(); ++i) { streams_[i] = new std::ifstream( sources[i], std::ios_base::in | std::ios_base::binary); if (streams_[i]->fail()) { FSTERROR() << "STTableReader::STTableReader: Error reading file: " << sources[i]; error_ = true; return; } 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: " << sources[i]; error_ = true; return; } if (file_version != kSTTableFileVersion) { FSTERROR() << "STTableReader::STTableReader: Wrong file version: " << sources[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: " << sources[i]; error_ = true; return; } } } MakeHeap(); } ~STTableReader() { for (auto &stream : streams_) delete stream; } static STTableReader *Open(const std::string &source) { if (source.empty()) { LOG(ERROR) << "STTableReader: Operation not supported on standard input"; return nullptr; } std::vector sources; sources.push_back(source); return new STTableReader(sources); } static STTableReader *Open( const std::vector &sources) { return new STTableReader(sources); } void Reset() { if (error_) return; for (size_t i = 0; i < streams_.size(); ++i) streams_[i]->seekg(positions_[i].front()); MakeHeap(); } bool Find(const std::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 std::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 std::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]); std::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 &source); // }; template bool ReadSTTableHeader(const std::string &source, Header *header) { if (source.empty()) { LOG(ERROR) << "ReadSTTable: Can't read header from standard input"; return false; } std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "ReadSTTableHeader: Could not open file: " << source; 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: " << source; return false; } if (file_version != kSTTableFileVersion) { LOG(ERROR) << "ReadSTTableHeader: Wrong file version: " << source; 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: " << source; 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); std::string key; ReadType(strm, &key); header->Read(strm, source + ":" + key); if (strm.fail()) { LOG(ERROR) << "ReadSTTableHeader: Error reading file: " << source; return false; } return true; } bool IsSTTable(const std::string &source); } // namespace fst #endif // FST_EXTENSIONS_FAR_STTABLE_H_ openfst-1.7.9/src/include/fst/extensions/linear/000077500000000000000000000000001421600557100216665ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/extensions/linear/linear-fst-data-builder.h000066400000000000000000001204701421600557100264420ustar00rootroot00000000000000// 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 #include namespace fst { // Forward declaration template class FeatureGroupBuilder; // For logging purposes inline std::string TranslateLabel(int64 label, const SymbolTable *syms); template std::string JoinLabels(Iterator begin, Iterator end, const SymbolTable *syms); template std::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; std::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 std::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 std::string TranslateLabel(int64 label, const SymbolTable *syms) { std::string ret; if (syms != nullptr) ret += syms->Find(label); if (ret.empty()) { std::ostringstream strm; strm << '<' << label << '>'; ret = strm.str(); } return ret; } template std::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 std::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_ openfst-1.7.9/src/include/fst/extensions/linear/linear-fst-data.h000066400000000000000000000424421421600557100250200ustar00rootroot00000000000000// 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_; } std::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; explicit 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 std::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 std::string &source) { if (!source.empty()) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "LinearTaggerFst::Read: Can't open file: " << source; return nullptr; } return Read(strm, FstReadOptions(source)); } 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 std::string &source) const override { if (!source.empty()) { std::ofstream strm(source, std::ios_base::out | std::ios_base::binary); if (!strm) { LOG(ERROR) << "LinearTaggerFst::Write: Can't open file: " << source; return false; } return Write(strm, FstWriteOptions(source)); } 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 std::string &source) { if (!source.empty()) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "LinearClassifierFst::Read: Can't open file: " << source; return nullptr; } return Read(strm, FstReadOptions(source)); } 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 std::string &source) const override { if (!source.empty()) { std::ofstream strm(source, std::ios_base::out | std::ios_base::binary); if (!strm) { LOG(ERROR) << "ProdLmFst::Write: Can't open file: " << source; return false; } return Write(strm, FstWriteOptions(source)); } 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_ openfst-1.7.9/src/include/fst/extensions/linear/linearscript.h000066400000000000000000000353271421600557100245500ustar00rootroot00000000000000// 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 { using LinearCompileArgs = std::tuple; 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 std::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 std::string &str, const char delim, SymbolTable *syms, std::vector *output) { if (str == FLAGS_empty_symbol) return; std::istringstream strm(str); std::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 std::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 std::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 std::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 std::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 std::string &model, SymbolTable *fsyms, SymbolTable *osyms, LinearFstDataBuilder *builder) { std::ifstream in(model); if (!in) LOG(FATAL) << "Can't open file: " << model; std::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 std::string &model, SymbolTable *fsyms, SymbolTable *osyms, LinearClassifierFstDataBuilder *builder) { std::ifstream in(model); if (!in) LOG(FATAL) << "Can't open file: " << model; std::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 std::string &str, std::vector *out); int ScanNumClasses(char **models, int models_length); template void LinearCompileTpl(LinearCompileArgs *args) { const std::string &epsilon_symbol = std::get<0>(*args); const std::string &unknown_symbol = std::get<1>(*args); const std::string &vocab = std::get<2>(*args); char **models = std::get<3>(*args); const int models_length = std::get<4>(*args); const std::string &out = std::get<5>(*args); const std::string &save_isymbols = std::get<6>(*args); const std::string &save_fsymbols = std::get<7>(*args); const std::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 std::string &arc_type, const std::string &epsilon_symbol, const std::string &unknown_symbol, const std::string &vocab, char **models, int models_len, const std::string &out, const std::string &save_isymbols, const std::string &save_fsymbols, const std::string &save_osymbols); template bool GetVocabRecord(const std::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) { std::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 std::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) { std::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]); GuessStartOrEnd(input_labels, kNoLabel); GuessStartOrEnd(output_labels, kNoLabel); return true; } } // namespace script } // namespace fst #endif // FST_EXTENSIONS_LINEAR_LINEARSCRIPT_H_ openfst-1.7.9/src/include/fst/extensions/linear/loglinear-apply.h000066400000000000000000000052521421600557100251420ustar00rootroot00000000000000// 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, ProjectType::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_ openfst-1.7.9/src/include/fst/extensions/linear/trie.h000066400000000000000000000312771421600557100230140ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/extensions/mpdt/000077500000000000000000000000001421600557100213605ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/extensions/mpdt/compose.h000066400000000000000000000243531421600557100232050ustar00rootroot00000000000000// 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> &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_ openfst-1.7.9/src/include/fst/extensions/mpdt/info.h000066400000000000000000000140431421600557100224660ustar00rootroot00000000000000// 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 #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) { auto impl = fst::make_unique>(); FstHeader hdr; if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return nullptr; 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 = static_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()) return nullptr; impl->Init(data, false, data_region); return impl.release(); } 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 = nullptr; 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 std::string &source) { if (!source.empty()) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm.good()) { LOG(ERROR) << "NGramFst::Read: Can't open file: " << source; return nullptr; } return Read(strm, FstReadOptions(source)); } 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 std::string &source) const override { return Fst::WriteFile(source); } 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) { static const auto 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); std::vector::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, /*enable_select_0_index=*/true, /*enable_select_1_index=*/true); future_index_.BuildIndex(future_, future_bits, /*enable_select_0_index=*/true, /*enable_select_1_index=*/false); 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; } } uint8 Flags() const final { return flags_; } void SetFlags(uint8 flags, uint8 mask) final { flags_ &= ~mask; flags_ |= (flags & kArcValueFlags); } private: mutable Arc arc_; mutable uint8 lazy_; const internal::NGramFstImpl *impl_; // Borrowed reference. mutable NGramFstInst inst_; size_t i_; uint8 flags_; }; } // namespace fst #endif // FST_EXTENSIONS_NGRAM_NGRAM_FST_H_ openfst-1.7.9/src/include/fst/extensions/ngram/nthbit.h000066400000000000000000000064141421600557100231660ustar00rootroot00000000000000// 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 #include #include #if defined(__BMI2__) // Intel Bit Manipulation Instruction Set 2 // PDEP requires BMI2; this is present starting with Haswell. #include namespace fst { // Returns the position (0-63) of the r-th 1 bit in v. // 0 <= r < CountOnes(v) <= 64. Therefore, v must not be 0. inline uint32 nth_bit(uint64 v, uint32 r) { DCHECK_NE(v, 0); DCHECK_LE(0, r); DCHECK_LT(r, __builtin_popcountll(v)); // PDEP example from https://stackoverflow.com/a/27453505 return __builtin_ctzll(_pdep_u64(uint64{1} << r, v)); } } // namespace fst #elif SIZE_MAX == UINT32_MAX // Detect 32-bit architectures via size_t. namespace fst { // Returns the position (0-63) of the r-th 1 bit in v. // 0 <= r < CountOnes(v) <= 64. Therefore, v must not be 0. uint32 nth_bit(uint64 v, uint32 r); } // namespace fst #elif SIZE_MAX == UINT64_MAX // Default 64-bit version, used by ARM64 and Intel < Haswell. namespace fst { namespace internal { extern const uint64 kPrefixSumOverflow[64]; extern const uint8 kSelectInByte[2048]; } // namespace internal // Returns the position (0-63) of the r-th 1 bit in v. // 0 <= r < CountOnes(v) <= 64. Therefore, v must not be 0. // // This version is based on the paper "Broadword Implementation of // Rank/Select Queries" by Sebastiano Vigna, p. 5, Algorithm 2, with // improvements from "Optimized Succinct Data Structures for Massive Data" // by Gog & Petri, 2014. inline uint32 nth_bit(const uint64 v, const uint32 r) { constexpr uint64 kOnesStep4 = 0x1111111111111111; constexpr uint64 kOnesStep8 = 0x0101010101010101; constexpr uint64 kMSBsStep8 = 0x80 * kOnesStep8; DCHECK_NE(v, 0); DCHECK_LE(0, r); DCHECK_LT(r, __builtin_popcountll(v)); uint64 s = v; s = s - ((s >> 1) & (0x5 * kOnesStep4)); s = (s & (0x3 * kOnesStep4)) + ((s >> 2) & (0x3 * kOnesStep4)); s = (s + (s >> 4)) & (0xF * kOnesStep8); // s now contains the byte-wise popcounts of v. // byte_sums contains partial sums of the byte-wise popcounts. // That is, byte i contains the popcounts of bytes <= i. uint64 byte_sums = s * kOnesStep8; // kPrefixSumOverflow[r] == (0x7F - r) * kOnesStep8, so the high bit is // still set if byte_sums - r > 0, or byte_sums > r. The first one set // is in the byte with the sum larger than r (since r is 0-based), // so this is the byte we need. const uint64 b = (byte_sums + internal::kPrefixSumOverflow[r]) & kMSBsStep8; // The first bit set is the high bit in the byte, so // num_trailing_zeros == 8 * byte_nr + 7 and the byte number is the // number of trailing zeros divided by 8. const int byte_nr = __builtin_ctzll(b) >> 3; const int shift = byte_nr << 3; // The top byte contains the whole-word popcount; we never need that. byte_sums <<= 8; // Paper uses reinterpret_cast; use shift/mask instead. const int rank_in_byte = r - (byte_sums >> shift) & 0xFF; return shift + internal::kSelectInByte[(rank_in_byte << 8) + ((v >> shift) & 0xFF)]; } } // namespace fst #else #error Unrecognized architecture size #endif #endif // FST_EXTENSIONS_NGRAM_NTHBIT_H_ openfst-1.7.9/src/include/fst/extensions/pdt/000077500000000000000000000000001421600557100212035ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/extensions/pdt/collection.h000066400000000000000000000055501421600557100235140ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/extensions/pdt/compose.h000066400000000000000000000405201421600557100230220ustar00rootroot00000000000000// 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> &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> &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_ openfst-1.7.9/src/include/fst/extensions/pdt/expand.h000066400000000000000000001037611421600557100226430ustar00rootroot00000000000000// 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 #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 == nullptr), own_state_table_(opts.state_table == nullptr), 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; explicit 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_ openfst-1.7.9/src/include/fst/extensions/pdt/getters.h000066400000000000000000000010371421600557100230320ustar00rootroot00000000000000// 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 std::string &str, PdtComposeFilter *cf); bool GetPdtParserType(const std::string &str, PdtParserType *pt); } // namespace script } // namespace fst #endif // FST_EXTENSIONS_PDT_GETTERS_H_ openfst-1.7.9/src/include/fst/extensions/pdt/info.h000066400000000000000000000107451421600557100223160ustar00rootroot00000000000000// 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 #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 std::string &FstType() const { return fst_type_; } const std::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: std::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>; // 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 = IntersectFst(ifst1, ifst2, nopts); break; } case SEQUENCE_FILTER: { IntersectFstOptions iopts; iopts.gc_limit = 0; *ofst = IntersectFst(ifst1, ifst2, iopts); break; } case ALT_SEQUENCE_FILTER: { IntersectFstOptions> iopts; iopts.gc_limit = 0; *ofst = IntersectFst(ifst1, ifst2, iopts); break; } case MATCH_FILTER: { IntersectFstOptions> iopts; iopts.gc_limit = 0; *ofst = IntersectFst(ifst1, ifst2, iopts); break; } case NO_MATCH_FILTER: { IntersectFstOptions> iopts; iopts.gc_limit = 0; *ofst = IntersectFst(ifst1, ifst2, iopts); break; } case NULL_FILTER: { IntersectFstOptions> iopts; iopts.gc_limit = 0; *ofst = IntersectFst(ifst1, ifst2, iopts); break; } case TRIVIAL_FILTER: { IntersectFstOptions> iopts; iopts.gc_limit = 0; *ofst = IntersectFst(ifst1, ifst2, iopts); break; } } if (opts.connect) Connect(ofst); } } // namespace fst #endif // FST_INTERSECT_H_ openfst-1.7.9/src/include/fst/interval-set.h000066400000000000000000000301071421600557100210040ustar00rootroot00000000000000// 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 #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) {} VectorIntervalStore(std::initializer_list intervals_init) : intervals_(intervals_init), 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; IntervalSet(std::initializer_list intervals_init) : intervals_(intervals_init) {} 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_ openfst-1.7.9/src/include/fst/invert.h000066400000000000000000000074661421600557100177120ustar00rootroot00000000000000// 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 #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_ openfst-1.7.9/src/include/fst/isomorphic.h000066400000000000000000000215251421600557100205470ustar00rootroot00000000000000// 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. False negatives (but not false positives) are possible // when the inputs are nondeterministic (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; delta is ignored. template ::value>::type * = nullptr> bool WeightCompare(const Weight &w1, const Weight &w2, float, bool *) { static const NaturalLess less; return less(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); const auto n1 = q1.Hash(); const 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), nondet_(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) { VLOG(1) << "Isomorphic: Only one of the FSTs is empty."; return false; } PairState(fst1_->Start(), fst2_->Start()); while (!queue_.empty()) { const auto &pr = queue_.front(); if (!IsIsomorphicState(pr.first, pr.second)) { if (nondet_) { VLOG(1) << "Isomorphic: Non-determinism as an unweighted automaton. " << "state1: " << pr.first << " state2: " << pr.second; error_ = true; } return false; } queue_.pop(); } 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; if (!ApproxEqual(arc1.weight, arc2.weight, delta_)) { return WeightCompare(arc1.weight, arc2.weight, delta_, error_); } else { return arc1.nextstate < arc2.nextstate; } } private: const 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. } VLOG(3) << "Pairing states: (" << s1 << ", " << s2 << ")"; state_pairs_[s1] = s2; queue_.emplace(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::queue> queue_; // Queue of state pairs. bool error_; // Error flag. bool nondet_; // Nondeterminism detected. ArcCompare comp_; }; template bool Isomorphism::IsIsomorphicState(StateId s1, StateId s2) { if (!ApproxEqual(fst1_->Final(s1), fst2_->Final(s2), delta_)) { VLOG(1) << "Isomorphic: Final weights not equal to within delta=" << delta_ << ": " // << "fst1.Final(" << s1 << ") = " << fst1_->Final(s1) << ", " << "fst2.Final(" << s2 << ") = " << fst2_->Final(s2); return false; } const auto narcs1 = fst1_->NumArcs(s1); const auto narcs2 = fst2_->NumArcs(s2); if (narcs1 != narcs2) { VLOG(1) << "Isomorphic: NumArcs not equal. " << "fst1.NumArcs(" << s1 << ") = " << narcs1 << ", " << "fst2.NumArcs(" << s2 << ") = " << 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) { VLOG(1) << "Isomorphic: ilabels not equal. " << "arc1: *" << arc1.ilabel << "* " << arc1.olabel << " " << arc1.weight << " " << arc1.nextstate << "arc2: *" << arc2.ilabel << "* " << arc2.olabel << " " << arc2.weight << " " << arc2.nextstate; return false; } if (arc1.olabel != arc2.olabel) { VLOG(1) << "Isomorphic: olabels not equal. " << "arc1: " << arc1.ilabel << " *" << arc1.olabel << "* " << arc1.weight << " " << arc1.nextstate << "arc2: " << arc2.ilabel << " *" << arc2.olabel << "* " << arc2.weight << " " << arc2.nextstate; return false; } if (!ApproxEqual(arc1.weight, arc2.weight, delta_)) { VLOG(1) << "Isomorphic: weights not ApproxEqual. " << "arc1: " << arc1.ilabel << " " << arc1.olabel << " *" << arc1.weight << "* " << arc1.nextstate << "arc2: " << arc2.ilabel << " " << arc2.olabel << " *" << arc2.weight << "* " << arc2.nextstate; return false; } if (!PairState(arc1.nextstate, arc2.nextstate)) { VLOG(1) << "Isomorphic: nextstates could not be paired. " << "arc1: " << arc1.ilabel << " " << arc1.olabel << " " << arc1.weight << " *" << arc1.nextstate << "* arc2: " << arc2.ilabel << " " << arc2.olabel << " " << arc2.weight << " *" << 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_)) { // Any subsequent matching failure maybe a false negative // since we only consider one permutation when pairing destination // states of nondeterministic transitions. VLOG(1) << "Isomorphic: Detected non-determinism as an unweighted " << "automaton; deferring error. " << "arc1: " << arc1.ilabel << " " << arc1.olabel << " " << arc1.weight << " " << arc1.nextstate << "arc2: " << arc2.ilabel << " " << arc2.olabel << " " << arc2.weight << " " << arc2.nextstate; nondet_ = true; } } } return true; } } // namespace internal // Tests if two FSTs have the same states and arcs up to a reordering. // Inputs should be nondeterministic when viewed as unweighted automata. // When the inputs are nondeterministic, the algorithm only considers one // permutation for each set of equivalent nondeterministic transitions // (the permutation that preserves state ID ordering) and hence might return // false negatives (but it never returns false positives). template bool Isomorphic(const Fst &fst1, const Fst &fst2, float delta = kDelta) { internal::Isomorphism iso(fst1, fst2, delta); const 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_ openfst-1.7.9/src/include/fst/label-reachable.h000066400000000000000000000511351421600557100213560ustar00rootroot00000000000000// 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 #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_ openfst-1.7.9/src/include/fst/mapped-file.h000066400000000000000000000066631421600557100205640ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #ifndef FST_MAPPED_FILE_H_ #define FST_MAPPED_FILE_H_ #ifdef _WIN32 #include #include #endif #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; size_t offset; #ifdef _WIN32 HANDLE file_mapping; #endif }; 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 std::string &source, size_t size); // Returns a MappedFile object that contains the contents of the file referred // to by the file descriptor starting from pos with size bytes. If the // memory mapping fails, nullptr is returned. In contrast to Map(), this // factory function does not backoff to allocating and reading. static MappedFile *MapFromFileDescriptor(int fd, size_t pos, 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, size_t align = kArchAlignment); // Creates a MappedFile object with a new'ed block of memory with enough // space for count elements of type T, correctly aligned for the type. // This is RECOMMENDED FOR INTERNAL USE ONLY as it may change in future // releases. template static MappedFile *AllocateType(size_t count) { return Allocate(sizeof(T) * count, alignof(T)); } // 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 size_t 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_ openfst-1.7.9/src/include/fst/matcher-fst.h000066400000000000000000000276341421600557100206170ustar00rootroot00000000000000// 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 #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)) {} // Constructs a MatcherFst from an FST, which is the underlying FST type used // by this class. Uses the existing Data if present, and runs Init on it. // Stores fst internally, making a thread-safe copy of it. explicit MatcherFst(const FST &fst, std::shared_ptr data = nullptr) : ImplToExpandedFst(data ? CreateImpl(fst, Name, data) : CreateDataAndImpl(fst, Name)) {} // Constructs a MatcherFst from an Fst, which is *not* the underlying // FST type used by this class. Uses the existing Data if present, and // runs Init on it. Stores fst internally, converting Fst to FST and // therefore making a deep copy. explicit MatcherFst(const Fst &fst, std::shared_ptr data = nullptr) : ImplToExpandedFst(data ? CreateImpl(fst, Name, data) : 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 source reads from standard input static MatcherFst *Read(const std::string &source) { auto *impl = ImplToExpandedFst::Read(source); 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 std::string &source) const override { return Fst::WriteFile(source); } 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; // Makes a thread-safe copy of fst. static std::shared_ptr CreateDataAndImpl(const FST &fst, const std::string &name) { FstMatcher imatcher(fst, MATCH_INPUT); FstMatcher omatcher(fst, MATCH_OUTPUT); return CreateImpl(fst, name, std::make_shared(imatcher.GetSharedData(), omatcher.GetSharedData())); } // Makes a deep copy of fst. static std::shared_ptr CreateDataAndImpl(const Fst &fst, const std::string &name) { FST result(fst); return CreateDataAndImpl(result, name); } // Makes a thread-safe copy of fst. static std::shared_ptr CreateImpl(const FST &fst, const std::string &name, std::shared_ptr data) { auto impl = std::make_shared(fst, name); impl->SetAddOn(data); Init init(&impl); return impl; } // Makes a deep copy of fst. static std::shared_ptr CreateImpl(const Fst &fst, const std::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_ openfst-1.7.9/src/include/fst/matcher.h000066400000000000000000001452601421600557100200210ustar00rootroot00000000000000// 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 #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_. // If multiple elements are equal to the `match_label_`, returns the rightmost // one. template inline bool SortedMatcher::BinarySearch() { size_t size = narcs_; if (size == 0) { return false; } size_t high = size - 1; while (size > 1) { const size_t half = size / 2; const size_t mid = high - half; aiter_->Seek(mid); if (GetLabel() >= match_label_) { high = mid; } size -= half; } aiter_->Seek(high); const auto label = GetLabel(); if (label == match_label_) { return true; } if (label < match_label_) { aiter_->Next(); } return false; } // 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), state_table_(std::make_shared()) { 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_), state_table_(safe ? std::make_shared() : matcher.state_table_) {} 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_; std::shared_ptr state_table_; // Table from state 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_ = fst::make_unique>(fst_, state_); if (match_type_ == MATCH_NONE) { FSTERROR() << "HashMatcher: Bad match type"; error_ = true; } // Attempts to insert a new label table. auto it_and_success = state_table_->emplace( state_, std::unique_ptr(new LabelTable())); // Sets instance's pointer to the label table for this state. label_table_ = it_and_success.first->second.get(); // If it already exists, no additional work is done and we simply return. if (!it_and_success.second) return; // Otherwise, populate this new table. // 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); label_it_ = range.first; label_end_ = range.second; if (label_it_ == label_end_) return false; 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_ = fst::make_unique>(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_ = fst::make_unique>(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_ openfst-1.7.9/src/include/fst/memory.h000066400000000000000000000311371421600557100177030ustar00rootroot00000000000000// 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 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_ openfst-1.7.9/src/include/fst/minimize.h000066400000000000000000000501011421600557100202040ustar00rootroot00000000000000// 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 #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()) { const 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.emplace(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_); static const ILabelCompare icomp; ArcSort(&Tr_, icomp); // 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_ = fst::make_unique(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()) { const auto 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.emplace(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], std::move(arc)); } } } } fst->SetStart(state_map[partition.ClassId(fst->Start())]); Connect(fst); } template void AcceptorMinimize(MutableFst *fst) { // Connects FST before minimization, handles disconnected states. Connect(fst); if (fst->Start() == kNoStateId) return; // The Revuz acyclic algorithm won't work for nondeterministic inputs, so if // the input is nondeterministic, we force the use of the Hopcroft cyclic // algorithm instead. static constexpr auto revuz_props = kAcyclic | kIDeterministic; if (fst->Properties(revuz_props, true) == revuz_props) { // Acyclic minimization (Revuz). VLOG(2) << "Acyclic minimization"; static const ILabelCompare comp; ArcSort(fst, comp); 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; this has // complexity O(e). // // In cyclic and non-deterministic cases, 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; static constexpr auto minimize_props = kAcceptor | kIDeterministic | kWeighted | kUnweighted; const auto props = fst->Properties(minimize_props, true); if (!(props & kIDeterministic)) { // 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; } } if ((props & kAcceptor) != kAcceptor) { // 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(&gfst, &encoder); internal::AcceptorMinimize(&gfst); 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) == kWeighted) { // Weighted acceptor. Push(fst, REWEIGHT_TO_INITIAL, delta); ArcMap(fst, QuantizeMapper(delta)); // We encode labels even though this is already an acceptor because weight // encoding gives us a transducer. EncodeMapper encoder(kEncodeLabels | kEncodeWeights); Encode(fst, &encoder); internal::AcceptorMinimize(fst); Decode(fst, encoder); } else { // Unweighted acceptor. internal::AcceptorMinimize(fst); } } } // namespace fst #endif // FST_MINIMIZE_H_ openfst-1.7.9/src/include/fst/mutable-fst.h000066400000000000000000000276241421600557100206240ustar00rootroot00000000000000// 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 #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 s, Weight weight = Weight::One()) = 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 multiple states. virtual void AddStates(size_t) = 0; // Adds an arc to state. virtual void AddArc(StateId, const Arc &) = 0; // Adds an arc (passed by rvalue reference) to state. Allows subclasses // to optionally implement move semantics. Defaults to lvalue overload. virtual void AddArc(StateId state, Arc &&arc) { AddArc(state, arc); } // 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) = 0; // Delete all arcs at a given state. virtual void DeleteArcs(StateId) = 0; // Optional, best effort only. virtual void ReserveStates(size_t) {} // Optional, best effort only. virtual void ReserveArcs(StateId, size_t) {} // 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 // source 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 std::string &source, bool convert = false, const std::string &convert_type = "vector") { if (convert == false) { if (!source.empty()) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); if (!strm) { LOG(ERROR) << "MutableFst::Read: Can't open file: " << source; return nullptr; } return Read(strm, FstReadOptions(source)); } else { return Read(std::cin, FstReadOptions("standard input")); } } else { // Converts to 'convert_type' if not mutable. std::unique_ptr> ifst(Fst::Read(source)); 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); } uint8 Flags() const { return data_.base->Flags(); } void SetFlags(uint8 flags, uint8 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 = Weight::One()) 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 AddStates(size_t n) override { MutateCheck(); return GetMutableImpl()->AddStates(n); } void AddArc(StateId s, const Arc &arc) override { MutateCheck(); GetMutableImpl()->AddArc(s, arc); } void AddArc(StateId s, Arc &&arc) override { MutateCheck(); GetMutableImpl()->AddArc(s, std::forward(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(size_t n) override { MutateCheck(); GetMutableImpl()->ReserveStates(n); } 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_ openfst-1.7.9/src/include/fst/pair-weight.h000066400000000000000000000102161421600557100206060ustar00rootroot00000000000000// 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(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); } 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(uint64 seed = std::random_device()(), bool allow_zero = true) : generate1_(seed, allow_zero), generate2_(seed, allow_zero) {} Weight operator()() const { return Weight(generate1_(), generate2_()); } private: const Generate1 generate1_; const Generate2 generate2_; }; } // namespace fst #endif // FST_PAIR_WEIGHT_H_ openfst-1.7.9/src/include/fst/partition.h000066400000000000000000000304541421600557100204050ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/power-weight-mappers.h000066400000000000000000000054461421600557100224650ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Conversions to/from PowerWeight and SparsePowerWeight. #ifndef FST_POWER_WEIGHT_MAPPERS_H_ #define FST_POWER_WEIGHT_MAPPERS_H_ namespace fst { // Converts FromWeight to ToPowerWeight (with one component). // ToPowerWeight may be PowerWeight or SparsePowerWeight. template class ToPowerWeightMapper { public: using FromWeight = FromWeight_; using ToWeight = ToPowerWeight; using Index = typename ToPowerWeight::Index; explicit ToPowerWeightMapper(Index index = 0) : index_(index) {} ToPowerWeight operator()(const FromWeight &w) const { return ToPowerWeight(index_, w.Value()); } private: const Index index_; }; // Converts FromPowerWeight to ToWeight. Uses only one component. // FromPowerWeight may be PowerWeight or SparsePowerWeight. template class FromPowerWeightMapper { public: using FromWeight = FromPowerWeight; using ToWeight = ToWeight_; using Index = typename FromPowerWeight::Index; explicit FromPowerWeightMapper(Index index = 0) : index_(index) {} ToWeight operator()(const FromPowerWeight &w) const { return ToWeight(w.Value(index_)); } private: const Index index_; }; // Projects to one dimension of the weight vector, filling the indices // with `default_weight`. // PowerWeightT may be PowerWeight or SparsePowerWeight. template class ProjectPowerWeightMapper { public: using FromWeight = PowerWeightT; using ToWeight = PowerWeightT; using Index = typename PowerWeightT::Index; using ComponentWeight = typename PowerWeightT::Weight; explicit ProjectPowerWeightMapper( Index from_index = 0, Index to_index = 0, const ComponentWeight &default_weight = ComponentWeight::Zero()) : from_index_(from_index), to_index_(to_index), default_weight_(default_weight) {} PowerWeightT operator()(const PowerWeightT &w) const { return PowerWeightT(to_index_, w.Value(from_index_), default_weight_); } private: const Index from_index_; const Index to_index_; const ComponentWeight default_weight_; }; // Applies a transformation function to each weight vector. // PowerWeightT may be PowerWeight or SparsePowerWeight. template class TransformPowerWeightMapper { public: using TransformFn = TransformFn_; using FromWeight = PowerWeightT; using ToWeight = PowerWeightT; explicit TransformPowerWeightMapper( const TransformFn &transform = TransformFn()) : transform_(transform) {} PowerWeightT operator()(const PowerWeightT &w) const { return transform_(w); } private: TransformFn transform_; }; } // namespace fst #endif // FST_POWER_WEIGHT_MAPPERS_H_ openfst-1.7.9/src/include/fst/power-weight.h000066400000000000000000000114171421600557100210130ustar00rootroot00000000000000// 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 #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 std::string &Type() { static const std::string *const type = new std::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(uint64 seed = std::random_device()(), bool allow_zero = true) : generate_(seed, allow_zero) {} Weight operator()() const { Weight result; for (size_t i = 0; i < n; ++i) result.SetValue(i, generate_()); return result; } private: const Generate generate_; }; } // namespace fst #endif // FST_POWER_WEIGHT_H_ openfst-1.7.9/src/include/fst/product-weight.h000066400000000000000000000076561421600557100213510ustar00rootroot00000000000000// 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 #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 std::string &Type() { static const std::string *const type = new std::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)); } // Specialization for product weight template class Adder> { public: using Weight = ProductWeight; Adder() {} explicit Adder(Weight w) : adder1_(w.Value1()), adder2_(w.Value2()) {} Weight Add(const Weight &w) { adder1_.Add(w.Value1()); adder2_.Add(w.Value2()); return Sum(); } Weight Sum() const { return Weight(adder1_.Sum(), adder2_.Sum()); } void Reset(Weight w = Weight::Zero()) { adder1_.Reset(w.Value1()); adder2_.Reset(w.Value2()); } private: Adder adder1_; Adder adder2_; }; // 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: using Weight = ProductWeight; using Generate = WeightGenerate>; explicit WeightGenerate(uint64 seed = std::random_device()(), bool allow_zero = true) : generate_(seed, allow_zero) {} Weight operator()() const { return Weight(generate_()); } private: const Generate generate_; }; } // namespace fst #endif // FST_PRODUCT_WEIGHT_H_ openfst-1.7.9/src/include/fst/project.h000066400000000000000000000114151421600557100200360ustar00rootroot00000000000000// 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 #include namespace fst { // This specifies whether to project on input or output. enum class ProjectType { INPUT = 1, OUTPUT = 2 }; OPENFST_DEPRECATED("Use `ProjectType::INPUT` instead.") static constexpr ProjectType PROJECT_INPUT = ProjectType::INPUT; OPENFST_DEPRECATED("Use `ProjectType::OUTPUT` instead.") static constexpr ProjectType PROJECT_OUTPUT = ProjectType::OUTPUT; // Mapper to implement projection per arc. template class ProjectMapper { public: using FromArc = A; using ToArc = A; constexpr explicit ProjectMapper(ProjectType project_type) : project_type_(project_type) {} ToArc operator()(const FromArc &arc) const { const auto label = project_type_ == ProjectType::INPUT ? arc.ilabel : arc.olabel; return ToArc(label, label, arc.weight, arc.nextstate); } constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; } constexpr MapSymbolsAction InputSymbolsAction() const { return project_type_ == ProjectType::INPUT ? MAP_COPY_SYMBOLS : MAP_CLEAR_SYMBOLS; } constexpr MapSymbolsAction OutputSymbolsAction() const { return project_type_ == ProjectType::OUTPUT ? MAP_COPY_SYMBOLS : MAP_CLEAR_SYMBOLS; } constexpr uint64 Properties(uint64 props) const { return ProjectProperties(props, project_type_ == ProjectType::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 ProjectType::INPUT: ofst->SetOutputSymbols(ifst.InputSymbols()); return; case ProjectType::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 ProjectType::INPUT: fst->SetOutputSymbols(fst->InputSymbols()); return; case ProjectType::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 == ProjectType::INPUT) { GetMutableImpl()->SetOutputSymbols(fst.InputSymbols()); } if (project_type == ProjectType::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_ openfst-1.7.9/src/include/fst/properties.h000066400000000000000000000502541421600557100205700ustar00rootroot00000000000000// 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 #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 at least one weighted cycle. constexpr uint64 kWeightedCycles = 0x0000400000000000ULL; // FST has no weighted cycles. Any cycles that may be present are unweighted. 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 of a string FST compiled into a string. constexpr uint64 kCompiledStringProperties = kAcceptor | kString | kUnweighted | kIDeterministic | kODeterministic | kILabelSorted | kOLabelSorted | kAcyclic | kInitialAcyclic | kUnweightedCycles | kTopSorted | kAccessible | kCoAccessible; // 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, size_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 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; } } } // namespace internal } // namespace fst #endif // FST_PROPERTIES_H_ openfst-1.7.9/src/include/fst/prune.h000066400000000000000000000316311421600557100175230ustar00rootroot00000000000000// 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; explicit PruneOptions(const Weight &weight_threshold = Weight::Zero(), StateId state_threshold = kNoStateId, ArcFilter filter = ArcFilter(), 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 = PruneOptions()) { 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 &opts = 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 = PruneOptions()) { 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_ openfst-1.7.9/src/include/fst/push.h000066400000000000000000000134441421600557100173530ustar00rootroot00000000000000// 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 #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 requested direction. 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 = REWEIGHT_TO_INITIAL, float delta = kShortestDelta, bool remove_total_weight = false) { using Weight = typename Arc::Weight; std::vector distance; const bool reverse = type == REWEIGHT_TO_INITIAL; ShortestDistance(*fst, &distance, reverse, delta); if (remove_total_weight) { const auto total_weight = ComputeTotalWeight(*fst, distance, reverse); Reweight(fst, distance, type); RemoveWeight(fst, total_weight, !reverse); } else { Reweight(fst, distance, type); } } constexpr uint8 kPushWeights = 0x01; constexpr uint8 kPushLabels = 0x02; constexpr uint8 kPushRemoveTotalWeight = 0x04; constexpr uint8 kPushRemoveCommonAffix = 0x08; // 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, uint8 ptype, float delta = kShortestDelta) { 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 { auto uwfst = MakeArcMapFst(ifst, RmWeightMapper()); auto guwfst = MakeArcMapFst(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_ openfst-1.7.9/src/include/fst/queue.h000066400000000000000000000741551421600557100175260ustar00rootroot00000000000000// 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 #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) {} ~TrivialQueue() override = 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) {} ~FifoQueue() override = default; StateId Head() const override { return queue_.front(); } void Enqueue(StateId s) override { queue_.push(s); } void Dequeue() override { queue_.pop(); } void Update(StateId) override {} bool Empty() const override { return queue_.empty(); } void Clear() override { queue_ = std::queue(); } private: std::queue queue_; }; // Last-in, first-out queue discipline. template class LifoQueue : public QueueBase { public: using StateId = S; LifoQueue() : QueueBase(LIFO_QUEUE) {} ~LifoQueue() override = default; StateId Head() const final { return stack_.top(); } void Enqueue(StateId s) final { stack_.push(s); } void Dequeue() final { stack_.pop(); } void Update(StateId) final {} bool Empty() const final { return stack_.empty(); } void Clear() final { stack_ = std::stack(); } private: std::stack stack_; }; // 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) {} ~ShortestFirstQueue() override = 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(); } ssize_t Size() const { return heap_.Size(); } 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 : public ShortestFirstQueue< S, internal::StateWeightCompare>> { public: using StateId = S; using Compare = internal::StateWeightCompare>; explicit NaturalShortestFirstQueue(const std::vector &distance) : ShortestFirstQueue(Compare(distance, less_)) {} ~NaturalShortestFirstQueue() override = default; private: // This is non-static because the constructor for non-idempotent weights will // result in an error. const NaturalLess less_{}; }; // In a shortest path computation on a lattice-like FST, we may keep many old // nonviable paths as a part of the search. Since the search process always // expands the lowest cost path next, that lowest cost path may be a very old // nonviable path instead of one we expect to lead to a shortest path. // // For instance, suppose that the current best path in an alignment has // traversed 500 arcs with a cost of 10. We may also have a bad path in // the queue that has traversed only 40 arcs but also has a cost of 10. // This path is very unlikely to lead to a reasonable alignment, so this queue // can prune it from the search space. // // This queue relies on the caller using a shortest-first exploration order // like this: // while (true) { // StateId head = queue.Head(); // queue.Dequeue(); // for (const auto& arc : GetArcs(fst, head)) { // queue.Enqueue(arc.nextstate); // } // } // We use this assumption to guess that there is an arc between Head and the // Enqueued state; this is how the number of path steps is measured. template class PruneNaturalShortestFirstQueue : public NaturalShortestFirstQueue { public: using StateId = S; using Base = NaturalShortestFirstQueue; PruneNaturalShortestFirstQueue(const std::vector &distance, ssize_t arc_threshold, ssize_t state_limit = 0) : Base(distance), arc_threshold_(arc_threshold), state_limit_(state_limit), head_steps_(0), max_head_steps_(0) {} ~PruneNaturalShortestFirstQueue() override = default; StateId Head() const override { const auto head = Base::Head(); // Stores the number of steps from the start of the graph to this state // along the shortest-weight path. if (head < steps_.size()) { max_head_steps_ = std::max(steps_[head], max_head_steps_); head_steps_ = steps_[head]; } return head; } void Enqueue(StateId s) override { // We assume that there is an arc between the Head() state and this // Enqueued state. const ssize_t state_steps = head_steps_ + 1; if (s >= steps_.size()) { steps_.resize(s + 1, state_steps); } // This is the number of arcs in the minimum cost path from Start to s. steps_[s] = state_steps; // Adjust the threshold in cases where path step thresholding wasn't // enough to keep the queue small. ssize_t adjusted_threshold = arc_threshold_; if (Base::Size() > state_limit_ && state_limit_ > 0) { adjusted_threshold = std::max( 0, arc_threshold_ - (Base::Size() / state_limit_) - 1); } if (state_steps > (max_head_steps_ - adjusted_threshold) || arc_threshold_ < 0) { if (adjusted_threshold == 0 && state_limit_ > 0) { // If the queue is continuing to grow without bound, we follow any // path that makes progress and clear the rest. Base::Clear(); } Base::Enqueue(s); } } private: // A dense map from StateId to the number of arcs in the minimum weight // path from Start to this state. std::vector steps_; // We only keep paths that are within this number of arcs (not weight!) // of the longest path. const ssize_t arc_threshold_; // If the size of the queue climbs above this number, we increase the // threshold to reduce the amount of work we have to do. const ssize_t state_limit_; // The following are mutable because Head() is const. // The number of arcs traversed in the minimum cost path from the start // state to the current Head() state. mutable ssize_t head_steps_; // The maximum number of arcs traversed by any low-cost path so far. mutable ssize_t max_head_steps_; }; // 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) {} ~TopOrderQueue() override = 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) {} ~StateOrderQueue() override = 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) {} ~SccQueue() override = 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_ = fst::make_unique>(); VLOG(2) << "AutoQueue: using state-order discipline"; } else if (props & kAcyclic) { queue_ = fst::make_unique>(fst, filter); VLOG(2) << "AutoQueue: using top-order discipline"; } else if ((props & kUnweighted) && (Weight::Properties() & kIdempotent)) { queue_ = fst::make_unique>(); 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 = fst::make_unique(); comp = fst::make_unique(*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_ = fst::make_unique>(); 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_ = fst::make_unique>(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] = fst::make_unique>(); VLOG(3) << "AutoQueue: SCC #" << i << ": using LIFO discipline"; break; case FIFO_QUEUE: default: queues_[i] = fst::make_unique>(); VLOG(3) << "AutoQueue: SCC #" << i << ": using FIFO discipine"; break; } } queue_ = fst::make_unique>>( scc_, &queues_); } } ~AutoQueue() override = 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 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 { constexpr 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 (s < beta_.size()) ? beta_[s] : kZero; } private: static constexpr Weight kZero = Weight::Zero(); const std::vector &beta_; }; template constexpr Weight NaturalAStarEstimate::kZero; // 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() override = default; private: // This is non-static because the constructor for non-idempotent weights will // result in 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)) {} ~PruneQueue() override = 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) {} ~NaturalPruneQueue() override = 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) {} ~FilterQueue() override = 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_ openfst-1.7.9/src/include/fst/randequivalent.h000066400000000000000000000103071421600557100214110ustar00rootroot00000000000000// 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 #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 npath, const RandGenOptions &opts, float delta = kDelta, uint64 seed = std::random_device()(), 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; std::mt19937 rand(seed); std::bernoulli_distribution coin(.5); for (int32 n = 0; n < npath; ++n) { VectorFst path; const auto &fst = coin(rand) ? sfst1 : sfst2; RandGen(fst, &path, opts); VectorFst ipath(path); VectorFst opath(path); Project(&ipath, ProjectType::INPUT); Project(&opath, ProjectType::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 nnpath 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 npath, float delta = kDelta, uint64 seed = std::random_device()(), 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, npath, opts, delta, seed, error); } } // namespace fst #endif // FST_RANDEQUIVALENT_H_ openfst-1.7.9/src/include/fst/randgen.h000066400000000000000000000625461421600557100200210ustar00rootroot00000000000000// 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 #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; explicit UniformArcSelector(uint64 seed = std::random_device()()) : 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() : seed_(std::random_device()()), rand_(seed_) {} // Constructs a selector with a given seed. explicit LogProbArcSelector(uint64 seed) : seed_(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; } uint64 Seed() const { return seed_; } protected: Log64Weight ToLogWeight(const Weight &weight) const { return to_log_weight_(weight); } std::mt19937_64 &MutableRand() const { return rand_; } private: const uint64 seed_; mutable std::mt19937_64 rand_; const 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::MutableRand; using LogProbArcSelector::ToLogWeight; using LogProbArcSelector::operator(); // Constructs a selector with a non-deterministic seed. FastLogProbArcSelector() : LogProbArcSelector() {} // Constructs a selector with a given seed. explicit FastLogProbArcSelector(uint64 seed) : LogProbArcSelector(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 = ToLogWeight(accumulator->Sum(fst.Final(s), &aiter, 0, fst.NumArcs(s))) .Value(); const double r = -log(std::uniform_real_distribution<>(0, 1)(MutableRand())); Weight w = from_log_weight_(r + sum); aiter.Reset(); return accumulator->LowerBound(w, &aiter); } private: const 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) { using distribution = std::binomial_distribution; // Left-over probability mass. Keep an array of the partial sums because // keeping a scalar and modifying norm -= probs[i] in the loop will result // in round-off error and can have probs[i] > norm. std::vector norm(probs.size()); std::partial_sum(probs.rbegin(), probs.rend(), norm.rbegin()); // Left-over number of samples needed. for (size_t i = 0; i < probs.size(); ++i) { distribution::result_type num_sampled = 0; if (probs[i] > 0) { distribution d(num_to_sample, probs[i] / norm[i]); num_sampled = d(*rng); } if (num_sampled != 0) (*result)[i] = num_sampled; num_to_sample -= std::min(num_sampled, num_to_sample); } } // 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_ = fst::make_unique(); accumulator_->Init(*fst); } else { // Shallow copy. accumulator_ = fst::make_unique(*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. const 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>::EmplaceArc; 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); 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(); auto weight = weighted_ ? to_weight_(Log64Weight(-log(prob))) : ToWeight::One(); EmplaceArc(s, aarc.ilabel, aarc.olabel, std::move(weight), state_table_.size()); 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) EmplaceArc(s, 0, 0, superfinal_); } } } 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_; const 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); } 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 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, uint64 seed = std::random_device()()) { const UniformArcSelector uniform_selector(seed); RandGenOptions> opts(uniform_selector); RandGen(ifst, ofst, opts); } } // namespace fst #endif // FST_RANDGEN_H_ openfst-1.7.9/src/include/fst/rational.h000066400000000000000000000235111421600557100202010ustar00rootroot00000000000000// 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 #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_.emplace_back(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); rfst_.SetInputSymbols(fst1.InputSymbols()); rfst_.SetOutputSymbols(fst1.OutputSymbols()); nonterminals_ = 2; rfst_.EmplaceArc(0, 0, -1, Weight::One(), 1); rfst_.EmplaceArc(0, 0, -2, Weight::One(), 1); fst_tuples_.emplace_back(-1, fst1.Copy()); fst_tuples_.emplace_back(-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); rfst_.SetInputSymbols(fst1.InputSymbols()); rfst_.SetOutputSymbols(fst1.OutputSymbols()); nonterminals_ = 2; rfst_.EmplaceArc(0, 0, -1, Weight::One(), 1); rfst_.EmplaceArc(1, 0, -2, Weight::One(), 2); fst_tuples_.emplace_back(-1, fst1.Copy()); fst_tuples_.emplace_back(-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); rfst_.EmplaceArc(0, 0, -1, Weight::One(), 0); } else { rfst_.AddState(); rfst_.AddState(); rfst_.SetStart(0); rfst_.SetFinal(1); rfst_.EmplaceArc(0, 0, -1, Weight::One(), 1); rfst_.EmplaceArc(1, 0, 0, Weight::One(), 0); } rfst_.SetInputSymbols(fst.InputSymbols()); rfst_.SetOutputSymbols(fst.OutputSymbols()); fst_tuples_.emplace_back(-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); ++nonterminals_; afst.EmplaceArc(0, 0, -nonterminals_, Weight::One(), 1); Union(&rfst_, afst); fst_tuples_.emplace_back(-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); ++nonterminals_; afst.EmplaceArc(0, 0, -nonterminals_, Weight::One(), 1); if (append) { Concat(&rfst_, afst); } else { Concat(afst, &rfst_); } fst_tuples_.emplace_back(-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_ = fst::make_unique>(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_ openfst-1.7.9/src/include/fst/register.h000066400000000000000000000064161421600557100202210ustar00rootroot00000000000000// 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 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 std::string &type) const { return this->GetEntry(type).reader; } const Converter GetConverter(const std::string &type) const { return this->GetEntry(type).converter; } protected: std::string ConvertKeyToSoFilename(const std::string &key) const override { std::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 std::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_ openfst-1.7.9/src/include/fst/relabel.h000066400000000000000000000365031421600557100200030ustar00rootroot00000000000000// 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 #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. const std::unordered_map input_map( ipairs.begin(), ipairs.end()); const std::unordered_map output_map( opairs.begin(), opairs.end()); 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 std::string &unknown_isymbol, bool attach_new_isymbols, const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, const std::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 (const auto &sitem : *old_isymbols) { const auto old_index = sitem.Label(); const auto symbol = sitem.Symbol(); auto new_index = new_isymbols->Find(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.emplace_back(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 (const auto &sitem : *old_osymbols) { const auto old_index = sitem.Label(); const auto symbol = sitem.Symbol(); auto new_index = new_osymbols->Find(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.emplace_back(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()), input_map_(ipairs.begin(), ipairs.end()), output_map_(opairs.begin(), opairs.end()), relabel_input_(!ipairs.empty()), relabel_output_(!opairs.empty()) { SetProperties(RelabelProperties(fst.Properties(kCopyProperties, false))); SetType("relabel"); } 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 (const auto &sitem : *old_isymbols) { input_map_[sitem.Label()] = new_isymbols->Find(sitem.Symbol()); } SetInputSymbols(new_isymbols); relabel_input_ = true; } if (old_osymbols && new_osymbols && old_osymbols->LabeledCheckSum() != new_osymbols->LabeledCheckSum()) { for (const auto &sitem : *old_osymbols) { output_map_[sitem.Label()] = new_osymbols->Find(sitem.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, std::move(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_ openfst-1.7.9/src/include/fst/replace-util.h000066400000000000000000000544131421600557100207630ustar00rootroot00000000000000// 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 #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; } uint8 Flags() const { return flags_; } void SetFlags(uint8 flags, uint8 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_. uint8 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 uint8 data_flags_; // Arc value flags valid for data in arcs_. mutable Arc final_arc_; // Final arc (when required). mutable uint8 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_ openfst-1.7.9/src/include/fst/reverse.h000066400000000000000000000101441421600557100200410ustar00rootroot00000000000000// 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 #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 Weight = typename FromArc::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) == Weight::Zero()) continue; if (ostart != kNoStateId) { ostart = kNoStateId; break; } else { ostart = s; } } if (ostart != kNoStateId && ifst.Final(ostart) != Weight::One()) { std::vector scc; SccVisitor scc_visitor(&scc, nullptr, nullptr, &dfs_iprops); DfsVisit(ifst, &scc_visitor); if (std::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); const auto weight = ifst.Final(is); if ((weight != Weight::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_ openfst-1.7.9/src/include/fst/reweight.h000066400000000000000000000114161421600557100202070ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/rmepsilon.h000066400000000000000000000441411421600557100204020ustar00rootroot00000000000000// 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 #include namespace fst { template struct RmEpsilonOptions : public ShortestDistanceOptions> { 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_weight_; } 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_weight_; // 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_ = 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(); if (static_cast(visited_.size()) <= state) { visited_.resize(state + 1, 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)) { if (static_cast(visited_.size()) <= arc.nextstate) { visited_.resize(arc.nextstate + 1, 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_.emplace( element, std::make_pair(expand_id_, arcs_.size())); if (insert_result.second) { arcs_.push_back(std::move(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(std::move(arc)); } } } } final_weight_ = Plus(final_weight_, 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 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, std::move(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_ openfst-1.7.9/src/include/fst/rmfinalepsilon.h000066400000000000000000000050001421600557100214030ustar00rootroot00000000000000// 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 #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_ openfst-1.7.9/src/include/fst/script/000077500000000000000000000000001421600557100175215ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/script/arc-class.h000066400000000000000000000020031421600557100215350ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/arciterator-class.h000066400000000000000000000132331421600557100233160ustar00rootroot00000000000000// 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 #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 uint8 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(uint8 flags, uint8 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(); } uint8 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(uint8 flags, uint8 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(); } uint8 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(uint8 flags, uint8 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(); } uint8 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(uint8 flags, uint8 mask) final { aiter_.SetFlags(flags, mask); } void SetValue(const ArcClass &ac) final { 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: void SetValue(const Arc &arc) { aiter_.SetValue(arc); } 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(); } uint8 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(uint8 flags, uint8 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_ openfst-1.7.9/src/include/fst/script/arcsort.h000066400000000000000000000016051421600557100213510ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/arg-packs.h000066400000000000000000000020371421600557100215440ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/closure.h000066400000000000000000000012161421600557100213460ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/compile-impl.h000066400000000000000000000167211421600557100222700ustar00rootroot00000000000000// 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 std::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 std::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 std::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 std::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 != '\0' || (!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_; std::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_ openfst-1.7.9/src/include/fst/script/compile.h000066400000000000000000000071301421600557100213230ustar00rootroot00000000000000// 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 std::string &source; const std::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 std::string &source, const std::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 std::string &source, const std::string &dest, const std::string &fst_type, const std::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 std::string &source, const std::string &fst_type, const std::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_ openfst-1.7.9/src/include/fst/script/compose.h000066400000000000000000000017271421600557100213460ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/concat.h000066400000000000000000000030741421600557100211450ustar00rootroot00000000000000// 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 *fst1 = std::get<0>(*args)->GetMutableFst(); const Fst &fst2 = *std::get<1>(*args).GetFst(); Concat(fst1, fst2); } using ConcatArgs2 = std::pair; template void Concat(ConcatArgs2 *args) { const Fst &fst1 = *std::get<0>(*args).GetFst(); MutableFst *fst2 = std::get<1>(*args)->GetMutableFst(); Concat(fst1, fst2); } using ConcatArgs3 = std::pair &, MutableFstClass *>; template void Concat(ConcatArgs3 *args) { const auto &untyped_fsts1 = std::get<0>(*args); std::vector *> typed_fsts1; typed_fsts1.reserve(untyped_fsts1.size()); for (const auto &untyped_fst1 : untyped_fsts1) { typed_fsts1.emplace_back(untyped_fst1->GetFst()); } MutableFst *fst2 = std::get<1>(*args)->GetMutableFst(); Concat(typed_fsts1, fst2); } void Concat(MutableFstClass *fst1, const FstClass &fst2); void Concat(const FstClass &fst1, MutableFstClass *fst2); void Concat(const std::vector &fsts1, MutableFstClass *fst2); } // namespace script } // namespace fst #endif // FST_SCRIPT_CONCAT_H_ openfst-1.7.9/src/include/fst/script/connect.h000066400000000000000000000007331421600557100213260ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/convert.h000066400000000000000000000016561421600557100213620ustar00rootroot00000000000000// 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 std::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 std::string &new_type); } // namespace script } // namespace fst #endif // FST_SCRIPT_CONVERT_H_ openfst-1.7.9/src/include/fst/script/decode.h000066400000000000000000000014241421600557100211160ustar00rootroot00000000000000// 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 namespace fst { namespace script { using DecodeArgs = std::pair; template void Decode(DecodeArgs *args) { MutableFst *fst = std::get<0>(*args)->GetMutableFst(); const EncodeMapper &mapper = *std::get<1>(*args).GetEncodeMapper(); Decode(fst, mapper); } void Decode(MutableFstClass *fst, const EncodeMapperClass &encoder); } // namespace script } // namespace fst #endif // FST_SCRIPT_DECODE_H_ openfst-1.7.9/src/include/fst/script/determinize.h000066400000000000000000000037451421600557100222220ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/difference.h000066400000000000000000000020331421600557100217620ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/disambiguate.h000066400000000000000000000034161421600557100223340ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/draw-impl.h000066400000000000000000000146471421600557100216020ustar00rootroot00000000000000// 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 std::string &title, float width, float height, bool portrait, bool vertical, float ranksep, float nodesep, int fontsize, int precision, const std::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 std::string &dest) { ostrm_ = &strm; SetStreamState(ostrm_); dest_ = dest; const auto 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 (!title_.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 std::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 std::string Escape(const std::string &str) { std::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 std::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. std::string dest_; // Drawn FST destination name. std::string title_; float width_; float height_; bool portrait_; bool vertical_; float ranksep_; float nodesep_; int fontsize_; int precision_; std::string float_format_; bool show_weight_one_; FstDrawer(const FstDrawer &) = delete; FstDrawer &operator=(const FstDrawer &) = delete; }; } // namespace fst #endif // FST_SCRIPT_DRAW_IMPL_H_ openfst-1.7.9/src/include/fst/script/draw.h000066400000000000000000000054711421600557100206360ustar00rootroot00000000000000// 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 DrawArgs { const FstClass &fst; const SymbolTable *isyms; const SymbolTable *osyms; const SymbolTable *ssyms; const bool accep; const std::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 std::string &float_format; // NOLINT const bool show_weight_one; std::ostream &ostrm; const std::string &dest; DrawArgs(const FstClass &fst, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, const std::string &title, float width, float height, bool portrait, bool vertical, float ranksep, float nodesep, int fontsize, int precision, const std::string &float_format, bool show_weight_one, std::ostream &ostrm, const std::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 Draw(DrawArgs *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 Draw(const FstClass &fst, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, const std::string &title, float width, float height, bool portrait, bool vertical, float ranksep, float nodesep, int fontsize, int precision, const std::string &float_format, bool show_weight_one, std::ostream &ostrm, const std::string &dest); } // namespace script } // namespace fst #endif // FST_SCRIPT_DRAW_H_ openfst-1.7.9/src/include/fst/script/encode.h000066400000000000000000000014021421600557100211240ustar00rootroot00000000000000// 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 namespace fst { namespace script { using EncodeArgs = std::tuple; template void Encode(EncodeArgs *args) { MutableFst *fst = std::get<0>(*args)->GetMutableFst(); EncodeMapper *mapper = std::get<1>(*args)->GetEncodeMapper(); Encode(fst, mapper); } void Encode(MutableFstClass *fst, EncodeMapperClass *mapper); } // namespace script } // namespace fst #endif // FST_SCRIPT_ENCODE_H_ openfst-1.7.9/src/include/fst/script/encodemapper-class.h000066400000000000000000000201451421600557100234410ustar00rootroot00000000000000// 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 #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 &) = 0; virtual const std::string &ArcType() const = 0; virtual const std::string &WeightType() const = 0; virtual EncodeMapperImplBase *Copy() const = 0; virtual uint8 Flags() const = 0; virtual uint64 Properties(uint64) = 0; virtual EncodeType Type() const = 0; virtual bool Write(const std::string &) const = 0; virtual bool Write(std::ostream &, const std::string &) const = 0; virtual const SymbolTable *InputSymbols() const = 0; virtual const SymbolTable *OutputSymbols() const = 0; virtual void SetInputSymbols(const SymbolTable *) = 0; virtual void SetOutputSymbols(const SymbolTable *) = 0; virtual ~EncodeMapperImplBase() {} }; // Templated implementation. template class EncodeMapperClassImpl : public EncodeMapperImplBase { public: explicit EncodeMapperClassImpl(const EncodeMapper &mapper) : mapper_(mapper) {} ArcClass operator()(const ArcClass &a) final; const std::string &ArcType() const final { return Arc::Type(); } const std::string &WeightType() const final { return Arc::Weight::Type(); } EncodeMapperClassImpl *Copy() const final { return new EncodeMapperClassImpl(mapper_); } uint8 Flags() const final { return mapper_.Flags(); } uint64 Properties(uint64 inprops) final { return mapper_.Properties(inprops); } EncodeType Type() const final { return mapper_.Type(); } bool Write(const std::string &source) const final { return mapper_.Write(source); } bool Write(std::ostream &strm, const std::string &source) const final { return mapper_.Write(strm, source); } const SymbolTable *InputSymbols() const final { return mapper_.InputSymbols(); } const SymbolTable *OutputSymbols() const final { return mapper_.OutputSymbols(); } void SetInputSymbols(const SymbolTable *syms) final { mapper_.SetInputSymbols(syms); } void SetOutputSymbols(const SymbolTable *syms) final { mapper_.SetOutputSymbols(syms); } ~EncodeMapperClassImpl() override {} const EncodeMapper *GetImpl() const { return &mapper_; } EncodeMapper *GetImpl() { return &mapper_; } private: EncodeMapper mapper_; }; template inline ArcClass EncodeMapperClassImpl::operator()(const ArcClass &a) { const Arc arc(a.ilabel, a.olabel, *(a.weight.GetWeight()), a.nextstate); return ArcClass(mapper_(arc)); } class EncodeMapperClass { public: EncodeMapperClass() : impl_(nullptr) {} EncodeMapperClass(const std::string &arc_type, uint8 flags, EncodeType type = ENCODE); template explicit EncodeMapperClass(const EncodeMapper &mapper) : impl_(new EncodeMapperClassImpl(mapper)) {} EncodeMapperClass(const EncodeMapperClass &other) : impl_(other.impl_ == nullptr ? nullptr : other.impl_->Copy()) {} EncodeMapperClass &operator=(const EncodeMapperClass &other) { impl_.reset(other.impl_ == nullptr ? nullptr : other.impl_->Copy()); return *this; } ArcClass operator()(const ArcClass &arc) { return (*impl_)(arc); } const std::string &ArcType() const { return impl_->ArcType(); } const std::string &WeightType() const { return impl_->WeightType(); } uint8 Flags() const { return impl_->Flags(); } uint64 Properties(uint64 inprops) { return impl_->Properties(inprops); } EncodeType Type() const { return impl_->Type(); } static EncodeMapperClass *Read(const std::string &source); static EncodeMapperClass *Read(std::istream &strm, const std::string &source); bool Write(const std::string &source) const { return impl_->Write(source); } bool Write(std::ostream &strm, const std::string &source) const { return impl_->Write(strm, source); } 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); } // Implementation stuff. 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(); } } // Required for registration. template static EncodeMapperClass *Read(std::istream &strm, const std::string &source) { std::unique_ptr> mapper( EncodeMapper::Read(strm, source)); return mapper ? new EncodeMapperClass(*mapper) : nullptr; } template static EncodeMapperImplBase *Create(uint8 flags, EncodeType type = ENCODE) { return new EncodeMapperClassImpl(EncodeMapper(flags, type)); } private: explicit EncodeMapperClass(EncodeMapperImplBase *impl) : impl_(impl) {} const EncodeMapperImplBase *GetImpl() const { return impl_.get(); } EncodeMapperImplBase *GetImpl() { return impl_.get(); } std::unique_ptr impl_; }; // Registration for EncodeMapper types. // This class definition is to avoid a nested class definition inside the // EncodeMapperIORegistration struct. template struct EncodeMapperClassRegEntry { Reader reader; Creator creator; EncodeMapperClassRegEntry(Reader reader, Creator creator) : reader(reader), creator(creator) {} EncodeMapperClassRegEntry() : reader(nullptr), creator(nullptr) {} }; template class EncodeMapperClassIORegister : public GenericRegister, EncodeMapperClassIORegister> { public: Reader GetReader(const std::string &arc_type) const { return this->GetEntry(arc_type).reader; } Creator GetCreator(const std::string &arc_type) const { return this->GetEntry(arc_type).creator; } protected: std::string ConvertKeyToSoFilename(const std::string &key) const final { std::string legal_type(key); ConvertToLegalCSymbol(&legal_type); return legal_type + "-arc.so"; } }; // Struct containing everything needed to register a particular type struct EncodeMapperClassIORegistration { using Reader = EncodeMapperClass *(*)(std::istream &stream, const std::string &source); using Creator = EncodeMapperImplBase *(*)(uint8 flags, EncodeType type); using Entry = EncodeMapperClassRegEntry; // EncodeMapper register. using Register = EncodeMapperClassIORegister; // EncodeMapper register-er. using Registerer = GenericRegisterer>; }; #define REGISTER_ENCODEMAPPER_CLASS(Arc) \ static EncodeMapperClassIORegistration::Registerer \ EncodeMapperClass_##Arc##_registerer( \ Arc::Type(), \ EncodeMapperClassIORegistration::Entry( \ EncodeMapperClass::Read, EncodeMapperClass::Create)); } // namespace script } // namespace fst #endif // FST_SCRIPT_ENCODEMAPPER_CLASS_H_ openfst-1.7.9/src/include/fst/script/epsnormalize.h000066400000000000000000000015161421600557100224050ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/equal.h000066400000000000000000000015141421600557100210020ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/equivalent.h000066400000000000000000000016271421600557100220550ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/fst-class.h000066400000000000000000000502101421600557100215670ustar00rootroot00000000000000// 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 #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 std::string &ArcType() const = 0; virtual WeightClass Final(int64) const = 0; virtual const std::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 std::string &WeightType() const = 0; virtual bool ValidStateId(int64) const = 0; virtual bool Write(const std::string &) const = 0; virtual bool Write(std::ostream &, const std::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 void AddStates(size_t) = 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(const SymbolTable *) = 0; virtual bool SetFinal(int64, const WeightClass &) = 0; virtual void SetOutputSymbols(const 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(); } // Warning: calling this method casts the FST to a mutable FST. void AddStates(size_t n) final { return static_cast *>(impl_.get())->AddStates(n); } const std::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 std::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 n) final { static_cast *>(impl_.get())->ReserveStates(n); } const SymbolTable *OutputSymbols() const final { return impl_->OutputSymbols(); } // Warning: calling this method casts the FST to a mutable FST. void SetInputSymbols(const 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(const 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 std::string &WeightType() const final { return Arc::Weight::Type(); } bool Write(const std::string &source) const final { return impl_->Write(source); } bool Write(std::ostream &ostr, const std::string &source) const final { const FstWriteOptions opts(source); 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 std::string &ArcType() const final { return impl_->ArcType(); } const std::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 std::string &source); static FstClass *Read(std::istream &istrm, const std::string &source); int64 Start() const final { return impl_->Start(); } bool ValidStateId(int64 s) const final { return impl_->ValidStateId(s); } const std::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 std::string &op_name) const; bool Write(const std::string &source) const final { return impl_->Write(source); } bool Write(std::ostream &ostr, const std::string &source) const final { return impl_->Write(ostr, source); } ~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(); } void AddStates(size_t n) { return GetImpl()->AddStates(n); } 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 n) { GetImpl()->ReserveStates(n); } static MutableFstClass *Read(const std::string &source, bool convert = false); void SetInputSymbols(const 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(const 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 std::string &arc_type); static VectorFstClass *Read(const std::string &source); 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); } }; // Registration stuff. // This class definition is to avoid a nested class definition inside the // FstClassIORegistration 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(nullptr), creator(nullptr), converter(nullptr) {} }; // Actual FST IO method register. template class FstClassIORegister : public GenericRegister, FstClassIORegister> { public: Reader GetReader(const std::string &arc_type) const { return this->GetEntry(arc_type).reader; } Creator GetCreator(const std::string &arc_type) const { return this->GetEntry(arc_type).creator; } Converter GetConverter(const std::string &arc_type) const { return this->GetEntry(arc_type).converter; } protected: std::string ConvertKeyToSoFilename(const std::string &key) const final { std::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 FstClassIORegistration { 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>; }; // Macros for registering other arc types. #define REGISTER_FST_CLASS(Class, Arc) \ static FstClassIORegistration::Registerer Class##_##Arc##_registerer( \ Arc::Type(), \ FstClassIORegistration::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_FST_CLASS_H_ openfst-1.7.9/src/include/fst/script/fstscript-decl.h000066400000000000000000000011261421600557100226200ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/fstscript.h000066400000000000000000000141301421600557100217120ustar00rootroot00000000000000// 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(Concat, Arc, ConcatArgs3); REGISTER_FST_OPERATION(Connect, Arc, MutableFstClass); REGISTER_FST_OPERATION(Convert, Arc, ConvertArgs); REGISTER_FST_OPERATION(Decode, Arc, DecodeArgs); REGISTER_FST_OPERATION(Determinize, Arc, DeterminizeArgs); REGISTER_FST_OPERATION(Difference, Arc, DifferenceArgs); REGISTER_FST_OPERATION(Disambiguate, Arc, DisambiguateArgs); REGISTER_FST_OPERATION(Draw, Arc, DrawArgs); REGISTER_FST_OPERATION(Encode, Arc, EncodeArgs); REGISTER_FST_OPERATION(EpsNormalize, Arc, EpsNormalizeArgs); REGISTER_FST_OPERATION(Equal, Arc, EqualArgs); REGISTER_FST_OPERATION(Equivalent, Arc, EquivalentArgs); REGISTER_FST_OPERATION(InitArcIteratorClass, Arc, InitArcIteratorClassArgs); REGISTER_FST_OPERATION(InitMutableArcIteratorClass, Arc, InitMutableArcIteratorClassArgs); REGISTER_FST_OPERATION(InitStateIteratorClass, Arc, InitStateIteratorClassArgs); REGISTER_FST_OPERATION(Info, Arc, InfoArgs); REGISTER_FST_OPERATION(Intersect, Arc, IntersectArgs); REGISTER_FST_OPERATION(Invert, Arc, MutableFstClass); REGISTER_FST_OPERATION(Isomorphic, Arc, IsomorphicArgs); } void RegisterBatch2() { REGISTER_FST_OPERATION(Map, Arc, MapArgs); REGISTER_FST_OPERATION(Minimize, Arc, MinimizeArgs); REGISTER_FST_OPERATION(Print, Arc, PrintArgs); 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(ShortestDistance, Arc, ShortestDistanceArgs3); REGISTER_FST_OPERATION(ShortestPath, Arc, ShortestPathArgs); REGISTER_FST_OPERATION(Synchronize, Arc, SynchronizeArgs); REGISTER_FST_OPERATION(TopSort, Arc, TopSortArgs); REGISTER_FST_OPERATION(Union, Arc, UnionArgs1); REGISTER_FST_OPERATION(Union, Arc, UnionArgs2); 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_ openfst-1.7.9/src/include/fst/script/getters.h000066400000000000000000000052461421600557100213560ustar00rootroot00000000000000// 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 #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 TokenType. #include // For ArcSortType. #include // For MapType. #include // For RandArcSelection. namespace fst { namespace script { bool GetArcSortType(const std::string &str, ArcSortType *sort_type); inline ClosureType GetClosureType(bool closure_plus) { return closure_plus ? CLOSURE_PLUS : CLOSURE_STAR; } bool GetComposeFilter(const std::string &str, ComposeFilter *compose_filter); bool GetDeterminizeType(const std::string &str, DeterminizeType *det_type); inline uint8 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 std::string &str, MapType *map_type); bool GetProjectType(const std::string &str, ProjectType *project_type); inline uint8 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 std::string &str, QueueType *queue_type); bool GetRandArcSelection(const std::string &str, RandArcSelection *ras); bool GetReplaceLabelType(const std::string &str, bool epsilon_on_replace, ReplaceLabelType *rlt); inline ReweightType GetReweightType(bool to_final) { return to_final ? REWEIGHT_TO_FINAL : REWEIGHT_TO_INITIAL; } bool GetTokenType(const std::string &str, TokenType *token_type); } // namespace script } // namespace fst #endif // FST_SCRIPT_GETTERS_H_ openfst-1.7.9/src/include/fst/script/info-impl.h000066400000000000000000000205531421600557100215710ustar00rootroot00000000000000// 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 #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: // 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 std::string &arc_filter_type = "any", const std::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 std::string &FstType() const { return fst_type_; } const std::string &ArcType() const { return arc_type_; } const std::string &InputSymbols() const { return input_symbols_; } const std::string &OutputSymbols() const { return output_symbols_; } bool LongInfo() const { return long_info_; } const std::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_; } void Info() const; private: void CheckLong() const { if (!long_info_) FSTERROR() << "FstInfo: Method only available with long info signature"; } std::string fst_type_; std::string input_symbols_; std::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_; std::string arc_filter_type_; bool long_info_; std::string arc_type_; }; } // namespace fst #endif // FST_SCRIPT_INFO_IMPL_H_ openfst-1.7.9/src/include/fst/script/info.h000066400000000000000000000016561421600557100206350ustar00rootroot00000000000000// 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 Info(InfoArgs *args) { const Fst &fst = *std::get<0>(*args).GetFst(); const FstInfo info(fst, std::get<1>(*args), std::get<2>(*args), std::get<3>(*args), std::get<4>(*args)); info.Info(); } void Info(const FstClass &fst, bool test_properties, const std::string &arc_filter, const std::string &info_type, bool verify); } // namespace script } // namespace fst #endif // FST_SCRIPT_INFO_H_ openfst-1.7.9/src/include/fst/script/intersect.h000066400000000000000000000020161421600557100216710ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/invert.h000066400000000000000000000007241421600557100212040ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/isomorphic.h000066400000000000000000000016271421600557100220540ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/map.h000066400000000000000000000110501421600557100204440ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/minimize.h000066400000000000000000000016001421600557100215100ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/print-impl.h000066400000000000000000000102671421600557100217730ustar00rootroot00000000000000// 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 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; explicit FstPrinter(const Fst &fst, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accept, bool show_weight_one, const std::string &field_separator, const std::string &missing_symbol = "") : fst_(fst), isyms_(isyms), osyms_(osyms), ssyms_(ssyms), accept_(accept && (fst.Properties(kAcceptor, true) == kAcceptor)), 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 std::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) { std::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 (!accept_) { *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 accept_; // Print as acceptor when possible? std::ostream *ostrm_; // Text FST destination. std::string dest_; // Text FST destination name. bool show_weight_one_; // Print weights equal to Weight::One()? std::string sep_; // Separator character between fields. std::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_ openfst-1.7.9/src/include/fst/script/print.h000066400000000000000000000056741421600557100210420ustar00rootroot00000000000000// 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 PrintArgs { const FstClass &fst; const SymbolTable *isyms; const SymbolTable *osyms; const SymbolTable *ssyms; const bool accept; const bool show_weight_one; std::ostream &ostrm; const std::string &dest; const std::string &sep; const std::string &missing_symbol; PrintArgs(const FstClass &fst, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accept, bool show_weight_one, std::ostream &ostrm, const std::string &dest, const std::string &sep, const std::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 Print(PrintArgs *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 Print(const FstClass &fst, std::ostream &ostrm, const std::string &dest, const SymbolTable *isyms = nullptr, const SymbolTable *osyms = nullptr, const SymbolTable *ssyms = nullptr, bool accept = true, bool show_weight_one = true, const std::string &missing_sym = ""); // TODO(kbg,2019-09-01): Deprecated. void PrintFst(const FstClass &fst, std::ostream &ostrm, const std::string &dest, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accept, bool show_weight_one, const std::string &missing_sym = ""); // The same, but with more sensible defaults, and for arc-templated FSTs only. // TODO(kbg,2019-09-01): Deprecated. template void PrintFst(const Fst &fst, std::ostream &ostrm, const std::string &dest = "", const SymbolTable *isyms = nullptr, const SymbolTable *osyms = nullptr, const SymbolTable *ssyms = nullptr) { const std::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_ openfst-1.7.9/src/include/fst/script/project.h000066400000000000000000000012071421600557100213400ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/prune.h000066400000000000000000000031311421600557100210210ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/push.h000066400000000000000000000030651421600557100206550ustar00rootroot00000000000000// 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 #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 type = REWEIGHT_TO_INITIAL, float delta = kShortestDelta, bool remove_total_weight = false); void Push(const FstClass &ifst, MutableFstClass *ofst, uint8 flags, ReweightType rew_type, float delta = kShortestDelta); } // namespace script } // namespace fst #endif // FST_SCRIPT_PUSH_H_ openfst-1.7.9/src/include/fst/script/randequivalent.h000066400000000000000000000046121421600557100227170ustar00rootroot00000000000000// 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 namespace fst { namespace script { using RandEquivalentInnerArgs = std::tuple &, float, uint64>; 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 int32 npath = std::get<2>(args->args); const auto &opts = std::get<3>(args->args); const float delta = std::get<4>(args->args); const uint64 seed = 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, npath, ropts, delta, seed); return; } case FAST_LOG_PROB_ARC_SELECTOR: { const FastLogProbArcSelector selector(seed); const RandGenOptions> ropts(selector, opts.max_length); args->retval = RandEquivalent(fst1, fst2, npath, ropts, delta, seed); return; } case LOG_PROB_ARC_SELECTOR: { const LogProbArcSelector selector(seed); const RandGenOptions> ropts(selector, opts.max_length); args->retval = RandEquivalent(fst1, fst2, npath, ropts, delta, seed); return; } } } bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath = 1, const RandGenOptions &opts = RandGenOptions(UNIFORM_ARC_SELECTOR), float delta = kDelta, uint64 seed = std::random_device()()); } // namespace script } // namespace fst #endif // FST_SCRIPT_RANDEQUIVALENT_H_ openfst-1.7.9/src/include/fst/script/randgen.h000066400000000000000000000037551421600557100213220ustar00rootroot00000000000000// 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 #include namespace fst { namespace script { using RandGenArgs = std::tuple &, uint64>; template void RandGen(RandGenArgs *args) { const Fst &ifst = *std::get<0>(*args).GetFst(); MutableFst *ofst = std::get<1>(*args)->GetMutableFst(); const auto &opts = std::get<2>(*args); const uint64 seed = 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, const RandGenOptions &opts = RandGenOptions(UNIFORM_ARC_SELECTOR), uint64 seed = std::random_device()()); } // namespace script } // namespace fst #endif // FST_SCRIPT_RANDGEN_H_ openfst-1.7.9/src/include/fst/script/relabel.h000066400000000000000000000044351421600557100213060ustar00rootroot00000000000000// 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 #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 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 std::string &unknown_isymbol, bool attach_new_isymbols, const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, const std::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_ openfst-1.7.9/src/include/fst/script/replace.h000066400000000000000000000050161421600557100213070ustar00rootroot00000000000000// 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 #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 ReplaceArgs = std::tuple> &, MutableFstClass *, const ReplaceOptions &>; template void Replace(ReplaceArgs *args) { // 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_ openfst-1.7.9/src/include/fst/script/reverse.h000066400000000000000000000014011421600557100213410ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/reweight.h000066400000000000000000000021051421600557100215060ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/rmepsilon.h000066400000000000000000000062401421600557100217040ustar00rootroot00000000000000// 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 #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_ openfst-1.7.9/src/include/fst/script/script-impl.h000066400000000000000000000165641421600557100221510ustar00rootroot00000000000000// 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: // // REGISTER_FST_OPERATION(Foo, StdArc, FooArgs); // REGISTER_FST_OPERATION(Foo, MyArc, FooArgs); // // .. etc // // You can also use REGISTER_FST_OPERATION_3ARCS macro to register an // operation for StdArc, LogArc, and Log64Arc: // // REGISTER_FST_OPERATION_3ARCS(Foo, FooArcs); // // 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 #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: OperationSignature GetOperation(const std::string &operation_name, const std::string &arc_type) { return this->GetEntry(std::make_pair(operation_name, arc_type)); } protected: std::string ConvertKeyToSoFilename( const std::pair &key) const final { // Uses the old-style FST for now. std::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 \ ({#Op, Arc::Type()}, Op) // A macro that calls REGISTER_FST_OPERATION for widely-used arc types. #define REGISTER_FST_OPERATION_3ARCS(Op, ArgPack) \ REGISTER_FST_OPERATION(Op, StdArc, ArgPack); \ REGISTER_FST_OPERATION(Op, LogArc, ArgPack); \ REGISTER_FST_OPERATION(Op, Log64Arc, ArgPack) // Template function to apply an operation by name. template void Apply(const std::string &op_name, const std::string &arc_type, typename OpReg::ArgPack *args) { const auto op = OpReg::Register::GetRegister()->GetOperation(op_name, arc_type); if (!op) { FSTERROR() << op_name << ": No operation found 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 std::string &op_name) { if (m.ArcType() != n.ArcType()) { FSTERROR() << op_name << ": Arguments with non-matching arc types " << 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->emplace_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_ openfst-1.7.9/src/include/fst/script/shortest-distance.h000066400000000000000000000165651421600557100233520ustar00rootroot00000000000000// 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 #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)); } using ShortestDistanceInnerArgs3 = std::tuple; using ShortestDistanceArgs3 = WithReturnValue; template void ShortestDistance(ShortestDistanceArgs3 *args) { const Fst &fst = *std::get<0>(args->args).GetFst(); args->retval = WeightClass(ShortestDistance(fst, std::get<1>(args->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); WeightClass ShortestDistance(const FstClass &ifst, double delta = fst::kShortestDelta); } // namespace script } // namespace fst #endif // FST_SCRIPT_SHORTEST_DISTANCE_H_ openfst-1.7.9/src/include/fst/script/shortest-path.h000066400000000000000000000072641421600557100225100ustar00rootroot00000000000000// 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 #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_ openfst-1.7.9/src/include/fst/script/stateiterator-class.h000066400000000000000000000041221421600557100236660ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/synchronize.h000066400000000000000000000013351421600557100222470ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/text-io.h000066400000000000000000000014261421600557100212660ustar00rootroot00000000000000// 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 std::string &weight_type, const std::string &source, std::vector *potentials); bool WritePotentials(const std::string &source, const std::vector &potentials); } // namespace script } // namespace fst #endif // FST_SCRIPT_TEXT_IO_H__ openfst-1.7.9/src/include/fst/script/topsort.h000066400000000000000000000011171421600557100214040ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/union.h000066400000000000000000000023761421600557100210320ustar00rootroot00000000000000// 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 #include namespace fst { namespace script { using UnionArgs1 = std::pair; template void Union(UnionArgs1 *args) { MutableFst *fst1 = std::get<0>(*args)->GetMutableFst(); const Fst &fst2 = *std::get<1>(*args).GetFst(); Union(fst1, fst2); } using UnionArgs2 = std::tuple &>; template void Union(UnionArgs2 *args) { MutableFst *fst1 = std::get<0>(*args)->GetMutableFst(); const auto &untyped_fsts2 = std::get<1>(*args); std::vector *> typed_fsts2; typed_fsts2.reserve(untyped_fsts2.size()); for (const auto &untyped_fst2 : untyped_fsts2) { typed_fsts2.emplace_back(untyped_fst2->GetFst()); } Union(fst1, typed_fsts2); } void Union(MutableFstClass *fst1, const FstClass &fst2); void Union(MutableFstClass *fst1, const std::vector &fsts2); } // namespace script } // namespace fst #endif // FST_SCRIPT_UNION_H_ openfst-1.7.9/src/include/fst/script/verify.h000066400000000000000000000011321421600557100211730ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/script/weight-class.h000066400000000000000000000160311421600557100222650ustar00rootroot00000000000000// 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 std::string &Type() const = 0; virtual std::string ToString() const = 0; virtual bool Member() 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 std::string &Type() const final { return W::Type(); } void Print(std::ostream *ostrm) const final { *ostrm << weight_; } std::string ToString() const final { std::string str; WeightToStr(weight_, &str); return str; } bool Member() const final { return weight_.Member(); } 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 std::string &weight_type, const std::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 char __ZERO__[] = "__ZERO__"; // NOLINT static constexpr char __ONE__[] = "__ONE__"; // NOLINT static constexpr char __NOWEIGHT__[] = "__NOWEIGHT__"; // NOLINT static WeightClass Zero(const std::string &weight_type); static WeightClass One(const std::string &weight_type); static WeightClass NoWeight(const std::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(); } } std::string ToString() const { return (impl_) ? impl_->ToString() : "none"; } const std::string &Type() const { if (impl_) return impl_->Type(); static const std::string *const no_type = new std::string("none"); return *no_type; } bool Member() const { return impl_ && impl_->Member(); } static bool WeightTypesMatch(const WeightClass &lhs, const WeightClass &rhs, const std::string &op_name); 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 std::string &str); template WeightImplBase *StrToWeightImplBase(const std::string &str) { 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)); } class WeightClassRegister : public GenericRegister { protected: std::string ConvertKeyToSoFilename(const std::string &key) const final { std::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_ openfst-1.7.9/src/include/fst/set-weight.h000066400000000000000000000443501421600557100204540ustar00rootroot00000000000000// 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 #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 = L; 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 std::string &Type() { static const std::string *const type = new std::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, 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_ = fst::make_unique>>(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_ openfst-1.7.9/src/include/fst/state-reachable.h000066400000000000000000000160071421600557100214160ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/state-table.h000066400000000000000000000407711421600557100206040ustar00rootroot00000000000000// 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 #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(const FP &fingerprint = FP(), 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(const Select &select, const FP &fingerprint, const 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 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 explicitly 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() * size_t{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) const { 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(ComposeFingerprint(CountStates(fst1), CountStates(fst2)), table_size) {} ProductComposeStateTable( const ProductComposeStateTable &table) : StateTable(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_ openfst-1.7.9/src/include/fst/statesort.h000066400000000000000000000042471421600557100204250ustar00rootroot00000000000000// 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 #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_ openfst-1.7.9/src/include/fst/string-weight.h000066400000000000000000000631421421600557100211670ustar00rootroot00000000000000// 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 #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 = L; 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 std::string &Type() { static const std::string *const type = new std::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_ openfst-1.7.9/src/include/fst/test-properties.h000066400000000000000000000205551421600557100215460ustar00rootroot00000000000000// 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 { // 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. 'mask & required_mask' is used to determine whether the stored // properties can be used. This routine is seldom called directly; instead it is // used to implement fst.Properties(mask, /*test=*/true). template uint64 ComputeProperties(const Fst &fst, uint64 mask, uint64 *known) { 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. // 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. constexpr uint64 kDfsProps = kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | kAccessible | kNotAccessible | kCoAccessible | kNotCoAccessible; std::vector scc; if (mask & (kDfsProps | 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 | kDfsProps)) { 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 & (kDfsProps | 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 = fst::make_unique>(); } if (mask & (kODeterministic | kNonODeterministic)) { olabels = fst::make_unique>(); } bool first_arc = true; for (ArcIterator> aiter(fst, s); !aiter.Done(); aiter.Next()) { const auto &arc = aiter.Value(); if (ilabels && ilabels->find(arc.ilabel) != ilabels->end()) { comp_props |= kNonIDeterministic; comp_props &= ~kIDeterministic; } if (olabels && olabels->find(arc.olabel) != olabels->end()) { comp_props |= kNonODeterministic; comp_props &= ~kODeterministic; } if (arc.ilabel != arc.olabel) { comp_props |= kNotAcceptor; comp_props &= ~kAcceptor; } if (arc.ilabel == 0 && arc.olabel == 0) { comp_props |= kEpsilons; comp_props &= ~kNoEpsilons; } if (arc.ilabel == 0) { comp_props |= kIEpsilons; comp_props &= ~kNoIEpsilons; } if (arc.olabel == 0) { comp_props |= kOEpsilons; comp_props &= ~kNoOEpsilons; } if (!first_arc) { if (arc.ilabel < prev_arc.ilabel) { comp_props |= kNotILabelSorted; comp_props &= ~kILabelSorted; } if (arc.olabel < prev_arc.olabel) { comp_props |= kNotOLabelSorted; comp_props &= ~kOLabelSorted; } } if (arc.weight != Weight::One() && arc.weight != Weight::Zero()) { comp_props |= kWeighted; comp_props &= ~kUnweighted; if ((comp_props & kUnweightedCycles) && scc[s] == scc[arc.nextstate]) { comp_props |= kWeightedCycles; comp_props &= ~kUnweightedCycles; } } if (arc.nextstate <= s) { comp_props |= kNotTopSorted; comp_props &= ~kTopSorted; } if (arc.nextstate != s + 1) { comp_props |= kNotString; comp_props &= ~kString; } prev_arc = arc; first_arc = false; if (ilabels) ilabels->insert(arc.ilabel); if (olabels) olabels->insert(arc.olabel); } if (nfinal > 0) { // Final state not last. comp_props |= kNotString; comp_props &= ~kString; } const auto final_weight = fst.Final(s); if (final_weight != Weight::Zero()) { // Final state. if (final_weight != Weight::One()) { comp_props |= kWeighted; comp_props &= ~kUnweighted; } ++nfinal; } else { // Non-final state. if (fst.NumArcs(s) != 1) { comp_props |= kNotString; comp_props &= ~kString; } } } if (fst.Start() != kNoStateId && fst.Start() != 0) { comp_props |= kNotString; comp_props &= ~kString; } } if (known) *known = KnownProperties(comp_props); return comp_props; } // Similar to ComputeProperties, but uses the properties already stored // in the FST when possible. template uint64 ComputeOrUseStoredProperties(const Fst &fst, uint64 mask, uint64 *known) { // Check stored FST properties first. const auto fst_props = fst.Properties(kFstProperties, /*test=*/false); 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; } return ComputeProperties(fst, mask, known); } // This is a wrapper around ComputeProperties that will cause a fatal error if // the stored properties and the computed properties are incompatible when // FLAGS_fst_verify_properties is true. This routine is seldom called directly; // instead it is used to implement fst.Properties(mask, /*test=*/true). template uint64 TestProperties(const Fst &fst, uint64 mask, uint64 *known) { if (FLAGS_fst_verify_properties) { const auto stored_props = fst.Properties(kFstProperties, false); const auto computed_props = ComputeProperties(fst, mask, known); if (!CompatProperties(stored_props, computed_props)) { FSTERROR() << "TestProperties: stored FST properties incorrect" << " (stored: props1, computed: props2)"; } return computed_props; } else { return ComputeOrUseStoredProperties(fst, mask, known); } } // If all the properties of 'fst' corresponding to 'check_mask' are known, // returns the stored properties. Otherwise, the properties corresponding to // both 'check_mask' and 'test_mask' are computed. This is used to check for // newly-added properties that might not be set in old binary files. template uint64 CheckProperties(const Fst &fst, uint64 check_mask, uint64 test_mask) { auto props = fst.Properties(kFstProperties, false); if (FLAGS_fst_verify_properties) { props = TestProperties(fst, check_mask | test_mask, /*known=*/nullptr); } else if ((KnownProperties(props) & check_mask) != check_mask) { props = ComputeProperties(fst, check_mask | test_mask, /*known=*/nullptr); } return props & (check_mask | test_mask); } } // namespace internal } // namespace fst #endif // FST_TEST_PROPERTIES_H_ openfst-1.7.9/src/include/fst/test/000077500000000000000000000000001421600557100171745ustar00rootroot00000000000000openfst-1.7.9/src/include/fst/test/algo_test.h000066400000000000000000001221401421600557100213260ustar00rootroot00000000000000// 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 #include #include #include #include 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. inline 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: using Label = typename Arc::Label; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; WeightedTester(uint64 seed, const Fst &zero_fst, const Fst &one_fst, const Fst &univ_fst, WeightGenerator weight_generator) : seed_(seed), rand_(seed), zero_fst_(zero_fst), one_fst_(one_fst), univ_fst_(univ_fst), generate_(std::move(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, ProjectType::INPUT); ProjectFst P2(T, ProjectType::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, ProjectType::INPUT); Invert(&I1); Project(&I1, ProjectType::OUTPUT); CHECK(Equiv(P1, I1)); } { VLOG(1) << "Check Pi_2(T) = Pi_1(T^-1) (destructive)."; VectorFst P1(T); VectorFst I1(T); Project(&P1, ProjectType::OUTPUT); Invert(&I1); Project(&I1, ProjectType::INPUT); CHECK(Equiv(P1, I1)); } { VLOG(1) << "Check Pi_1(T) = Pi_2(T^-1) (delayed)."; ProjectFst P1(T, ProjectType::INPUT); InvertFst I1(T); ProjectFst P2(I1, ProjectType::OUTPUT); CHECK(Equiv(P1, P2)); } { VLOG(1) << "Check Pi_2(T) = Pi_1(T^-1) (delayed)."; ProjectFst P1(T, ProjectType::OUTPUT); InvertFst I1(T); ProjectFst P2(I1, ProjectType::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 const UniformArcSelector uniform_selector(seed_); const RandGenOptions> opts(uniform_selector, kRandomPathLength); return RandEquivalent(fst1, fst2, kNumRandomPaths, opts, kTestDelta, seed_); } // 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, ProjectType::INPUT); Project(&P2, ProjectType::INPUT); if (!Equiv(P1, P2)) { LOG(ERROR) << "Inputs not equivalent"; return false; } // Ensures seed used once per instantiation. static const UniformArcSelector uniform_selector(seed_); const 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( MakeArcMapFst(pfst, RmWeightMapper())))); const Weight sum1 = Times(ShortestDistance(fst), threshold); const Weight sum2 = ShortestDistance(D); return ApproxEqual(Plus(sum1, sum2), sum1, kTestDelta); } // Random seed. uint64 seed_; // Random state (for randomness in this class). std::mt19937_64 rand_; // 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 generate_; // 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, uint64 seed) {} 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: using Arc = StdArc; using Label = Arc::Label; using StateId = Arc::StateId; using Weight = Arc::Weight; UnweightedTester(const Fst &zero_fsa, const Fst &one_fsa, const Fst &univ_fsa, uint64 seed) : zero_fsa_(zero_fsa), one_fsa_(one_fsa), univ_fsa_(univ_fsa), rand_(seed) {} 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_); const int n = std::uniform_int_distribution<>(0, 4)(rand_); 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)."; const int n = std::uniform_int_distribution<>(0, 4)(rand_); 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) { // Skips 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; // Checks both 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_; // Random state. std::mt19937_64 rand_; }; // 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: using Label = typename Arc::Label; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; AlgoTester(WeightGenerator generator, uint64 seed) : generate_(std::move(generator)), rand_(seed) { one_fst_.AddState(); one_fst_.SetStart(0); one_fst_.SetFinal(0); univ_fst_.AddState(); univ_fst_.SetStart(0); univ_fst_.SetFinal(0); for (int i = 0; i < kNumRandomLabels; ++i) univ_fst_.EmplaceArc(0, i, i, 0); weighted_tester_.reset(new WeightedTester( seed, zero_fst_, one_fst_, univ_fst_, generate_)); unweighted_tester_.reset( new UnweightedTester(zero_fst_, one_fst_, univ_fst_, seed)); } void MakeRandFst(MutableFst *fst) { RandFst(kNumRandomStates, kNumRandomArcs, kNumRandomLabels, kAcyclicProb, generate_, rand_(), 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, ProjectType::OUTPUT); Project(&A2, ProjectType::INPUT); Project(&A3, ProjectType::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 generate_; // Random state used to seed RandFst. std::mt19937_64 rand_; // 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 std::unique_ptr> weighted_tester_; // Tests unweighted FSTs std::unique_ptr> 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_ openfst-1.7.9/src/include/fst/test/compactors.h000066400000000000000000000106161421600557100215230ustar00rootroot00000000000000#ifndef FST_TEST_COMPACTORS_H_ #define FST_TEST_COMPACTORS_H_ // See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Compactors for use in tests. See compact-fst.h. #include #include #include #include #include namespace fst { // A user-defined compactor for test FST. // Stores all Arc components as a tuple. template class TrivialArcCompactor { public: using Arc = A; using Label = typename A::Label; using StateId = typename A::StateId; using Weight = typename A::Weight; // We use ArcTpl, which is trivially copyable if Weight is. static_assert(std::is_trivially_copyable::value, "Weight must be trivially copyable."); using Element = ArcTpl; static_assert(std::is_trivially_copyable::value, "ArcTpl should be trivially copyable; someone broke it."); Element Compact(StateId s, const A &arc) const { return Element(arc.ilabel, arc.olabel, arc.weight, arc.nextstate); } Arc Expand(StateId s, const Element &e, uint32 f = kArcValueFlags) const { return Arc(e.ilabel, e.olabel, e.weight, e.nextstate); } ssize_t Size() const { return -1; } uint64 Properties() const { return 0ULL; } bool Compatible(const Fst &fst) const { return true; } static const std::string &Type() { static const std::string *const type = new std::string("trival_arc_compactor_" + Arc::Type()); return *type; } bool Write(std::ostream &strm) const { return true; } static TrivialArcCompactor *Read(std::istream &strm) { return new TrivialArcCompactor; } }; // A user-defined arc compactor for test FST. // Doesn't actually do any compacting, but exercises the Compactor interface. template class TrivialCompactor { public: using Arc = A; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; TrivialCompactor() { CHECK(false); } // Constructor from the Fst to be compacted. If compactor is present, // only optional state should be copied from it. explicit TrivialCompactor(const Fst &fst, std::shared_ptr = nullptr) : fst_(fst.Copy()) {} // Copy constructor. Must make a thread-safe copy suitable for use by // by Fst::Copy(/*safe=*/true). TrivialCompactor(const TrivialCompactor &compactor) : fst_(compactor.fst_->Copy(/*safe=*/true)) {} StateId Start() const { return fst_->Start(); } StateId NumStates() const { return CountStates(*fst_); } size_t NumArcs() const { return CountArcs(*fst_); } // Accessor class for state attributes. class State { public: State() = default; State(const TrivialCompactor *c, StateId s) : c_(c), s_(s), i_(fst::make_unique>>(*c->fst_, s)) {} StateId GetStateId() const { return s_; } Weight Final() const { return c_->fst_->Final(s_); } size_t NumArcs() const { return c_->fst_->NumArcs(s_); } Arc GetArc(size_t i, uint32 f) const { i_->Seek(i); return i_->Value(); } private: const TrivialCompactor *c_ = nullptr; StateId s_ = kNoStateId; std::unique_ptr>> i_; }; void SetState(StateId s, State *state) { *state = State(this, s); } template bool IsCompatible(const Fst &fst) const { return std::is_same::value; } uint64 Properties(uint64 props) const { return props; } static const std::string &Type() { static const std::string *const type = new std::string("trivial_compactor_" + Arc::Type()); return *type; } bool Error() const { return fst_->Properties(kError, /*test=*/false); } bool Write(std::ostream &strm, const FstWriteOptions &opts) const { WriteType(strm, Type()); // Write as a VectorFst. return VectorFst::WriteFst(*fst_, strm, opts); } static TrivialCompactor *Read(std::istream &strm, FstReadOptions opts, const FstHeader &hdr) { std::string type; ReadType(strm, &type); if (type != Type()) return nullptr; opts.header = nullptr; auto fst = fst::WrapUnique(VectorFst::Read(strm, opts)); if (fst == nullptr) return nullptr; return new TrivialCompactor(*fst); } private: std::unique_ptr> fst_; }; } // namespace fst #endif // FST_TEST_COMPACTORS_H_ openfst-1.7.9/src/include/fst/test/fst_test.h000066400000000000000000000225171421600557100212070ustar00rootroot00000000000000// 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: using Arc = typename F::Arc; using StateId = typename Arc::StateId; using Weight = typename Arc::Weight; using Label = typename Arc::Label; explicit FstTester(size_t num_states = 128, bool weighted = true) : num_states_(num_states), weighted_(weighted) { VectorFst vfst; InitFst(&vfst, num_states); testfst_ = new F(vfst); } ~FstTester() { delete testfst_; } // This verifies the contents described in InitFst() using // methods defined in a generic Fst. template void TestBase(const G &fst) const { StateId ns = 0; StateIterator siter(fst); Matcher matcher(fst, MATCH_INPUT); MatchType match_type = matcher.Type(true); bool has_states = false; for (; !siter.Done(); siter.Next()) { has_states = true; } CHECK_EQ(fst.Start(), has_states ? 0 : kNoStateId); 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)); if (na == ns + 1) { CHECK_EQ(arc.nextstate, s == num_states_ - 1 ? 0 : s + 1); } else { 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 + 1); CHECK_EQ(na, aiter.Position()); CHECK_EQ(fst.NumArcs(s), s + 1); CHECK_EQ(fst.NumInputEpsilons(s), 0); CHECK_EQ(fst.NumOutputEpsilons(s), s + 1); CHECK(!matcher.Find(s + 2)); // out-of-range CHECK(!matcher.Find(kNoLabel)); // no explicit input epsilons CHECK(matcher.Find(0)); CHECK_EQ(matcher.Value().ilabel, kNoLabel); // implicit epsilon loop ++ns; } CHECK_EQ(num_states_, ns); CHECK(Verify(fst)); CHECK(fst.Properties(ns > 0 ? kNotAcceptor : kAcceptor, true)); CHECK(fst.Properties(ns > 0 ? kOEpsilons : kNoOEpsilons, true)); } void TestBase() const { TestBase(*testfst_); } // This verifies methods specfic to an ExpandedFst. template void TestExpanded(const G &fst) const { CHECK_EQ(fst.NumStates(), num_states_); 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 operator= template void TestAssign(const 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 constructor and Copy method. 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 std::string filename = FLAGS_tmpdir + "/test.fst"; const std::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 + 1 // (b) For ith arc (i: 1 to s) of s: // (1) ilabel = i // (2) olabel = 0 // (3) weight = NthWeight(i) // (4) nextstate = s // (c) s+1st arc of s: // (1) ilabel = s + 1 // (2) olabel = 0 // (3) weight = NthWeight(s + 1) // (4) nextstate = s + 1 if s < nstates - 1 // 0 if s == nstates - 1 void InitFst(MutableFst *fst, size_t nstates) const { fst->DeleteStates(); 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->AddArc( s, Arc(s + 1, 0, NthWeight(s + 1), s == nstates - 1 ? 0 : s + 1)); } if (nstates > 0) fst->SetStart(0); } // Generates One() + ... + One() (n times) if weighted_, // otherwise One(). Weight NthWeight(int n) const { if (!weighted_) return Weight::One(); Weight w = Weight::Zero(); for (int i = 0; i < n; ++i) w = Plus(w, Weight::One()); return w; } size_t num_states_ = 0; bool weighted_ = true; F *testfst_; // what we're testing }; } // namespace fst #endif // FST_TEST_FST_TEST_H_ openfst-1.7.9/src/include/fst/test/rand-fst.h000066400000000000000000000055431421600557100210720ustar00rootroot00000000000000#ifndef FST_TEST_RAND_FST_H_ #define FST_TEST_RAND_FST_H_ #include #include #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, Generate generate, uint64 seed, MutableFst *fst) { using Label = typename Arc::Label; using StateId = typename Arc::StateId; using Weight = typename Arc::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 }; std::mt19937_64 rand(seed); const StateId ns = std::uniform_int_distribution<>(0, num_random_states - 1)(rand); std::uniform_int_distribution arc_dist(0, num_random_arcs - 1); std::uniform_int_distribution { 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_ openfst-1.7.9/src/include/fst/util.h000066400000000000000000000305541421600557100173520ustar00rootroot00000000000000// 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 #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, std::string *s) { // NOLINT s->clear(); int32 ns = 0; ReadType(strm, &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::array *c) { for (auto &v : *c) ReadType(strm, &v); return strm; } 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, // NOLINT const std::string &s) { int32 ns = s.size(); WriteType(strm, 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 &WriteSequence(std::ostream &strm, const C &c) { for (const auto &e : c) { WriteType(strm, e); } return strm; } template std::ostream &WriteContainer(std::ostream &strm, const C &c) { const int64 n = c.size(); WriteType(strm, n); WriteSequence(strm, c); return strm; } } // namespace internal template std::ostream &WriteType(std::ostream &strm, const std::array &c) { return internal::WriteSequence(strm, c); } 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 std::string &s, const std::string &source, size_t nline, bool allow_negative, bool *error = nullptr); template Weight StrToWeight(const std::string &s) { Weight w; std::istringstream strm(s); strm >> w; if (!strm) { FSTERROR() << "StrToWeight: Bad weight: " << s; return Weight::NoWeight(); } return w; } template void WeightToStr(Weight w, std::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 std::string &source, std::vector> *pairs, bool allow_negative = false) { std::ifstream strm(source, std::ios_base::in); if (!strm) { LOG(ERROR) << "ReadIntPairs: Can't open file: " << source; 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 = " << source << ", line = " << nline; return false; } bool err; I i1 = StrToInt64(col[0], source, nline, allow_negative, &err); if (err) return false; I i2 = StrToInt64(col[1], source, nline, allow_negative, &err); if (err) return false; pairs->emplace_back(i1, i2); } return true; } template bool WriteIntPairs(const std::string &source, const std::vector> &pairs) { std::ofstream fstrm; if (!source.empty()) { fstrm.open(source); if (!fstrm) { LOG(ERROR) << "WriteIntPairs: Can't open file: " << source; return false; } } std::ostream &ostrm = fstrm.is_open() ? fstrm : std::cout; for (const auto &pair : pairs) { ostrm << pair.first << "\t" << pair.second << "\n"; } return !!ostrm; } // Utilities for reading/writing label pairs. template bool ReadLabelPairs(const std::string &source, std::vector> *pairs, bool allow_negative = false) { return ReadIntPairs(source, pairs, allow_negative); } template bool WriteLabelPairs(const std::string &source, const std::vector> &pairs) { return WriteIntPairs(source, pairs); } // Utilities for converting a type name to a legal C symbol. void ConvertToLegalCSymbol(std::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_ openfst-1.7.9/src/include/fst/vector-fst.h000066400000000000000000000605211421600557100204660ustar00rootroot00000000000000// 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 #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_(Weight::Zero()), niepsilons_(0), noepsilons_(0), arcs_(alloc) {} VectorState(const VectorState &state, const ArcAllocator &alloc) : final_weight_(state.Final()), niepsilons_(state.NumInputEpsilons()), noepsilons_(state.NumOutputEpsilons()), arcs_(state.arcs_.begin(), state.arcs_.end(), alloc) {} void Reset() { final_weight_ = Weight::Zero(); niepsilons_ = 0; noepsilons_ = 0; arcs_.clear(); } Weight Final() const { return final_weight_; } 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_weight_ = std::move(weight); } void SetNumInputEpsilons(size_t n) { niepsilons_ = n; } void SetNumOutputEpsilons(size_t n) { noepsilons_ = n; } void AddArc(const Arc &arc) { IncrementNumEpsilons(arc); arcs_.push_back(arc); } void AddArc(Arc &&arc) { IncrementNumEpsilons(arc); arcs_.push_back(std::move(arc)); } template void EmplaceArc(T &&... ctor_args) { arcs_.emplace_back(std::forward(ctor_args)...); IncrementNumEpsilons(arcs_.back()); } void SetArc(const Arc &arc, size_t n) { if (arcs_[n].ilabel == 0) --niepsilons_; if (arcs_[n].olabel == 0) --noepsilons_; IncrementNumEpsilons(arc); 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: // Update the number of epsilons as a result of having added an arc. void IncrementNumEpsilons(const Arc &arc) { if (arc.ilabel == 0) ++niepsilons_; if (arc.olabel == 0) ++noepsilons_; } Weight final_weight_; // 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 (auto *state : states_) State::Destroy(state, &state_alloc_); } // Copying is not permitted. VectorFstBaseImpl(const VectorFstBaseImpl &) = delete; VectorFstBaseImpl &operator=(const VectorFstBaseImpl &) = delete; // Moving is permitted. VectorFstBaseImpl(VectorFstBaseImpl &&impl) noexcept : FstImpl(), states_(std::move(impl.states_)), start_(impl.start_) { impl.states_.clear(); impl.start_ = kNoStateId; } VectorFstBaseImpl &operator=(VectorFstBaseImpl &&impl) noexcept { for (auto *state : states_) { State::Destroy(state, &state_alloc_); } states_.clear(); std::swap(states_, impl.states_); start_ = impl.start_; impl.start_ = kNoStateId; return *this; } 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(State *state) { states_.push_back(state); return states_.size() - 1; } StateId AddState() { return AddState(CreateState()); } void AddStates(size_t n) { const auto curr_num_states = NumStates(); states_.resize(n + curr_num_states); std::generate(states_.begin() + curr_num_states, states_.end(), [this] { return CreateState(); }); } void AddArc(StateId state, const Arc &arc) { states_[state]->AddArc(arc); } void AddArc(StateId state, Arc &&arc) { states_[state]->AddArc(std::move(arc)); } template void EmplaceArc(StateId state, T &&... ctor_args) { states_[state]->EmplaceArc(std::forward(ctor_args)...); } void DeleteStates(const std::vector &dstates) { std::vector newid(states_.size(), 0); for (size_t 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 (size_t 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(size_t 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: State *CreateState() { return new (&state_alloc_) State(arc_alloc_); } std::vector states_; StateId start_; typename State::StateAllocator state_alloc_; typename State::ArcAllocator arc_alloc_; }; // 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 AddStates(size_t n) { BaseImpl::AddStates(n); SetProperties(AddStateProperties(Properties())); } void AddArc(StateId state, const Arc &arc) { BaseImpl::AddArc(state, arc); UpdatePropertiesAfterAddArc(state); } void AddArc(StateId state, Arc &&arc) { BaseImpl::AddArc(state, std::move(arc)); UpdatePropertiesAfterAddArc(state); } template void EmplaceArc(StateId state, T &&... ctor_args) { BaseImpl::EmplaceArc(state, std::forward(ctor_args)...); UpdatePropertiesAfterAddArc(state); } 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: void UpdatePropertiesAfterAddArc(StateId state) { auto *vstate = GetState(state); const size_t num_arcs{vstate->NumArcs()}; if (num_arcs) { const auto &arc = vstate->GetArc(num_arcs - 1); const auto *parc = (num_arcs < 2) ? nullptr : &(vstate->GetArc(num_arcs - 2)); SetProperties(AddArcProperties(Properties(), state, arc, parc)); } } // 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, std::move(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. // // VectorFst is thread-compatible. 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 unused_safe = false) : ImplToMutableFst(fst.GetSharedImpl()) {} VectorFst(VectorFst &&) noexcept; // 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 &) = default; VectorFst &operator=(VectorFst &&) noexcept; VectorFst &operator=(const Fst &fst) override { if (this != &fst) SetImpl(std::make_shared(fst)); return *this; } template void EmplaceArc(StateId state, T &&... ctor_args) { MutateCheck(); GetMutableImpl()->EmplaceArc(state, std::forward(ctor_args)...); } // 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 source // reads from standard input. static VectorFst *Read(const std::string &source) { auto *impl = ImplToExpandedFst>::Read(source); 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 std::string &source) const override { return Fst::WriteFile(source); } 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>::GetMutableImpl; using ImplToMutableFst>::MutateCheck; using ImplToMutableFst>::SetImpl; explicit VectorFst(std::shared_ptr impl) : ImplToMutableFst(impl) {} }; template inline VectorFst::VectorFst(VectorFst &&fst) noexcept = default; template inline VectorFst &VectorFst::operator=( VectorFst &&fst) noexcept = default; // 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); std::streampos 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 uint8 Flags() const { return kArcValueFlags; } void SetFlags(uint8, uint8) {} 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_); uint64 properties = properties_->load(std::memory_order_relaxed); 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; properties_->store(properties, std::memory_order_relaxed); } uint8 Flags() const final { return kArcValueFlags; } void SetFlags(uint8, uint8) final {} private: State *state_; std::atomic *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_ openfst-1.7.9/src/include/fst/verify.h000066400000000000000000000070101421600557100176700ustar00rootroot00000000000000// 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 #include namespace fst { // Verifies that an Fst's contents are sane. template bool Verify(const Fst &fst, bool allow_negative_labels = false) { const auto start = fst.Start(); const auto *isyms = fst.InputSymbols(); const auto *osyms = fst.OutputSymbols(); const auto ns = CountStates(fst); 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->Member(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->Member(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, /*test=*/false); if (fst_props & kError) { LOG(ERROR) << "Verify: FST error property is set"; return false; } uint64 known_props; uint64 test_props = internal::ComputeProperties(fst, kFstProperties, &known_props); if (!internal::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_ openfst-1.7.9/src/include/fst/visit.h000066400000000000000000000222021421600557100175220ustar00rootroot00000000000000// 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_ openfst-1.7.9/src/include/fst/weight.h000066400000000000000000000317571421600557100176720ustar00rootroot00000000000000// 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 #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: // - In a left semiring, for all a, b, b', c: // if Times(a, b) = c, Divide(c, a, DIVIDE_LEFT) = b' and b'.Member(), // then Times(a, b') = c. // - In a right semiring, for all a, a', b, c: // if Times(a, b) = c, Divide(c, b, DIVIDE_RIGHT) = a' and a'.Member(), // then Times(a', b) = c. // - In a commutative semiring, // * for all a, c: // Divide(c, a, DIVIDE_ANY) = Divide(c, a, DIVIDE_LEFT) // = Divide(c, a, DIVIDE_RIGHT) // * for all a, b, b', c: // if Times(a, b), Divide(c, a, DIVIDE_ANY) = b' and b'.Member(), // then Times(a, b') = c // - In the case where there exist no b such that c = Times(a, b), the // return value of Divide(c, a, DIVIDE_LEFT) is unspecified. Returning // Weight::NoWeight() is recommemded but not required in order to // allow the most efficient implementation. // - All algorithms in this library only call Divide(c, a) when it is // guaranteed that there exists a b such that c = Times(a, b). // // 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: Adder() : sum_(Weight::Zero()) {} explicit Adder(Weight w) : sum_(std::move(w)) {} Weight Add(const Weight &w) { sum_ = Plus(sum_, w); return sum_; } Weight Sum() const { return sum_; } void Reset(Weight w = Weight::Zero()) { sum_ = std::move(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 { constexpr W operator()(W weight) const { return weight; } }; // General random weight generator: raises error. // // The standard interface is roughly: // // class WeightGenerate { // public: // explicit WeightGenerate(uint64 seed = std::random_device()(), // bool allow_zero = true, // ...); // // MyWeight operator()() const; // }; // // Many weight generators also take trailing constructor arguments specifying // the number of random (unique) weights, the length of weights (e.g., for // string-based weights), etc. with sensible defaults 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) { std::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_ openfst-1.7.9/src/include/fst/windows_defs.inc000066400000000000000000000002351421600557100214030ustar00rootroot00000000000000// Aggregator file for common things that need to be defined when building // for Windows. #ifdef _WIN32 #include using ssize_t = SSIZE_T; #endifopenfst-1.7.9/src/lib/000077500000000000000000000000001421600557100145445ustar00rootroot00000000000000openfst-1.7.9/src/lib/Makefile.am000066400000000000000000000005351421600557100166030ustar00rootroot00000000000000AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS) lib_LTLIBRARIES = libfst.la libfst_la_SOURCES = compat.cc encode.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 22:0:0 libfst_la_LIBADD = $(DL_LIBS) openfst-1.7.9/src/lib/Makefile.in000066400000000000000000000560351421600557100166220ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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 encode.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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/compat.Plo ./$(DEPDIR)/encode.Plo \ ./$(DEPDIR)/flags.Plo ./$(DEPDIR)/fst-types.Plo \ ./$(DEPDIR)/fst.Plo ./$(DEPDIR)/mapped-file.Plo \ ./$(DEPDIR)/properties.Plo ./$(DEPDIR)/symbol-table-ops.Plo \ ./$(DEPDIR)/symbol-table.Plo ./$(DEPDIR)/util.Plo \ ./$(DEPDIR)/weight.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 encode.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 22: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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encode.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flags.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst-types.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mapped-file.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/properties.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/symbol-table-ops.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/symbol-table.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/util.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/compat.Plo -rm -f ./$(DEPDIR)/encode.Plo -rm -f ./$(DEPDIR)/flags.Plo -rm -f ./$(DEPDIR)/fst-types.Plo -rm -f ./$(DEPDIR)/fst.Plo -rm -f ./$(DEPDIR)/mapped-file.Plo -rm -f ./$(DEPDIR)/properties.Plo -rm -f ./$(DEPDIR)/symbol-table-ops.Plo -rm -f ./$(DEPDIR)/symbol-table.Plo -rm -f ./$(DEPDIR)/util.Plo -rm -f ./$(DEPDIR)/weight.Plo -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 -f ./$(DEPDIR)/compat.Plo -rm -f ./$(DEPDIR)/encode.Plo -rm -f ./$(DEPDIR)/flags.Plo -rm -f ./$(DEPDIR)/fst-types.Plo -rm -f ./$(DEPDIR)/fst.Plo -rm -f ./$(DEPDIR)/mapped-file.Plo -rm -f ./$(DEPDIR)/properties.Plo -rm -f ./$(DEPDIR)/symbol-table-ops.Plo -rm -f ./$(DEPDIR)/symbol-table.Plo -rm -f ./$(DEPDIR)/util.Plo -rm -f ./$(DEPDIR)/weight.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/lib/compat.cc000066400000000000000000000077271421600557100163530ustar00rootroot00000000000000// 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 compatibility definitions. #include #include #include #include #include void FailedNewHandler() { std::cerr << "Memory allocation failed" << std::endl; std::exit(1); } namespace fst { CheckSummer::CheckSummer() : count_(0) { check_sum_.resize(kCheckSumLength, '\0'); } void CheckSummer::Reset() { count_ = 0; for (int i = 0; i < kCheckSumLength; ++i) check_sum_[i] = '\0'; } void CheckSummer::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 CheckSummer::Update(std::string const &data) { for (int i = 0; i < data.size(); ++i) { check_sum_[(count_++) % kCheckSumLength] ^= data[i]; } } // String joining and splitting. namespace { // Computes size of joined string. size_t GetResultSize(const std::vector &elements, size_t s_size) { const auto lambda = [](size_t partial, const std::string &right) { return partial + right.size(); }; return (std::accumulate(elements.begin(), elements.end(), 0, lambda) + s_size * (elements.size() - 1)); } } // namespace // Joins a vector of strings on a given delimiter. std::string StringJoin(const std::vector &elements, const std::string &delim) { std::string result; if (elements.empty()) return result; size_t s_size = delim.size(); result.reserve(GetResultSize(elements, s_size)); auto it = elements.begin(); result.append(it->data(), it->size()); for (++it; it != elements.end(); ++it) { result.append(delim.data(), s_size); result.append(it->data(), it->size()); } return result; } std::string StringJoin(const std::vector &elements, const char *delim) { const std::string str_delim(delim); return StringJoin(elements, str_delim); } std::string StringJoin(const std::vector &elements, char delim) { const std::string str_delim{delim}; return StringJoin(elements, str_delim); } // Splits a string according to delimiter, skipping over consecutive // delimiters. std::vector StringSplit(const std::string &full, const std::string &delim) { size_t prev = 0; size_t found = full.find_first_of(delim); size_t size = found - prev; std::vector result; if (size > 0) result.push_back(full.substr(prev, size)); while (found != std::string::npos) { prev = found + 1; found = full.find_first_of(delim, prev); size = found - prev; if (size > 0) result.push_back(full.substr(prev, size)); } return result; } std::vector StringSplit(const std::string &full, const char *delim) { const std::string str_delim(delim); return StringSplit(full, str_delim); } std::vector StringSplit(const std::string &full, char delim) { const std::string str_delim{delim}; return StringSplit(full, str_delim); } void StripTrailingAsciiWhitespace(std::string *full) { const auto lambda = [](char ch) { return !std::isspace(ch); }; const auto pos = std::find_if(full->rbegin(), full->rend(), lambda).base(); full->erase(pos, full->end()); } std::string StripTrailingAsciiWhitespace(const std::string &full) { std::string copy(full); StripTrailingAsciiWhitespace(©); return copy; } } // namespace fst openfst-1.7.9/src/lib/encode.cc000066400000000000000000000025531421600557100163150ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Definitions for encode table header. #include namespace fst { bool EncodeTableHeader::Read(std::istream &strm, const std::string &source) { int32 magic_number; ReadType(strm, &magic_number); if (magic_number == internal::kEncodeMagicNumber) { ReadType(strm, &arctype_); ReadType(strm, &flags_); ReadType(strm, &size_); } else if (magic_number == internal::kEncodeDeprecatedMagicNumber) { // TODO(b/141172858): deprecated, remove by 2020-01-01. uint32 flags; ReadType(strm, &flags); flags_ = flags; int64 size; ReadType(strm, &size); size_ = size; } else { LOG(ERROR) << "EncodeTableHeader::Read: Bad encode table header: " << source; return false; } if (!strm) { LOG(ERROR) << "EncodeTableHeader::Read: Read failed: " << source; return false; } return true; } bool EncodeTableHeader::Write(std::ostream &strm, const std::string &source) const { WriteType(strm, internal::kEncodeMagicNumber); WriteType(strm, arctype_); WriteType(strm, flags_); WriteType(strm, size_); strm.flush(); if (!strm) { LOG(ERROR) << "EncodeTableHeader::Write: Write failed: " << source; return false; } return true; } } // namespace fst openfst-1.7.9/src/lib/flags.cc000066400000000000000000000121631421600557100161520ustar00rootroot00000000000000// 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 #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"); static std::string flag_usage; static std::string prog_src; // Sets prog_src to src. static void SetProgSrc(const char *src) { prog_src = src; // Remove "-main" in src filename. Flags are defined in fstx.cc but SetFlags() // is called in fstx-main.cc, which results in a filename mismatch in // ShowUsageRestrict() below. static constexpr char kMainSuffix[] = "-main.cc"; const int prefix_length = prog_src.size() - strlen(kMainSuffix); if (prefix_length > 0 && prog_src.substr(prefix_length) == kMainSuffix) { prog_src.erase(prefix_length, strlen("-main")); } } void SetFlags(const char *usage, int *argc, char ***argv, bool remove_flags, const char *src) { flag_usage = usage; SetProgSrc(src); int index = 1; for (; index < *argc; ++index) { std::string argval = (*argv)[index]; if (argval[0] != '-' || argval == "-") break; while (argval[0] == '-') argval = argval.substr(1); // Removes initial '-'. std::string arg = argval; std::string val = ""; // Splits argval (arg=val) into arg and val. auto pos = argval.find("="); if (pos != std::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 uint64_register = FlagRegister::GetRegister(); if (uint64_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 std::string &src, bool in_src, bool show_file) { std::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) std::cout << std::endl;; std::cout << "Flags from: " << file << std::endl; file_out = true; } old_file = file; } std::cout << usage << std::endl; ; usage_out = true; } if (usage_out) std::cout << std::endl; ; } void ShowUsage(bool long_usage) { std::set> usage_set; std::cout << flag_usage << std::endl; ; 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 uint64_register = FlagRegister::GetRegister(); uint64_register->GetUsage(&usage_set); auto double_register = FlagRegister::GetRegister(); double_register->GetUsage(&usage_set); if (!prog_src.empty()) { std::cout << "PROGRAM FLAGS:" << std::endl << std::endl; ; ShowUsageRestrict(usage_set, prog_src, true, false); } if (!long_usage) return; if (!prog_src.empty()) { std::cout << "LIBRARY FLAGS:" << std::endl << std::endl; } ShowUsageRestrict(usage_set, prog_src, false, true); } openfst-1.7.9/src/lib/fst-types.cc000066400000000000000000000024721421600557100170160ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Registration of common FST and arc types. #include #include #include #include #include #include namespace fst { 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_FST(CompactStringFst, StdArc); REGISTER_FST(CompactStringFst, LogArc); REGISTER_FST(CompactStringFst, Log64Arc); REGISTER_FST(CompactWeightedStringFst, StdArc); REGISTER_FST(CompactWeightedStringFst, LogArc); REGISTER_FST(CompactWeightedStringFst, Log64Arc); REGISTER_FST(CompactAcceptorFst, StdArc); REGISTER_FST(CompactAcceptorFst, LogArc); REGISTER_FST(CompactAcceptorFst, Log64Arc); REGISTER_FST(CompactUnweightedFst, StdArc); REGISTER_FST(CompactUnweightedFst, LogArc); REGISTER_FST(CompactUnweightedFst, Log64Arc); REGISTER_FST(CompactUnweightedAcceptorFst, StdArc); REGISTER_FST(CompactUnweightedAcceptorFst, LogArc); REGISTER_FST(CompactUnweightedAcceptorFst, Log64Arc); } // namespace fst openfst-1.7.9/src/lib/fst.cc000066400000000000000000000117411421600557100156530ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // FST definitions. #include #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 std::string &) { int64 pos = strm.tellg(); bool match = true; int32 magic_number = 0; ReadType(strm, &magic_number); if (magic_number != kFstMagicNumber) { LOG(WARNING) << "Magic number not matched. Got: " << magic_number; 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 std::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 << ". Magic number not matched. Got: " << magic_number; 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 std::string &) 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; } std::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 std::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 std::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 std::string &mode) { if (mode == "read") return READ; if (mode == "map") return MAP; LOG(ERROR) << "Unknown file read mode " << mode; return READ; } std::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 openfst-1.7.9/src/lib/mapped-file.cc000066400000000000000000000141501421600557100172370ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // #include #include #include #ifdef _WIN32 #include // for _get_osfhandle, _open #include // for CreateFileMapping, UnmapViewOfFile #include #else #include #include #endif // _WIN32 #include #include #include #include #include #include #include namespace fst { #ifdef _WIN32 namespace { static constexpr DWORD DWORD_MAX = std::numeric_limits::max(); } // namespace #endif // _WIN32 MappedFile::MappedFile(const MemoryRegion ®ion) : region_(region) {} MappedFile::~MappedFile() { if (region_.size != 0) { if (region_.mmap) { VLOG(2) << "munmap'ed " << region_.size << " bytes at " << region_.mmap; #ifdef _WIN32 if (UnmapViewOfFile(region_.mmap) != 0) { LOG(ERROR) << "Failed to unmap region: " << GetLastError(); } CloseHandle(region_.file_mapping); #else if (munmap(region_.mmap, region_.size) != 0) { LOG(ERROR) << "Failed to unmap region: " << strerror(errno); } #endif } else { if (region_.data) { operator delete(static_cast(region_.data) - region_.offset); } } } } MappedFile *MappedFile::Map(std::istream *istrm, bool memorymap, const std::string &source, size_t size) { const auto spos = istrm->tellg(); VLOG(2) << "memorymap: " << (memorymap ? "true" : "false") << " source: \"" << source << "\"" << " size: " << size << " offset: " << spos; if (memorymap && spos >= 0 && spos % kArchAlignment == 0) { const size_t pos = static_cast(spos); #ifdef _WIN32 const int fd = _open(source.c_str(), _O_RDONLY); #else const int fd = open(source.c_str(), O_RDONLY); #endif if (fd != -1) { std::unique_ptr mmf(MapFromFileDescriptor(fd, pos, size)); if (close(fd) == 0 && mmf != nullptr) { istrm->seekg(pos + size, std::ios::beg); if (istrm) { VLOG(2) << "mmap'ed region of " << size << " at offset " << pos << " from " << source << " to addr " << mmf->region_.mmap; return mmf.release(); } } else { LOG(WARNING) << "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 = static_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::MapFromFileDescriptor(int fd, size_t pos, size_t size) { #ifdef _WIN32 SYSTEM_INFO sysInfo; GetSystemInfo(&sysInfo); const DWORD pagesize = sysInfo.dwPageSize; #else const int pagesize = sysconf(_SC_PAGESIZE); #endif // _WIN32 const size_t offset = pos % pagesize; const size_t offset_pos = pos - offset; const size_t upsize = size + offset; #ifdef _WIN32 if (fd == -1) { LOG(ERROR) << "Invalid file descriptor fd=" << fd; return nullptr; } HANDLE file = reinterpret_cast(_get_osfhandle(fd)); if (file == INVALID_HANDLE_VALUE) { LOG(ERROR) << "Invalid file descriptor fd=" << fd; return nullptr; } HANDLE file_mapping = CreateFileMappingA(file, nullptr, PAGE_READONLY, upsize >> (8 * sizeof(DWORD)), upsize & DWORD_MAX, nullptr); if (file_mapping == INVALID_HANDLE_VALUE) { LOG(ERROR) << "Can't create mapping for fd=" << fd << " size=" << upsize << ": " << GetLastError(); return nullptr; } void *map = MapViewOfFile(file_mapping, FILE_MAP_READ, offset_pos >> (8 * sizeof(DWORD)), offset_pos & DWORD_MAX, upsize); if (!map) { LOG(ERROR) << "mmap failed for fd=" << fd << " size=" << upsize << " offset=" << offset_pos << ": " << GetLastError(); CloseHandle(file_mapping); return nullptr; } #else void *map = mmap(nullptr, upsize, PROT_READ, MAP_SHARED, fd, offset_pos); if (map == MAP_FAILED) { LOG(ERROR) << "mmap failed for fd=" << fd << " size=" << upsize << " offset=" << offset_pos; return nullptr; } #endif MemoryRegion region; region.mmap = map; region.size = upsize; region.data = static_cast(static_cast(map) + offset); region.offset = offset; #ifdef _WIN32 region.file_mapping = file_mapping; #endif // _WIN32 return new MappedFile(region); } MappedFile *MappedFile::Allocate(size_t size, size_t align) { MemoryRegion region; region.data = nullptr; region.offset = 0; if (size > 0) { // TODO(jrosenstock,sorenj): Use std::align() when that is no longer banned. // Use std::aligned_alloc() when C++17 is allowed. char *buffer = static_cast(operator new(size + align)); uintptr_t address = reinterpret_cast(buffer); region.offset = align - (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 size_t MappedFile::kArchAlignment; constexpr size_t MappedFile::kMaxReadChunk; } // namespace fst openfst-1.7.9/src/lib/properties.cc000066400000000000000000000423401421600557100172520ustar00rootroot00000000000000// 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 #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, 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, size_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 openfst-1.7.9/src/lib/symbol-table-ops.cc000066400000000000000000000077661421600557100202640ustar00rootroot00000000000000// 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 (const auto &litem : left) { merged->AddSymbol(litem.Symbol(), litem.Label()); if (right_has_all) { int64 key = right.Find(litem.Symbol()); if (key == -1) { right_has_all = false; } else if (!relabel && key != litem.Label()) { relabel = true; } } } if (right_has_all) { if (right_relabel_output) *right_relabel_output = relabel; return right.Copy(); } // Adds all symbols we can from right symbol table. std::vector conflicts; for (const auto &ritem : right) { int64 key = merged->Find(ritem.Symbol()); if (key != -1) { // Symbol already exists, maybe with different value. if (key != ritem.Label()) relabel = true; continue; } // Symbol doesn't exist from left. left_has_all = false; if (!merged->Find(ritem.Label()).empty()) { // We can't add this where we want to, add it later, in order. conflicts.push_back(ritem.Symbol()); continue; } // There is a hole and we can add this symbol with its ID. merged->AddSymbol(ritem.Symbol(), ritem.Label()); } if (right_relabel_output) *right_relabel_output = relabel; if (left_has_all) return left.Copy(); // Adds 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; for (const auto &stitem : syms) { sorted[stitem.Label()] = stitem.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 std::string &source, bool input_symbols) { std::ifstream in(source, std::ios_base::in | std::ios_base::binary); if (!in) { LOG(ERROR) << "FstReadSymbols: Can't open file " << source; return nullptr; } FstHeader hdr; if (!hdr.Read(in, source)) { LOG(ERROR) << "FstReadSymbols: Couldn't read header from " << source; return nullptr; } if (hdr.GetFlags() & FstHeader::HAS_ISYMBOLS) { std::unique_ptr isymbols(SymbolTable::Read(in, source)); if (isymbols == nullptr) { LOG(ERROR) << "FstReadSymbols: Couldn't read input symbols from " << source; return nullptr; } if (input_symbols) return isymbols.release(); } if (hdr.GetFlags() & FstHeader::HAS_OSYMBOLS) { std::unique_ptr osymbols(SymbolTable::Read(in, source)); if (osymbols == nullptr) { LOG(ERROR) << "FstReadSymbols: Couldn't read output symbols from " << source; return nullptr; } if (!input_symbols) return osymbols.release(); } LOG(ERROR) << "FstReadSymbols: The file " << source << " doesn't contain the requested symbols"; return nullptr; } bool AddAuxiliarySymbols(const std::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 openfst-1.7.9/src/lib/symbol-table.cc000066400000000000000000000326401421600557100174520ustar00rootroot00000000000000// 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 #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 { SymbolTableTextOptions::SymbolTableTextOptions(bool allow_negative_labels) : allow_negative_labels(allow_negative_labels), fst_field_separator(FLAGS_fst_field_separator) {} namespace internal { // Maximum line length in textual symbols file. const int kLineLen = 8096; // Identifies stream data as a symbol table (and its endianity). static constexpr int32 kSymbolTableMagicNumber = 2125658996; constexpr int64 DenseSymbolMap::kEmptyBucket; DenseSymbolMap::DenseSymbolMap() : str_hash_(), buckets_(1 << 4, kEmptyBucket), hash_mask_(buckets_.size() - 1) {} std::pair DenseSymbolMap::InsertOrFind(KeyType key) { static constexpr float kMaxOccupancyRatio = 0.75; // Grows when 75% full. if (Size() >= kMaxOccupancyRatio * buckets_.size()) { Rehash(buckets_.size() * 2); } size_t idx = GetHash(key); while (buckets_[idx] != kEmptyBucket) { const auto stored_value = buckets_[idx]; if (symbols_[stored_value] == key) return {stored_value, false}; idx = (idx + 1) & hash_mask_; } const auto next = Size(); buckets_[idx] = next; symbols_.emplace_back(key); return {next, true}; } int64 DenseSymbolMap::Find(KeyType key) const { size_t idx = str_hash_(key) & hash_mask_; while (buckets_[idx] != kEmptyBucket) { const auto stored_value = buckets_[idx]; if (symbols_[stored_value] == key) 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::fill(buckets_.begin(), buckets_.end(), kEmptyBucket); for (size_t i = 0; i < Size(); ++i) { size_t idx = GetHash(symbols_[i]); while (buckets_[idx] != kEmptyBucket) { idx = (idx + 1) & hash_mask_; } buckets_[idx] = i; } } void DenseSymbolMap::RemoveSymbol(size_t idx) { symbols_.erase(symbols_.begin() + idx); Rehash(buckets_.size()); } void DenseSymbolMap::ShrinkToFit() { symbols_.shrink_to_fit(); } void MutableSymbolTableImpl::AddTable(const SymbolTable &table) { for (const auto &item : table) { AddSymbol(item.Symbol()); } } std::unique_ptr ConstSymbolTableImpl::Copy() const { LOG(FATAL) << "ConstSymbolTableImpl can't be copied"; return nullptr; } int64 ConstSymbolTableImpl::AddSymbol(SymbolType symbol, int64 key) { LOG(FATAL) << "ConstSymbolTableImpl does not support AddSymbol"; return kNoSymbol; } int64 ConstSymbolTableImpl::AddSymbol(SymbolType symbol) { return AddSymbol(symbol, kNoSymbol); } void ConstSymbolTableImpl::RemoveSymbol(int64 key) { LOG(FATAL) << "ConstSymbolTableImpl does not support RemoveSymbol"; } void ConstSymbolTableImpl::SetName(const std::string &new_name) { LOG(FATAL) << "ConstSymbolTableImpl does not support SetName"; } void ConstSymbolTableImpl::AddTable(const SymbolTable &table) { LOG(FATAL) << "ConstSymbolTableImpl does not support AddTable"; } SymbolTableImpl *SymbolTableImpl::ReadText(std::istream &strm, const std::string &source, const SymbolTableTextOptions &opts) { std::unique_ptr impl(new SymbolTableImpl(source)); int64 nline = 0; char line[kLineLen]; const auto separator = opts.fst_field_separator + "\n"; while (!strm.getline(line, kLineLen).fail()) { ++nline; std::vector col; 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 = " << source << ", 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 != '\0' || (!opts.allow_negative_labels && key < 0) || key == kNoSymbol) { LOG(ERROR) << "SymbolTable::ReadText: Bad non-negative integer \"" << value << "\", " << "file = " << source << ", line = " << nline; return nullptr; } impl->AddSymbol(symbol, key); } impl->ShrinkToFit(); 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 = std::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; } std::string SymbolTableImpl::Find(int64 key) const { int64 idx = key; if (key < 0 || key >= dense_key_limit_) { const auto it = key_map_.find(key); if (it == key_map_.end()) return ""; idx = it->second; } if (idx < 0 || idx >= symbols_.Size()) return ""; return symbols_.GetSymbol(idx); } int64 SymbolTableImpl::AddSymbol(SymbolType symbol, int64 key) { if (key == kNoSymbol) return key; const auto insert_key = symbols_.InsertOrFind(symbol); if (!insert_key.second) { const 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 + 1 == static_cast(symbols_.Size()) && 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 >= static_cast(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 (size_t i = idx - dense_key_limit_; i + 1 < idx_key_.size(); ++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 &) { int32 magic_number = 0; ReadType(strm, &magic_number); if (strm.fail()) { LOG(ERROR) << "SymbolTable::Read: Read failed"; return nullptr; } std::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; } std::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); } impl->ShrinkToFit(); return impl.release(); } bool SymbolTableImpl::Write(std::ostream &strm) const { WriteType(strm, kSymbolTableMagicNumber); WriteType(strm, name_); WriteType(strm, available_key_); const int64 size = symbols_.Size(); WriteType(strm, size); for (int64 i = 0; i < dense_key_limit_; ++i) { WriteType(strm, symbols_.GetSymbol(i)); WriteType(strm, i); } for (const auto &p : key_map_) { WriteType(strm, symbols_.GetSymbol(p.second)); WriteType(strm, p.first); } strm.flush(); if (strm.fail()) { LOG(ERROR) << "SymbolTable::Write: Write failed"; return false; } return true; } void SymbolTableImpl::ShrinkToFit() { symbols_.ShrinkToFit(); } } // namespace internal SymbolTable *SymbolTable::ReadText(const std::string &source, const SymbolTableTextOptions &opts) { std::ifstream strm(source, std::ios_base::in); if (!strm.good()) { LOG(ERROR) << "SymbolTable::ReadText: Can't open file: " << source; return nullptr; } return ReadText(strm, source, opts); } bool SymbolTable::Write(const std::string &source) const { if (!source.empty()) { std::ofstream strm(source, std::ios_base::out | std::ios_base::binary); if (!strm) { LOG(ERROR) << "SymbolTable::Write: Can't open file: " << source; return false; } if (!Write(strm)) { LOG(ERROR) << "SymbolTable::Write: Write failed: " << source; return false; } return true; } else { return Write(std::cout); } } 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 (const auto &item : *this) { std::ostringstream line; if (item.Label() < 0 && !opts.allow_negative_labels && !once_only) { LOG(WARNING) << "Negative symbol table entry when not allowed"; once_only = true; } line << item.Symbol() << opts.fst_field_separator[0] << item.Label() << '\n'; strm.write(line.str().data(), line.str().length()); } return true; } bool SymbolTable::WriteText(const std::string &source) const { if (!source.empty()) { std::ofstream strm(source); if (!strm) { LOG(ERROR) << "SymbolTable::WriteText: Can't open file: " << source; return false; } if (!WriteText(strm, SymbolTableTextOptions())) { LOG(ERROR) << "SymbolTable::WriteText: Write failed: " << source; return false; } return true; } else { return WriteText(std::cout, SymbolTableTextOptions()); } } 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, std::string *result) { std::ostringstream ostrm; table->Write(ostrm); *result = ostrm.str(); } SymbolTable *StringToSymbolTable(const std::string &str) { std::istringstream istrm(str); return SymbolTable::Read(istrm, SymbolTableReadOptions()); } } // namespace fst openfst-1.7.9/src/lib/util.cc000066400000000000000000000053421421600557100160340ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // FST utility definitions. #include #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 std::string &s, const std::string &source, 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 = " << source << ", line = " << nline; if (error) *error = true; return 0; } return n; } void ConvertToLegalCSymbol(std::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; } int AlignBufferWithOutputStream(std::ostream &strm, std::ostringstream &buffer) { const auto strm_pos = strm.tellp(); if (strm_pos == -1) { LOG(ERROR) << "Cannot determine stream position"; return -1; } const int stream_offset = strm_pos % MappedFile::kArchAlignment; for (int i = 0; i < stream_offset; ++i) buffer.write("", 1); return stream_offset; } } // namespace fst openfst-1.7.9/src/lib/weight.cc000066400000000000000000000075311421600557100163500ustar00rootroot00000000000000#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 openfst-1.7.9/src/script/000077500000000000000000000000001421600557100153025ustar00rootroot00000000000000openfst-1.7.9/src/script/Makefile.am000066400000000000000000000015771421600557100173500ustar00rootroot00000000000000AM_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 22:0:0 endif openfst-1.7.9/src/script/Makefile.in000066400000000000000000001000331421600557100173440ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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__maybe_remake_depfiles = depfiles am__depfiles_remade = ./$(DEPDIR)/arciterator-class.Plo \ ./$(DEPDIR)/arcsort.Plo ./$(DEPDIR)/closure.Plo \ ./$(DEPDIR)/compile.Plo ./$(DEPDIR)/compose.Plo \ ./$(DEPDIR)/concat.Plo ./$(DEPDIR)/connect.Plo \ ./$(DEPDIR)/convert.Plo ./$(DEPDIR)/decode.Plo \ ./$(DEPDIR)/determinize.Plo ./$(DEPDIR)/difference.Plo \ ./$(DEPDIR)/disambiguate.Plo ./$(DEPDIR)/draw.Plo \ ./$(DEPDIR)/encode.Plo ./$(DEPDIR)/encodemapper-class.Plo \ ./$(DEPDIR)/epsnormalize.Plo ./$(DEPDIR)/equal.Plo \ ./$(DEPDIR)/equivalent.Plo ./$(DEPDIR)/fst-class.Plo \ ./$(DEPDIR)/getters.Plo ./$(DEPDIR)/info-impl.Plo \ ./$(DEPDIR)/info.Plo ./$(DEPDIR)/intersect.Plo \ ./$(DEPDIR)/invert.Plo ./$(DEPDIR)/isomorphic.Plo \ ./$(DEPDIR)/map.Plo ./$(DEPDIR)/minimize.Plo \ ./$(DEPDIR)/print.Plo ./$(DEPDIR)/project.Plo \ ./$(DEPDIR)/prune.Plo ./$(DEPDIR)/push.Plo \ ./$(DEPDIR)/randequivalent.Plo ./$(DEPDIR)/randgen.Plo \ ./$(DEPDIR)/relabel.Plo ./$(DEPDIR)/replace.Plo \ ./$(DEPDIR)/reverse.Plo ./$(DEPDIR)/reweight.Plo \ ./$(DEPDIR)/rmepsilon.Plo ./$(DEPDIR)/shortest-distance.Plo \ ./$(DEPDIR)/shortest-path.Plo \ ./$(DEPDIR)/stateiterator-class.Plo \ ./$(DEPDIR)/synchronize.Plo ./$(DEPDIR)/text-io.Plo \ ./$(DEPDIR)/topsort.Plo ./$(DEPDIR)/union.Plo \ ./$(DEPDIR)/verify.Plo ./$(DEPDIR)/weight-class.Plo 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 am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 22: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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arcsort.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/closure.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compile.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compose.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/concat.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/connect.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/convert.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decode.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/determinize.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/difference.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/disambiguate.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/draw.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encode.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encodemapper-class.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/epsnormalize.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/equal.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/equivalent.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst-class.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/info-impl.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/info.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/intersect.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/invert.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isomorphic.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/map.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/minimize.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/project.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prune.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/push.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/randequivalent.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/randgen.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/relabel.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/replace.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reverse.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reweight.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rmepsilon.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shortest-distance.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shortest-path.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stateiterator-class.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/synchronize.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/text-io.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/topsort.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/union.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/verify.Plo@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight-class.Plo@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/arciterator-class.Plo -rm -f ./$(DEPDIR)/arcsort.Plo -rm -f ./$(DEPDIR)/closure.Plo -rm -f ./$(DEPDIR)/compile.Plo -rm -f ./$(DEPDIR)/compose.Plo -rm -f ./$(DEPDIR)/concat.Plo -rm -f ./$(DEPDIR)/connect.Plo -rm -f ./$(DEPDIR)/convert.Plo -rm -f ./$(DEPDIR)/decode.Plo -rm -f ./$(DEPDIR)/determinize.Plo -rm -f ./$(DEPDIR)/difference.Plo -rm -f ./$(DEPDIR)/disambiguate.Plo -rm -f ./$(DEPDIR)/draw.Plo -rm -f ./$(DEPDIR)/encode.Plo -rm -f ./$(DEPDIR)/encodemapper-class.Plo -rm -f ./$(DEPDIR)/epsnormalize.Plo -rm -f ./$(DEPDIR)/equal.Plo -rm -f ./$(DEPDIR)/equivalent.Plo -rm -f ./$(DEPDIR)/fst-class.Plo -rm -f ./$(DEPDIR)/getters.Plo -rm -f ./$(DEPDIR)/info-impl.Plo -rm -f ./$(DEPDIR)/info.Plo -rm -f ./$(DEPDIR)/intersect.Plo -rm -f ./$(DEPDIR)/invert.Plo -rm -f ./$(DEPDIR)/isomorphic.Plo -rm -f ./$(DEPDIR)/map.Plo -rm -f ./$(DEPDIR)/minimize.Plo -rm -f ./$(DEPDIR)/print.Plo -rm -f ./$(DEPDIR)/project.Plo -rm -f ./$(DEPDIR)/prune.Plo -rm -f ./$(DEPDIR)/push.Plo -rm -f ./$(DEPDIR)/randequivalent.Plo -rm -f ./$(DEPDIR)/randgen.Plo -rm -f ./$(DEPDIR)/relabel.Plo -rm -f ./$(DEPDIR)/replace.Plo -rm -f ./$(DEPDIR)/reverse.Plo -rm -f ./$(DEPDIR)/reweight.Plo -rm -f ./$(DEPDIR)/rmepsilon.Plo -rm -f ./$(DEPDIR)/shortest-distance.Plo -rm -f ./$(DEPDIR)/shortest-path.Plo -rm -f ./$(DEPDIR)/stateiterator-class.Plo -rm -f ./$(DEPDIR)/synchronize.Plo -rm -f ./$(DEPDIR)/text-io.Plo -rm -f ./$(DEPDIR)/topsort.Plo -rm -f ./$(DEPDIR)/union.Plo -rm -f ./$(DEPDIR)/verify.Plo -rm -f ./$(DEPDIR)/weight-class.Plo -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 -f ./$(DEPDIR)/arciterator-class.Plo -rm -f ./$(DEPDIR)/arcsort.Plo -rm -f ./$(DEPDIR)/closure.Plo -rm -f ./$(DEPDIR)/compile.Plo -rm -f ./$(DEPDIR)/compose.Plo -rm -f ./$(DEPDIR)/concat.Plo -rm -f ./$(DEPDIR)/connect.Plo -rm -f ./$(DEPDIR)/convert.Plo -rm -f ./$(DEPDIR)/decode.Plo -rm -f ./$(DEPDIR)/determinize.Plo -rm -f ./$(DEPDIR)/difference.Plo -rm -f ./$(DEPDIR)/disambiguate.Plo -rm -f ./$(DEPDIR)/draw.Plo -rm -f ./$(DEPDIR)/encode.Plo -rm -f ./$(DEPDIR)/encodemapper-class.Plo -rm -f ./$(DEPDIR)/epsnormalize.Plo -rm -f ./$(DEPDIR)/equal.Plo -rm -f ./$(DEPDIR)/equivalent.Plo -rm -f ./$(DEPDIR)/fst-class.Plo -rm -f ./$(DEPDIR)/getters.Plo -rm -f ./$(DEPDIR)/info-impl.Plo -rm -f ./$(DEPDIR)/info.Plo -rm -f ./$(DEPDIR)/intersect.Plo -rm -f ./$(DEPDIR)/invert.Plo -rm -f ./$(DEPDIR)/isomorphic.Plo -rm -f ./$(DEPDIR)/map.Plo -rm -f ./$(DEPDIR)/minimize.Plo -rm -f ./$(DEPDIR)/print.Plo -rm -f ./$(DEPDIR)/project.Plo -rm -f ./$(DEPDIR)/prune.Plo -rm -f ./$(DEPDIR)/push.Plo -rm -f ./$(DEPDIR)/randequivalent.Plo -rm -f ./$(DEPDIR)/randgen.Plo -rm -f ./$(DEPDIR)/relabel.Plo -rm -f ./$(DEPDIR)/replace.Plo -rm -f ./$(DEPDIR)/reverse.Plo -rm -f ./$(DEPDIR)/reweight.Plo -rm -f ./$(DEPDIR)/rmepsilon.Plo -rm -f ./$(DEPDIR)/shortest-distance.Plo -rm -f ./$(DEPDIR)/shortest-path.Plo -rm -f ./$(DEPDIR)/stateiterator-class.Plo -rm -f ./$(DEPDIR)/synchronize.Plo -rm -f ./$(DEPDIR)/text-io.Plo -rm -f ./$(DEPDIR)/topsort.Plo -rm -f ./$(DEPDIR)/union.Plo -rm -f ./$(DEPDIR)/verify.Plo -rm -f ./$(DEPDIR)/weight-class.Plo -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/script/arciterator-class.cc000066400000000000000000000017661421600557100212450ustar00rootroot00000000000000// 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_3ARCS(InitArcIteratorClass, InitArcIteratorClassArgs); REGISTER_FST_OPERATION_3ARCS(InitMutableArcIteratorClass, InitMutableArcIteratorClassArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/arcsort.cc000066400000000000000000000007311421600557100172670ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(ArcSort, ArcSortArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/closure.cc000066400000000000000000000007371421600557100172740ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Closure, ClosureArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/compile.cc000066400000000000000000000032771421600557100172520ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void CompileFst(std::istream &istrm, const std::string &source, const std::string &dest, const std::string &fst_type, const std::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 std::string &source, const std::string &fst_type, const std::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 form 2; 1 does not require registration. REGISTER_FST_OPERATION_3ARCS(CompileFstInternal, CompileFstArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/compose.cc000066400000000000000000000013241421600557100172560ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Compose, ComposeArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/concat.cc000066400000000000000000000023361421600557100170640ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Concat(MutableFstClass *fst1, const FstClass &fst2) { if (!internal::ArcTypesMatch(*fst1, fst2, "Concat")) { fst1->SetProperties(kError, kError); return; } ConcatArgs1 args(fst1, fst2); Apply>("Concat", fst1->ArcType(), &args); } void Concat(const FstClass &fst1, MutableFstClass *fst2) { if (!internal::ArcTypesMatch(fst1, *fst2, "Concat")) { fst2->SetProperties(kError, kError); return; } ConcatArgs2 args(fst1, fst2); Apply>("Concat", fst2->ArcType(), &args); } void Concat(const std::vector &fsts1, MutableFstClass *fst2) { for (const auto *fst1 : fsts1) { if (!internal::ArcTypesMatch(*fst1, *fst2, "Concat")) { fst2->SetProperties(kError, kError); return; } } ConcatArgs3 args(fsts1, fst2); Apply>("Concat", fst2->ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(Concat, ConcatArgs1); REGISTER_FST_OPERATION_3ARCS(Concat, ConcatArgs2); } // namespace script } // namespace fst openfst-1.7.9/src/script/connect.cc000066400000000000000000000006441421600557100172460ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Connect(MutableFstClass *fst) { Apply>("Connect", fst->ArcType(), fst); } REGISTER_FST_OPERATION_3ARCS(Connect, MutableFstClass); } // namespace script } // namespace fst openfst-1.7.9/src/script/convert.cc000066400000000000000000000010331421600557100172660ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { FstClass *Convert(const FstClass &ifst, const std::string &new_type) { ConvertInnerArgs iargs(ifst, new_type); ConvertArgs args(iargs); Apply>("Convert", ifst.ArcType(), &args); return args.retval; } REGISTER_FST_OPERATION_3ARCS(Convert, ConvertArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/decode.cc000066400000000000000000000011131421600557100170300ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Decode(MutableFstClass *fst, const EncodeMapperClass &mapper) { if (!internal::ArcTypesMatch(*fst, mapper, "Decode")) { fst->SetProperties(kError, kError); return; } DecodeArgs args(fst, mapper); Apply>("Decode", fst->ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(Decode, DecodeArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/determinize.cc000066400000000000000000000013461421600557100201340ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Determinize, DeterminizeArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/difference.cc000066400000000000000000000013621421600557100177050ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Difference, DifferenceArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/disambiguate.cc000066400000000000000000000013611421600557100202500ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Disambiguate, DisambiguateArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/draw.cc000066400000000000000000000017301421600557100165470ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Draw(const FstClass &fst, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accep, const std::string &title, float width, float height, bool portrait, bool vertical, float ranksep, float nodesep, int fontsize, int precision, const std::string &float_format, bool show_weight_one, std::ostream &ostrm, const std::string &dest) { DrawArgs args(fst, isyms, osyms, ssyms, accep, title, width, height, portrait, vertical, ranksep, nodesep, fontsize, precision, float_format, show_weight_one, ostrm, dest); Apply>("Draw", fst.ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(Draw, DrawArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/encode.cc000066400000000000000000000011061421600557100170440ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Encode(MutableFstClass *fst, EncodeMapperClass *mapper) { if (!internal::ArcTypesMatch(*fst, *mapper, "Encode")) { fst->SetProperties(kError, kError); return; } EncodeArgs args(fst, mapper); Apply>("Encode", fst->ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(Encode, EncodeArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/encodemapper-class.cc000066400000000000000000000046371421600557100213700ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { namespace { // Helper methods. EncodeMapperClass *ReadEncodeMapper(std::istream &istrm, const std::string &source) { if (!istrm) { LOG(ERROR) << "ReadEncodeMapperClass: Can't open file: " << source; return nullptr; } EncodeTableHeader hdr; if (!hdr.Read(istrm, source)) return nullptr; const auto &arc_type = hdr.ArcType(); // TODO(b/141172858): deprecated, remove by 2020-01-01. if (arc_type.empty()) { LOG(ERROR) << "Old-style EncodeMapper cannot be used with script interface"; return nullptr; } // The actual reader also consumes the header, so to be kind we rewind. istrm.seekg(0, istrm.beg); static const auto *reg = EncodeMapperClassIORegistration::Register::GetRegister(); const auto reader = reg->GetReader(arc_type); if (!reader) { LOG(ERROR) << "EncodeMapperClass::Read: Unknown arc type: " << arc_type; return nullptr; } return reader(istrm, source); } EncodeMapperImplBase *CreateEncodeMapper(const std::string &arc_type, uint8 flags, EncodeType type) { static const auto *reg = EncodeMapperClassIORegistration::Register::GetRegister(); auto creator = reg->GetCreator(arc_type); if (!creator) { FSTERROR() << "EncodeMapperClass: Unknown arc type: " << arc_type; return nullptr; } return creator(flags, type); } } // namespace EncodeMapperClass::EncodeMapperClass(const std::string &arc_type, uint8 flags, EncodeType type) : impl_(CreateEncodeMapper(arc_type, flags, type)) {} EncodeMapperClass *EncodeMapperClass::Read(const std::string &source) { if (!source.empty()) { std::ifstream strm(source, std::ios_base::in | std::ios_base::binary); return ReadEncodeMapper(strm, source); } else { return ReadEncodeMapper(std::cin, "standard input"); } } EncodeMapperClass *EncodeMapperClass::Read(std::istream &strm, const std::string &source) { return ReadEncodeMapper(strm, source); } // Registration. REGISTER_ENCODEMAPPER_CLASS(StdArc); REGISTER_ENCODEMAPPER_CLASS(LogArc); REGISTER_ENCODEMAPPER_CLASS(Log64Arc); } // namespace script } // namespace fst openfst-1.7.9/src/script/epsnormalize.cc000066400000000000000000000012511421600557100203200ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(EpsNormalize, EpsNormalizeArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/equal.cc000066400000000000000000000011221421600557100167140ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Equal, EqualArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/equivalent.cc000066400000000000000000000011771421600557100177740ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Equivalent, EquivalentArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/fst-class.cc000066400000000000000000000100671421600557100175140ustar00rootroot00000000000000// 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 namespace fst { namespace script { namespace { // Helper functions. template F *ReadFstClass(std::istream &istrm, const std::string &source) { if (!istrm) { LOG(ERROR) << "ReadFstClass: Can't open file: " << source; return nullptr; } FstHeader hdr; if (!hdr.Read(istrm, source)) return nullptr; const FstReadOptions read_options(source, &hdr); const auto &arc_type = hdr.ArcType(); static const auto *reg = FstClassIORegistration::Register::GetRegister(); const auto reader = reg->GetReader(arc_type); if (!reader) { LOG(ERROR) << "ReadFstClass: Unknown arc type: " << arc_type; return nullptr; } return reader(istrm, read_options); } template FstClassImplBase *CreateFstClass(const std::string &arc_type) { static const auto *reg = FstClassIORegistration::Register::GetRegister(); auto creator = reg->GetCreator(arc_type); if (!creator) { FSTERROR() << "CreateFstClass: Unknown arc type: " << arc_type; return nullptr; } return creator(); } template FstClassImplBase *ConvertFstClass(const FstClass &other) { static const auto *reg = FstClassIORegistration::Register::GetRegister(); auto converter = reg->GetConverter(other.ArcType()); if (!converter) { FSTERROR() << "ConvertFstClass: Unknown arc type: " << other.ArcType(); return nullptr; } return converter(other); } } // namespace // FstClass methods. FstClass *FstClass::Read(const std::string &source) { if (!source.empty()) { std::ifstream istrm(source, std::ios_base::in | std::ios_base::binary); return ReadFstClass(istrm, source); } else { return ReadFstClass(std::cin, "standard input"); } } FstClass *FstClass::Read(std::istream &istrm, const std::string &source) { return ReadFstClass(istrm, source); } bool FstClass::WeightTypesMatch(const WeightClass &weight, const std::string &op_name) const { if (WeightType() != weight.Type()) { FSTERROR() << op_name << ": FST and weight with non-matching weight types: " << WeightType() << " and " << weight.Type(); return false; } return true; } // MutableFstClass methods. MutableFstClass *MutableFstClass::Read(const std::string &source, bool convert) { if (convert == false) { if (!source.empty()) { std::ifstream in(source, std::ios_base::in | std::ios_base::binary); return ReadFstClass(in, source); } else { return ReadFstClass(std::cin, "standard input"); } } else { // Converts to VectorFstClass if not mutable. std::unique_ptr ifst(FstClass::Read(source)); 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 std::string &source) { if (!source.empty()) { std::ifstream in(source, std::ios_base::in | std::ios_base::binary); return ReadFstClass(in, source); } else { return ReadFstClass(std::cin, "standard input"); } } VectorFstClass::VectorFstClass(const std::string &arc_type) : MutableFstClass(CreateFstClass(arc_type)) {} VectorFstClass::VectorFstClass(const FstClass &other) : MutableFstClass(ConvertFstClass(other)) {} // Registration. REGISTER_FST_CLASSES(StdArc); REGISTER_FST_CLASSES(LogArc); REGISTER_FST_CLASSES(Log64Arc); } // namespace script } // namespace fst openfst-1.7.9/src/script/getters.cc000066400000000000000000000104661421600557100172750ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include namespace fst { namespace script { bool GetArcSortType(const std::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 std::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 == "no_match") { *compose_filter = NO_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 std::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 std::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 GetProjectType(const std::string &str, ProjectType *project_type) { if (str == "input") { *project_type = ProjectType::INPUT; } else if (str == "output") { *project_type = ProjectType::OUTPUT; } else { return false; } return true; } bool GetRandArcSelection(const std::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 std::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 std::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; } bool GetTokenType(const std::string &str, TokenType *token_type) { if (str == "byte") { *token_type = TokenType::BYTE; } else if (str == "utf8") { *token_type = TokenType::UTF8; } else if (str == "symbol") { *token_type = TokenType::SYMBOL; } else { return false; } return true; } } // namespace script } // namespace fst openfst-1.7.9/src/script/info-impl.cc000066400000000000000000000067701421600557100175150ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include namespace fst { void FstInfo::Info() const { std::ostream &ostrm = std::cout; const auto old = ostrm.setf(std::ios::left); ostrm.width(50); ostrm << "fst type" << FstType() << std::endl; ostrm.width(50); ostrm << "arc type" << ArcType() << std::endl; ostrm.width(50); ostrm << "input symbol table" << InputSymbols() << std::endl; ostrm.width(50); ostrm << "output symbol table" << OutputSymbols() << std::endl; if (!LongInfo()) { ostrm.setf(old); return; } ostrm.width(50); ostrm << "# of states" << NumStates() << std::endl; ostrm.width(50); ostrm << "# of arcs" << NumArcs() << std::endl; ostrm.width(50); ostrm << "initial state" << Start() << std::endl; ostrm.width(50); ostrm << "# of final states" << NumFinal() << std::endl; ostrm.width(50); ostrm << "# of input/output epsilons" << NumEpsilons() << std::endl; ostrm.width(50); ostrm << "# of input epsilons" << NumInputEpsilons() << std::endl; ostrm.width(50); ostrm << "# of output epsilons" << NumOutputEpsilons() << std::endl; ostrm.width(50); ostrm << "input label multiplicity" << InputLabelMultiplicity() << std::endl; ostrm.width(50); ostrm << "output label multiplicity" << OutputLabelMultiplicity() << std::endl; ostrm.width(50); std::string arc_type = ""; if (ArcFilterType() == "epsilon") arc_type = "epsilon "; else if (ArcFilterType() == "iepsilon") arc_type = "input-epsilon "; else if (ArcFilterType() == "oepsilon") arc_type = "output-epsilon "; const auto accessible_label = "# of " + arc_type + "accessible states"; ostrm.width(50); ostrm << accessible_label << NumAccessible() << std::endl; const auto coaccessible_label = "# of " + arc_type + "coaccessible states"; ostrm.width(50); ostrm << coaccessible_label << NumCoAccessible() << std::endl; const auto connected_label = "# of " + arc_type + "connected states"; ostrm.width(50); ostrm << connected_label << NumConnected() << std::endl; const auto numcc_label = "# of " + arc_type + "connected components"; ostrm.width(50); ostrm << numcc_label << NumCc() << std::endl; const auto numscc_label = "# of " + arc_type + "strongly conn components"; ostrm.width(50); ostrm << numscc_label << NumScc() << std::endl; ostrm.width(50); ostrm << "input matcher" << (InputMatchType() == MATCH_INPUT ? 'y' : InputMatchType() == MATCH_NONE ? 'n' : '?') << std::endl; ostrm.width(50); ostrm << "output matcher" << (OutputMatchType() == MATCH_OUTPUT ? 'y' : OutputMatchType() == MATCH_NONE ? 'n' : '?') << std::endl; ostrm.width(50); ostrm << "input lookahead" << (InputLookAhead() ? 'y' : 'n') << std::endl; ostrm.width(50); ostrm << "output lookahead" << (OutputLookAhead() ? 'y' : 'n') << std::endl; uint64 prop = 1; for (auto i = 0; i < 64; ++i, prop <<= 1) { if (prop & kBinaryProperties) { char value = 'n'; if (Properties() & prop) value = 'y'; ostrm.width(50); ostrm << PropertyNames[i] << value << std::endl; } else if (prop & kPosTrinaryProperties) { char value = '?'; if (Properties() & prop) { value = 'y'; } else if (Properties() & prop << 1) { value = 'n'; } ostrm.width(50); ostrm << PropertyNames[i] << value << std::endl; } } ostrm.setf(old); } } // namespace fst openfst-1.7.9/src/script/info.cc000066400000000000000000000011041421600557100165400ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Info(const FstClass &fst, bool test_properties, const std::string &arc_filter, const std::string &info_type, bool verify) { InfoArgs args(fst, test_properties, arc_filter, info_type, verify); Apply>("Info", fst.ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(Info, InfoArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/intersect.cc000066400000000000000000000013501421600557100176100ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Intersect, IntersectArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/invert.cc000066400000000000000000000006401421600557100171200ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Invert(MutableFstClass *fst) { Apply>("Invert", fst->ArcType(), fst); } REGISTER_FST_OPERATION_3ARCS(Invert, MutableFstClass); } // namespace script } // namespace fst openfst-1.7.9/src/script/isomorphic.cc000066400000000000000000000011771421600557100177730ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Isomorphic, IsomorphicArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/map.cc000066400000000000000000000012071421600557100163660ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Map, MapArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/minimize.cc000066400000000000000000000013211421600557100174270ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Minimize, MinimizeArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/print.cc000066400000000000000000000022641421600557100167510ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Print(const FstClass &fst, std::ostream &ostrm, const std::string &dest, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accept, bool show_weight_one, const std::string &missing_sym) { const auto sep = FLAGS_fst_field_separator.substr(0, 1); PrintArgs args(fst, isyms, osyms, ssyms, accept, show_weight_one, ostrm, dest, sep, missing_sym); Apply>("Print", fst.ArcType(), &args); } // TODO(kbg,2019-09-01): Deprecated. void PrintFst(const FstClass &fst, std::ostream &ostrm, const std::string &dest, const SymbolTable *isyms, const SymbolTable *osyms, const SymbolTable *ssyms, bool accept, bool show_weight_one, const std::string &missing_sym) { Print(fst, ostrm, dest, isyms, osyms, ssyms, accept, show_weight_one, missing_sym); } REGISTER_FST_OPERATION_3ARCS(Print, PrintArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/project.cc000066400000000000000000000007421421600557100172620ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Project, ProjectArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/prune.cc000066400000000000000000000022401421600557100167400ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Prune, PruneArgs1); REGISTER_FST_OPERATION_3ARCS(Prune, PruneArgs2); } // namespace script } // namespace fst openfst-1.7.9/src/script/push.cc000066400000000000000000000016351421600557100165750ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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, uint8 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_3ARCS(Push, PushArgs1); REGISTER_FST_OPERATION_3ARCS(Push, PushArgs2); } // namespace script } // namespace fst openfst-1.7.9/src/script/randequivalent.cc000066400000000000000000000014461421600557100206400ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath, const RandGenOptions &opts, float delta, uint64 seed) { if (!internal::ArcTypesMatch(fst1, fst2, "RandEquivalent")) return false; RandEquivalentInnerArgs iargs(fst1, fst2, npath, opts, delta, seed); RandEquivalentArgs args(iargs); Apply>("RandEquivalent", fst1.ArcType(), &args); return args.retval; } REGISTER_FST_OPERATION_3ARCS(RandEquivalent, RandEquivalentArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/randgen.cc000066400000000000000000000012341421600557100172270ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void RandGen(const FstClass &ifst, MutableFstClass *ofst, const RandGenOptions &opts, uint64 seed) { if (!internal::ArcTypesMatch(ifst, *ofst, "RandGen")) { ofst->SetProperties(kError, kError); return; } RandGenArgs args(ifst, ofst, opts, seed); Apply>("RandGen", ifst.ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(RandGen, RandGenArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/relabel.cc000066400000000000000000000023311421600557100172160ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Relabel(MutableFstClass *ofst, const SymbolTable *old_isyms, const SymbolTable *relabel_isyms, const std::string &unknown_isymbol, bool attach_new_isyms, const SymbolTable *old_osyms, const SymbolTable *relabel_osyms, const std::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_3ARCS(Relabel, RelabelArgs1); REGISTER_FST_OPERATION_3ARCS(Relabel, RelabelArgs2); } // namespace script } // namespace fst openfst-1.7.9/src/script/replace.cc000066400000000000000000000013301421600557100172210ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Replace(const std::vector> &pairs, MutableFstClass *ofst, const ReplaceOptions &opts) { for (const auto &pair : pairs) { if (!internal::ArcTypesMatch(*pair.second, *ofst, "Replace")) { ofst->SetProperties(kError, kError); return; } } ReplaceArgs args(pairs, ofst, opts); Apply>("Replace", ofst->ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(Replace, ReplaceArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/reverse.cc000066400000000000000000000012061421600557100172630ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Reverse, ReverseArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/reweight.cc000066400000000000000000000010551421600557100174300ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Reweight, ReweightArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/rmepsilon.cc000066400000000000000000000011451421600557100176220ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(RmEpsilon, RmEpsilonArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/shortest-distance.cc000066400000000000000000000026201421600557100212540ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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 &fst, std::vector *distance, bool reverse, double delta) { ShortestDistanceArgs2 args(fst, distance, reverse, delta); Apply>("ShortestDistance", fst.ArcType(), &args); } WeightClass ShortestDistance(const FstClass &fst, double delta) { ShortestDistanceInnerArgs3 iargs(fst, delta); ShortestDistanceArgs3 args(iargs); Apply>("ShortestDistance", fst.ArcType(), &args); return args.retval; } REGISTER_FST_OPERATION_3ARCS(ShortestDistance, ShortestDistanceArgs1); REGISTER_FST_OPERATION_3ARCS(ShortestDistance, ShortestDistanceArgs2); REGISTER_FST_OPERATION_3ARCS(ShortestDistance, ShortestDistanceArgs3); } // namespace script } // namespace fst openfst-1.7.9/src/script/shortest-path.cc000066400000000000000000000012521421600557100204160ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(ShortestPath, ShortestPathArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/stateiterator-class.cc000066400000000000000000000012111421600557100216010ustar00rootroot00000000000000// 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_3ARCS(InitStateIteratorClass, InitStateIteratorClassArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/synchronize.cc000066400000000000000000000011501421600557100201610ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Synchronize, SynchronizeArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/text-io.cc000066400000000000000000000042071421600557100172050ustar00rootroot00000000000000// 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 std::string &weight_type, const std::string &source, std::vector *potentials) { std::ifstream istrm(source); if (!istrm) { LOG(ERROR) << "ReadPotentials: Can't open file: " << source; 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 = " << source << ", line = " << nline; return false; } const ssize_t s = StrToInt64(col[0], source, 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 std::string &source, const std::vector &potentials) { std::ofstream ostrm; if (!source.empty()) { ostrm.open(source); if (!ostrm) { LOG(ERROR) << "WritePotentials: Can't open file: " << source; 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: " << (source.empty() ? "standard output" : source); return false; } return true; } } // namespace script } // namespace fst openfst-1.7.9/src/script/topsort.cc000066400000000000000000000007151421600557100173260ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { bool TopSort(MutableFstClass *fst) { TopSortArgs args(fst); Apply>("TopSort", fst->ArcType(), &args); return args.retval; } REGISTER_FST_OPERATION_3ARCS(TopSort, TopSortArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/union.cc000066400000000000000000000017021421600557100167410ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #include #include namespace fst { namespace script { void Union(MutableFstClass *fst1, const FstClass &fst2) { if (!internal::ArcTypesMatch(*fst1, fst2, "Union")) { fst1->SetProperties(kError, kError); return; } UnionArgs1 args(fst1, fst2); Apply>("Union", fst1->ArcType(), &args); } void Union(MutableFstClass *fst1, const std::vector &fsts2) { for (const auto *fst2 : fsts2) { if (!internal::ArcTypesMatch(*fst1, *fst2, "Union")) { fst1->SetProperties(kError, kError); return; } } UnionArgs2 args(fst1, fsts2); Apply>("Union", fst1->ArcType(), &args); } REGISTER_FST_OPERATION_3ARCS(Union, UnionArgs1); REGISTER_FST_OPERATION_3ARCS(Union, UnionArgs2); } // namespace script } // namespace fst openfst-1.7.9/src/script/verify.cc000066400000000000000000000007041421600557100171160ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. #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_3ARCS(Verify, VerifyArgs); } // namespace script } // namespace fst openfst-1.7.9/src/script/weight-class.cc000066400000000000000000000062441421600557100202110ustar00rootroot00000000000000// 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 std::string &weight_type, const std::string &weight_str) { static const auto *reg = WeightClassRegister::GetRegister(); const auto stw = reg->GetEntry(weight_type); if (!stw) { FSTERROR() << "WeightClass: Unknown weight type: " << weight_type; impl_.reset(); return; } impl_.reset(stw(weight_str)); } constexpr char WeightClass::__ZERO__[]; constexpr char WeightClass::__ONE__[]; constexpr char WeightClass::__NOWEIGHT__[]; WeightClass WeightClass::Zero(const std::string &weight_type) { return WeightClass(weight_type, __ZERO__); } WeightClass WeightClass::One(const std::string &weight_type) { return WeightClass(weight_type, __ONE__); } WeightClass WeightClass::NoWeight(const std::string &weight_type) { return WeightClass(weight_type, __NOWEIGHT__); } bool WeightClass::WeightTypesMatch(const WeightClass &lhs, const WeightClass &rhs, const std::string &op_name) { if (lhs.Type() != rhs.Type()) { FSTERROR() << op_name << ": Weights with non-matching types: " << lhs.Type() << " and " << rhs.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 && WeightClass::WeightTypesMatch(lhs, 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 && WeightClass::WeightTypesMatch(lhs, 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 && WeightClass::WeightTypesMatch(lhs, rhs, "Times"))) { 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 && WeightClass::WeightTypesMatch(lhs, 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 openfst-1.7.9/src/test/000077500000000000000000000000001421600557100147555ustar00rootroot00000000000000openfst-1.7.9/src/test/Makefile.am000066400000000000000000000017341421600557100170160ustar00rootroot00000000000000AM_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 weight_test_SOURCES = weight_test.cc algo_test_SOURCES = algo_test.cc 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) openfst-1.7.9/src/test/Makefile.in000066400000000000000000001427521421600557100170350ustar00rootroot00000000000000# Makefile.in generated by automake 1.16.1 from Makefile.am. # @configure_input@ # Copyright (C) 1994-2018 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 = { \ if test -z '$(MAKELEVEL)'; then \ false; \ elif test -n '$(MAKE_HOST)'; then \ true; \ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ true; \ else \ false; \ fi; \ } 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 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_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) DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) 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__maybe_remake_depfiles = depfiles am__depfiles_remade = \ ./$(DEPDIR)/algo_test_lexicographic-algo_test.Po \ ./$(DEPDIR)/algo_test_log-algo_test.Po \ ./$(DEPDIR)/algo_test_minmax-algo_test.Po \ ./$(DEPDIR)/algo_test_power-algo_test.Po \ ./$(DEPDIR)/algo_test_tropical-algo_test.Po \ ./$(DEPDIR)/fst_test.Po ./$(DEPDIR)/weight_test.Po 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 = $(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) am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp \ $(top_srcdir)/test-driver 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@ LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ 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_LIBS = @PYTHON_LIBS@ 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@ runstatedir = @runstatedir@ 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 weight_test_SOURCES = weight_test.cc algo_test_SOURCES = algo_test.cc 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 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__maybe_remake_depfiles)'; \ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ 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@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_log-algo_test.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_minmax-algo_test.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_power-algo_test.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_tropical-algo_test.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst_test.Po@am__quote@ # am--include-marker @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight_test.Po@am__quote@ # am--include-marker $(am__depfiles_remade): @$(MKDIR_P) $(@D) @echo '# dummy' >$@-t && $(am__mv) $@-t $@ am--depfiles: $(am__depfiles_remade) .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; \ elif test -n "$$redo_logs"; then \ 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: $(check_PROGRAMS) @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: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) distdir-am distdir-am: $(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 -f ./$(DEPDIR)/algo_test_lexicographic-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_log-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_minmax-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_power-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_tropical-algo_test.Po -rm -f ./$(DEPDIR)/fst_test.Po -rm -f ./$(DEPDIR)/weight_test.Po -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 -f ./$(DEPDIR)/algo_test_lexicographic-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_log-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_minmax-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_power-algo_test.Po -rm -f ./$(DEPDIR)/algo_test_tropical-algo_test.Po -rm -f ./$(DEPDIR)/fst_test.Po -rm -f ./$(DEPDIR)/weight_test.Po -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 am--depfiles 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 .PRECIOUS: Makefile # 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: openfst-1.7.9/src/test/algo_test.cc000066400000000000000000000110021421600557100172370ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Regression test for various FST algorithms. #include #include #include #include // DEFINEs determine which semirings are tested; these are controlled by // the `defines` attributes of the associated build rules. DEFINE_uint64(seed, 403, "random seed"); DEFINE_int32(repeat, 25, "number of test repetitions"); namespace { 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::StdArc; using ::fst::STRING_LEFT; using ::fst::STRING_RIGHT; using ::fst::StringArc; using ::fst::TropicalWeight; using ::fst::WeightGenerate; } // namespace 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; LOG(INFO) << "Seed = " << FLAGS_seed; std::mt19937_64 rand(FLAGS_seed); FLAGS_fst_default_cache_gc = std::bernoulli_distribution(.5)(rand); FLAGS_fst_default_cache_gc_limit = std::uniform_int_distribution<>(0, kCacheGcLimit)(rand); 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(FLAGS_seed, false); AlgoTester tropical_tester(tropical_generator, FLAGS_seed); tropical_tester.Test(); #endif // TEST_TROPICAL #ifdef TEST_LOG using LogWeightGenerate = WeightGenerate; LogWeightGenerate log_generator(FLAGS_seed, false); AlgoTester log_tester(log_generator, FLAGS_seed); log_tester.Test(); #endif // TEST_LOG #ifdef TEST_MINMAX using MinMaxWeightGenerate = WeightGenerate; MinMaxWeightGenerate minmax_generator(FLAGS_seed, false); AlgoTester minmax_tester(minmax_generator, FLAGS_seed); minmax_tester.Test(); #endif #ifdef TEST_LEFT_STRING using StringWeightGenerate = WeightGenerate>; StringWeightGenerate left_string_generator(FLAGS_seed, 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(FLAGS_seed, 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(FLAGS_seed, 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(FLAGS_seed, 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(FLAGS_seed, false); AlgoTester tropical_cube_tester( tropical_cube_generator, FLAGS_seed); tropical_cube_tester.Test(); #endif // TEST_POWER return 0; } openfst-1.7.9/src/test/fst_test.cc000066400000000000000000000157051421600557100171270ustar00rootroot00000000000000// See www.openfst.org for extensive documentation on this weighted // finite-state transducer library. // // Regression test for FST classes. #include #include #include #include #include #include #include #include #include namespace fst { namespace { // A user-defined arc type. struct CustomArc { using Label = int16; using Weight = ProductWeight; using StateId = int64; CustomArc(Label i, Label o, Weight w, StateId s) : ilabel(i), olabel(o), weight(w), nextstate(s) {} CustomArc() {} static const std::string &Type() { // Arc type name static const std::string *const type = new std::string("my"); return *type; } Label ilabel; // Transition input label Label olabel; // Transition output label Weight weight; // Transition weight StateId nextstate; // Transition destination state }; REGISTER_FST(VectorFst, CustomArc); REGISTER_FST(ConstFst, CustomArc); static fst::FstRegisterer< CompactArcFst>> CompactFst_StdArc_TrivialCompactor_registerer; static fst::FstRegisterer< CompactArcFst>> CompactFst_CustomArc_TrivialCompactor_registerer; static fst::FstRegisterer> ConstFst_StdArc_uint16_registerer; static fst::FstRegisterer< CompactArcFst, uint16>> CompactFst_StdArc_TrivialCompactor_uint16_registerer; static fst::FstRegisterer>> CompactFst_StdArc_CustomCompactor_registerer; static fst::FstRegisterer< CompactFst>> CompactFst_CustomArc_CustomCompactor_registerer; } // namespace } // namespace fst using fst::CompactArcFst; using fst::CompactFst; using fst::ConstFst; using fst::CustomArc; using fst::EditFst; using fst::FstTester; using fst::MatcherFst; using fst::StdArc; using fst::StdArcLookAheadFst; using fst::TrivialArcCompactor; using fst::TrivialCompactor; using fst::VectorFst; 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 { for (const size_t num_states : {0, 1, 2, 3, 128}) { FstTester> std_vector_tester(num_states); std_vector_tester.TestBase(); std_vector_tester.TestExpanded(); std_vector_tester.TestAssign(); std_vector_tester.TestCopy(); std_vector_tester.TestIO(); std_vector_tester.TestMutable(); } // Test with a default-constructed Fst, not a copied Fst. FstTester> empty_tester(/*num_states=*/0); { const VectorFst empty_fst; empty_tester.TestBase(empty_fst); empty_tester.TestExpanded(empty_fst); empty_tester.TestCopy(empty_fst); empty_tester.TestIO(empty_fst); empty_tester.TestAssign(empty_fst); } { VectorFst empty_fst; empty_tester.TestMutable(&empty_fst); } } // ConstFst tests { FstTester> std_const_tester; std_const_tester.TestBase(); std_const_tester.TestExpanded(); std_const_tester.TestCopy(); std_const_tester.TestIO(); } // CompactArcFst> { FstTester>> std_compact_tester; std_compact_tester.TestBase(); std_compact_tester.TestExpanded(); std_compact_tester.TestCopy(); std_compact_tester.TestIO(); } // CompactFst> { for (const size_t num_states : {0, 1, 2, 3, 128}) { FstTester>> std_compact_tester(num_states); std_compact_tester.TestBase(); std_compact_tester.TestExpanded(); std_compact_tester.TestCopy(); std_compact_tester.TestIO(); } // TODO(jrosenstock): Add tests on default-constructed Fst. } // 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(); } // CompactArcFst> { for (const size_t num_states : {0, 1, 2, 3, 128}) { FstTester>> std_compact_tester(num_states); std_compact_tester.TestBase(); std_compact_tester.TestExpanded(); std_compact_tester.TestCopy(); std_compact_tester.TestIO(); } // TODO(jrosenstock): Make this work. #if 0 // Test with a default-constructed Fst, not a copied Fst. FstTester>> empty_tester(/*num_states=*/0); const CompactArcFst> empty_fst; empty_tester.TestBase(empty_fst); empty_tester.TestExpanded(empty_fst); empty_tester.TestCopy(empty_fst); empty_tester.TestIO(empty_fst); #endif } // CompactFst> { for (const size_t num_states : {0, 1, 2, 3, 128}) { FstTester>> std_compact_tester(num_states); std_compact_tester.TestBase(); std_compact_tester.TestExpanded(); std_compact_tester.TestCopy(); std_compact_tester.TestIO(); } // TODO(jrosenstock): Add tests on default-constructed Fst. } // ConstFst tests { FstTester> std_const_tester; std_const_tester.TestBase(); std_const_tester.TestExpanded(); std_const_tester.TestCopy(); std_const_tester.TestIO(); } // CompactArcFst, 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; } openfst-1.7.9/src/test/weight_test.cc000066400000000000000000000456201421600557100176210ustar00rootroot00000000000000// 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 DEFINE_uint64(seed, 403, "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::RealWeight; using fst::RealWeightTpl; using fst::SET_BOOLEAN; using fst::SET_INTERSECT_UNION; using fst::SET_UNION_INTERSECT; using fst::SetWeight; using fst::SignedLogWeight; using fst::SignedLogWeightTpl; using fst::SparsePowerWeight; using fst::STRING_LEFT; using fst::STRING_RIGHT; using fst::StringWeight; using fst::TropicalWeight; using fst::TropicalWeightTpl; using fst::UnionWeight; using fst::WeightConvert; using fst::WeightGenerate; using fst::WeightTester; template void TestTemplatedWeights(uint64 seed, int repeat) { using TropicalWeightGenerate = WeightGenerate>; TropicalWeightGenerate tropical_generate(seed); WeightTester, TropicalWeightGenerate> tropical_tester( tropical_generate); tropical_tester.Test(repeat); using LogWeightGenerate = WeightGenerate>; LogWeightGenerate log_generate(seed); WeightTester, LogWeightGenerate> log_tester(log_generate); log_tester.Test(repeat); using RealWeightGenerate = WeightGenerate>; RealWeightGenerate real_generate(seed); WeightTester, RealWeightGenerate> real_tester(real_generate); real_tester.Test(repeat); using MinMaxWeightGenerate = WeightGenerate>; MinMaxWeightGenerate minmax_generate(seed, true); WeightTester, MinMaxWeightGenerate> minmax_tester( minmax_generate); minmax_tester.Test(repeat); using SignedLogWeightGenerate = WeightGenerate>; SignedLogWeightGenerate signedlog_generate(seed, true); 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. const WeightConvert to_w1_; const 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)); } // If this test fails, it is possible that x == x will not // hold for FloatWeight, breaking NaturalLess and probably more. // To trigger these failures, use g++ -O -m32 -mno-sse. // Google-only... // This will never fail in google3, as those options aren't used. // ...Google-only template bool FloatEqualityIsReflexive(T m) { // The idea here is that x is spilled to memory, but // y remains in an 80-bit register with extra precision, // causing it to compare unequal to x. volatile T x = 1.111; x *= m; T y = 1.111; y *= m; return x == y; } void TestFloatEqualityIsReflexive() { // Use a volatile test_value to avoid excessive inlining / optimization // breaking what we're trying to test. volatile double test_value = 1.1; CHECK(FloatEqualityIsReflexive(static_cast(test_value))); CHECK(FloatEqualityIsReflexive(test_value)); } } // namespace int main(int argc, char **argv) { std::set_new_handler(FailedNewHandler); SET_FLAGS(argv[0], &argc, &argv, true); TestTemplatedWeights(FLAGS_seed, FLAGS_repeat); TestTemplatedWeights(FLAGS_seed, FLAGS_repeat); FLAGS_fst_weight_parentheses = "()"; TestTemplatedWeights(FLAGS_seed, FLAGS_repeat); TestTemplatedWeights(FLAGS_seed, FLAGS_repeat); FLAGS_fst_weight_parentheses = ""; // Makes sure type names for templated weights are consistent. CHECK_EQ(TropicalWeight::Type(), "tropical"); CHECK(TropicalWeightTpl::Type() != TropicalWeightTpl::Type()); CHECK_EQ(LogWeight::Type(), "log"); CHECK(LogWeightTpl::Type() != LogWeightTpl::Type()); CHECK_EQ(RealWeight::Type(), "real"); CHECK(RealWeightTpl::Type() != RealWeightTpl::Type()); TropicalWeightTpl w(2.0); TropicalWeight tw(2.0); CHECK_EQ(w.Value(), tw.Value()); TestAdder(1000); TestAdder(1000); TestAdder(1000); TestSignedAdder(1000); TestImplicitConversion(); TestImplicitConversion(); TestImplicitConversion(); TestImplicitConversion(); TestWeightConversion(2.0); using LeftStringWeight = StringWeight; using LeftStringWeightGenerate = WeightGenerate; LeftStringWeightGenerate left_string_generate(FLAGS_seed); WeightTester left_string_tester( left_string_generate); left_string_tester.Test(FLAGS_repeat); using RightStringWeight = StringWeight; using RightStringWeightGenerate = WeightGenerate; RightStringWeightGenerate right_string_generate(FLAGS_seed); 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(FLAGS_seed); WeightTester iu_set_tester(iu_set_generate); iu_set_tester.Test(FLAGS_repeat); using UISetWeight = SetWeight; using UISetWeightGenerate = WeightGenerate; UISetWeightGenerate ui_set_generate(FLAGS_seed); 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(FLAGS_seed); 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(FLAGS_seed, true); WeightTester tropical_gallic_tester(tropical_gallic_generate); using TropicalGenGallicWeight = GallicWeight; using TropicalGenGallicWeightGenerate = WeightGenerate; TropicalGenGallicWeightGenerate tropical_gen_gallic_generate(FLAGS_seed, false); WeightTester tropical_gen_gallic_tester(tropical_gen_gallic_generate); using TropicalProductWeight = ProductWeight; using TropicalProductWeightGenerate = WeightGenerate; TropicalProductWeightGenerate tropical_product_generate(FLAGS_seed); WeightTester tropical_product_tester(tropical_product_generate); using TropicalLexicographicWeight = LexicographicWeight; using TropicalLexicographicWeightGenerate = WeightGenerate; TropicalLexicographicWeightGenerate tropical_lexicographic_generate( FLAGS_seed); WeightTester tropical_lexicographic_tester(tropical_lexicographic_generate); using TropicalCubeWeight = PowerWeight; using TropicalCubeWeightGenerate = WeightGenerate; TropicalCubeWeightGenerate tropical_cube_generate(FLAGS_seed); WeightTester tropical_cube_tester(tropical_cube_generate); using FirstNestedProductWeight = ProductWeight; using FirstNestedProductWeightGenerate = WeightGenerate; FirstNestedProductWeightGenerate first_nested_product_generate(FLAGS_seed); WeightTester first_nested_product_tester(first_nested_product_generate); using SecondNestedProductWeight = ProductWeight; using SecondNestedProductWeightGenerate = WeightGenerate; SecondNestedProductWeightGenerate second_nested_product_generate(FLAGS_seed); WeightTester second_nested_product_tester(second_nested_product_generate); using NestedProductCubeWeight = PowerWeight; using NestedProductCubeWeightGenerate = WeightGenerate; NestedProductCubeWeightGenerate nested_product_cube_generate(FLAGS_seed); WeightTester nested_product_cube_tester(nested_product_cube_generate); using SparseNestedProductCubeWeight = SparsePowerWeight; using SparseNestedProductCubeWeightGenerate = WeightGenerate; SparseNestedProductCubeWeightGenerate sparse_nested_product_cube_generate( FLAGS_seed); WeightTester sparse_nested_product_cube_tester(sparse_nested_product_cube_generate); using LogSparsePowerWeight = SparsePowerWeight; using LogSparsePowerWeightGenerate = WeightGenerate; LogSparsePowerWeightGenerate log_sparse_power_generate(FLAGS_seed); WeightTester log_sparse_power_tester(log_sparse_power_generate); using LogLogExpectationWeight = ExpectationWeight; using LogLogExpectationWeightGenerate = WeightGenerate; LogLogExpectationWeightGenerate log_log_expectation_generate(FLAGS_seed); WeightTester log_log_expectation_tester(log_log_expectation_generate); using LogLogSparseExpectationWeight = ExpectationWeight; using LogLogSparseExpectationWeightGenerate = WeightGenerate; LogLogSparseExpectationWeightGenerate log_log_sparse_expectation_generate( FLAGS_seed); 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(FLAGS_seed); 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(); TestFloatEqualityIsReflexive(); return 0; } openfst-1.7.9/test-driver000077500000000000000000000110421421600557100154030ustar00rootroot00000000000000#! /bin/sh # test-driver - basic testsuite driver script. scriptversion=2018-03-07.03; # UTC # Copyright (C) 2011-2018 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 tweaked_estatus=1 else tweaked_estatus=$estatus fi case $tweaked_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 the test outcome and exit status in the logs, so that one can # know whether the test passed or failed simply by looking at the '.log' # file, without the need of also peaking into the corresponding '.trs' # file (automake bug#11814). echo "$res $test_name (exit status: $estatus)" >>$log_file # 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 'before-save-hook 'time-stamp) # time-stamp-start: "scriptversion=" # time-stamp-format: "%:y-%02m-%02d.%02H" # time-stamp-time-zone: "UTC0" # time-stamp-end: "; # UTC" # End: