--- /dev/null
+Principal Contacts:
+
+Cyril Allauzen <allauzen@google.com>
+Michael Riley <riley@google.com>
+
+Contributors:
+
+These contributions range from fundamental algorithmic contributions (e.g.,
+Mehryar Mohri) to implementation of core components and extensions.
+
+Tom Bagby <tombagby@google.com>
+Dan Bikel <dbikel@google.com>
+Dan Povey <dpovey@gmail.com>
+Kyle Gorman <kbg@google.com>
+Boulos Harb <harb@google.com>
+Mehryar Mohri <mohri@cs.nyu.edu>
+Kasturi Raghavan <krr@google.com>
+Jacob Ratkiewicz <jpr@google.com>
+Johan Schalkwyk <johans@google.com>
+Masha Shugrina <shumash@google.com>
+Wojtek Skut <wojciech@google.com>
+Jeffrey Sorensen <sorenj@google.com>
+Richard Sproat <rws@google.com>
+Ananda Theertha Suresh <theertha@google.com>
+Terry Tai <ttai@google.com>
+Ke Wu <wuke@google.com>
--- /dev/null
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use these files except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Copyright 2005-2015 Google, Inc.
--- /dev/null
+Installation Instructions
+*************************
+
+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005,
+2006, 2007 Free Software Foundation, Inc.
+
+This file is free documentation; the Free Software Foundation gives
+unlimited permission to copy, distribute and modify it.
+
+Basic Installation
+==================
+
+Briefly, the shell commands `./configure; make; make install' should
+configure, build, and install this package. The following
+more-detailed instructions are generic; see the `README' file for
+instructions specific to this package.
+
+ The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation. It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions. Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+ It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring. Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.
+
+ If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release. If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+ The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'. You need `configure.ac' if
+you want to change it or regenerate `configure' using a newer version
+of `autoconf'.
+
+The simplest way to compile this package is:
+
+ 1. `cd' to the directory containing the package's source code and type
+ `./configure' to configure the package for your system.
+
+ Running `configure' might take a while. While running, it prints
+ some messages telling which features it is checking for.
+
+ 2. Type `make' to compile the package.
+
+ 3. Optionally, type `make check' to run any self-tests that come with
+ the package.
+
+ 4. Type `make install' to install the programs and any data files and
+ documentation.
+
+ 5. You can remove the program binaries and object files from the
+ source code directory by typing `make clean'. To also remove the
+ files that `configure' created (so you can compile the package for
+ a different kind of computer), type `make distclean'. There is
+ also a `make maintainer-clean' target, but that is intended mainly
+ for the package's developers. If you use it, you may have to get
+ all sorts of other programs in order to regenerate files that came
+ with the distribution.
+
+ 6. Often, you can also type `make uninstall' to remove the installed
+ files again.
+
+Compilers and Options
+=====================
+
+Some systems require unusual options for compilation or linking that the
+`configure' script does not know about. Run `./configure --help' for
+details on some of the pertinent environment variables.
+
+ You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment. Here
+is an example:
+
+ ./configure CC=c99 CFLAGS=-g LIBS=-lposix
+
+ *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory. To do this, you can use GNU `make'. `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script. `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+ With a non-GNU `make', it is safer to compile the package for one
+architecture at a time in the source code directory. After you have
+installed the package for one architecture, use `make distclean' before
+reconfiguring for another architecture.
+
+Installation Names
+==================
+
+By default, `make install' installs the package's commands under
+`/usr/local/bin', include files under `/usr/local/include', etc. You
+can specify an installation prefix other than `/usr/local' by giving
+`configure' the option `--prefix=PREFIX'.
+
+ You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files. If you
+pass the option `--exec-prefix=PREFIX' to `configure', the package uses
+PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files still use the regular prefix.
+
+ In addition, if you use an unusual directory layout you can give
+options like `--bindir=DIR' to specify different values for particular
+kinds of files. Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+ If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System). The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+ For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+There may be some features `configure' cannot figure out automatically,
+but needs to determine by the type of machine the package will run on.
+Usually, assuming the package is built to be run on the _same_
+architectures, `configure' can figure that out, but if it prints a
+message saying it cannot guess the machine type, give it the
+`--build=TYPE' option. TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+ CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+ OS KERNEL-OS
+
+ See the file `config.sub' for the possible values of each field. If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+ If you are _building_ compiler tools for cross-compiling, you should
+use the option `--target=TYPE' to select the type of system they will
+produce code for.
+
+ If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+If you want to set default values for `configure' scripts to share, you
+can create a site shell script called `config.site' that gives default
+values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists. Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+Variables not defined in a site shell script can be set in the
+environment passed to `configure'. However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost. In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'. For example:
+
+ ./configure CC=/usr/local2/bin/gcc
+
+causes the specified `gcc' to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+Unfortunately, this technique does not work for `CONFIG_SHELL' due to
+an Autoconf bug. Until the bug is fixed you can use this workaround:
+
+ CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+`configure' Invocation
+======================
+
+`configure' recognizes the following options to control how it operates.
+
+`--help'
+`-h'
+ Print a summary of the options to `configure', and exit.
+
+`--version'
+`-V'
+ Print the version of Autoconf used to generate the `configure'
+ script, and exit.
+
+`--cache-file=FILE'
+ Enable the cache: use and save the results of the tests in FILE,
+ traditionally `config.cache'. FILE defaults to `/dev/null' to
+ disable caching.
+
+`--config-cache'
+`-C'
+ Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+ Do not print messages saying which checks are being made. To
+ suppress all normal output, redirect it to `/dev/null' (any error
+ messages will still be shown).
+
+`--srcdir=DIR'
+ Look for the package's source code in directory DIR. Usually
+ `configure' can determine that directory automatically.
+
+`configure' also accepts some other, not widely useful, options. Run
+`configure --help' for more details.
+
--- /dev/null
+SUBDIRS = src
+ACLOCAL_AMFLAGS = -I m4
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = .
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/configure $(am__configure_deps) \
+ $(srcdir)/config.h.in \
+ $(top_srcdir)/src/include/fst/config.h.in AUTHORS COPYING \
+ INSTALL NEWS README ar-lib compile config.guess config.sub \
+ install-sh missing ltmain.sh
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno config.status.lineno
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = config.h $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+SOURCES =
+DIST_SOURCES =
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+ ctags-recursive dvi-recursive html-recursive info-recursive \
+ install-data-recursive install-dvi-recursive \
+ install-exec-recursive install-html-recursive \
+ install-info-recursive install-pdf-recursive \
+ install-ps-recursive install-recursive installcheck-recursive \
+ installdirs-recursive pdf-recursive ps-recursive \
+ tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
+ distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+ $(RECURSIVE_TARGETS) \
+ $(RECURSIVE_CLEAN_TARGETS) \
+ $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+ cscope distdir dist dist-all distcheck
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
+ $(LISP)config.h.in
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+CSCOPE = cscope
+DIST_SUBDIRS = $(SUBDIRS)
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+ if test -d "$(distdir)"; then \
+ find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
+ && rm -rf "$(distdir)" \
+ || { sleep 5 && rm -rf "$(distdir)"; }; \
+ else :; fi
+am__post_remove_distdir = $(am__remove_distdir)
+am__relativize = \
+ dir0=`pwd`; \
+ sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+ sed_rest='s,^[^/]*/*,,'; \
+ sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+ sed_butlast='s,/*[^/]*$$,,'; \
+ while test -n "$$dir1"; do \
+ first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+ if test "$$first" != "."; then \
+ if test "$$first" = ".."; then \
+ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+ else \
+ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+ if test "$$first2" = "$$first"; then \
+ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+ else \
+ dir2="../$$dir2"; \
+ fi; \
+ dir0="$$dir0"/"$$first"; \
+ fi; \
+ fi; \
+ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+ done; \
+ reldir="$$dir2"
+DIST_ARCHIVES = $(distdir).tar.gz
+GZIP_ENV = --best
+DIST_TARGETS = dist-gzip
+distuninstallcheck_listfiles = find . -type f -print
+am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
+ | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
+distcleancheck_listfiles = find . -type f -print
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+SUBDIRS = src
+ACLOCAL_AMFLAGS = -I m4
+all: config.h
+ $(MAKE) $(AM_MAKEFLAGS) all-recursive
+
+.SUFFIXES:
+am--refresh: Makefile
+ @:
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
+ $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
+ && exit 0; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ echo ' $(SHELL) ./config.status'; \
+ $(SHELL) ./config.status;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ $(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ $(am__cd) $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+$(am__aclocal_m4_deps):
+
+config.h: stamp-h1
+ @test -f $@ || rm -f stamp-h1
+ @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
+
+stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status
+ @rm -f stamp-h1
+ cd $(top_builddir) && $(SHELL) ./config.status config.h
+$(srcdir)/config.h.in: $(am__configure_deps)
+ ($(am__cd) $(top_srcdir) && $(AUTOHEADER))
+ rm -f stamp-h1
+ touch $@
+
+src/include/fst/config.h: src/include/fst/stamp-h2
+ @test -f $@ || rm -f src/include/fst/stamp-h2
+ @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) src/include/fst/stamp-h2
+
+src/include/fst/stamp-h2: $(top_srcdir)/src/include/fst/config.h.in $(top_builddir)/config.status
+ @rm -f src/include/fst/stamp-h2
+ cd $(top_builddir) && $(SHELL) ./config.status src/include/fst/config.h
+
+distclean-hdr:
+ -rm -f config.h stamp-h1 src/include/fst/config.h src/include/fst/stamp-h2
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+distclean-libtool:
+ -rm -f libtool config.lt
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+# (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+ @fail=; \
+ if $(am__make_keepgoing); then \
+ failcom='fail=yes'; \
+ else \
+ failcom='exit 1'; \
+ fi; \
+ dot_seen=no; \
+ target=`echo $@ | sed s/-recursive//`; \
+ case "$@" in \
+ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+ *) list='$(SUBDIRS)' ;; \
+ esac; \
+ for subdir in $$list; do \
+ echo "Making $$target in $$subdir"; \
+ if test "$$subdir" = "."; then \
+ dot_seen=yes; \
+ local_target="$$target-am"; \
+ else \
+ local_target="$$target"; \
+ fi; \
+ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+ || eval $$failcom; \
+ done; \
+ if test "$$dot_seen" = "no"; then \
+ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+ fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+ include_option=--etags-include; \
+ empty_fix=.; \
+ else \
+ include_option=--include; \
+ empty_fix=; \
+ fi; \
+ list='$(SUBDIRS)'; for subdir in $$list; do \
+ if test "$$subdir" = .; then :; else \
+ test ! -f $$subdir/TAGS || \
+ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+ fi; \
+ done; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscope: cscope.files
+ test ! -s cscope.files \
+ || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
+clean-cscope:
+ -rm -f cscope.files
+cscope.files: clean-cscope cscopelist
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+ -rm -f cscope.out cscope.in.out cscope.po.out cscope.files
+
+distdir: $(DISTFILES)
+ $(am__remove_distdir)
+ test -d "$(distdir)" || mkdir "$(distdir)"
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+ @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+ if test "$$subdir" = .; then :; else \
+ $(am__make_dryrun) \
+ || test -d "$(distdir)/$$subdir" \
+ || $(MKDIR_P) "$(distdir)/$$subdir" \
+ || exit 1; \
+ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+ $(am__relativize); \
+ new_distdir=$$reldir; \
+ dir1=$$subdir; dir2="$(top_distdir)"; \
+ $(am__relativize); \
+ new_top_distdir=$$reldir; \
+ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+ ($(am__cd) $$subdir && \
+ $(MAKE) $(AM_MAKEFLAGS) \
+ top_distdir="$$new_top_distdir" \
+ distdir="$$new_distdir" \
+ am__remove_distdir=: \
+ am__skip_length_check=: \
+ am__skip_mode_fix=: \
+ distdir) \
+ || exit 1; \
+ fi; \
+ done
+ -test -n "$(am__skip_mode_fix)" \
+ || find "$(distdir)" -type d ! -perm -755 \
+ -exec chmod u+rwx,go+rx {} \; -o \
+ ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+ ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+ ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
+ || chmod -R a+r "$(distdir)"
+dist-gzip: distdir
+ tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+ $(am__post_remove_distdir)
+
+dist-bzip2: distdir
+ tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
+ $(am__post_remove_distdir)
+
+dist-lzip: distdir
+ tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
+ $(am__post_remove_distdir)
+
+dist-xz: distdir
+ tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
+ $(am__post_remove_distdir)
+
+dist-tarZ: distdir
+ @echo WARNING: "Support for shar distribution archives is" \
+ "deprecated." >&2
+ @echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+ tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+ $(am__post_remove_distdir)
+
+dist-shar: distdir
+ @echo WARNING: "Support for distribution archives compressed with" \
+ "legacy program 'compress' is deprecated." >&2
+ @echo WARNING: "It will be removed altogether in Automake 2.0" >&2
+ shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
+ $(am__post_remove_distdir)
+
+dist-zip: distdir
+ -rm -f $(distdir).zip
+ zip -rq $(distdir).zip $(distdir)
+ $(am__post_remove_distdir)
+
+dist dist-all:
+ $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
+ $(am__post_remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration. Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+ case '$(DIST_ARCHIVES)' in \
+ *.tar.gz*) \
+ GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
+ *.tar.bz2*) \
+ bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
+ *.tar.lz*) \
+ lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
+ *.tar.xz*) \
+ xz -dc $(distdir).tar.xz | $(am__untar) ;;\
+ *.tar.Z*) \
+ uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+ *.shar.gz*) \
+ GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
+ *.zip*) \
+ unzip $(distdir).zip ;;\
+ esac
+ chmod -R a-w $(distdir)
+ chmod u+w $(distdir)
+ mkdir $(distdir)/_build $(distdir)/_inst
+ chmod a-w $(distdir)
+ test -d $(distdir)/_build || exit 0; \
+ dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+ && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+ && am__cwd=`pwd` \
+ && $(am__cd) $(distdir)/_build \
+ && ../configure \
+ $(AM_DISTCHECK_CONFIGURE_FLAGS) \
+ $(DISTCHECK_CONFIGURE_FLAGS) \
+ --srcdir=.. --prefix="$$dc_install_base" \
+ && $(MAKE) $(AM_MAKEFLAGS) \
+ && $(MAKE) $(AM_MAKEFLAGS) dvi \
+ && $(MAKE) $(AM_MAKEFLAGS) check \
+ && $(MAKE) $(AM_MAKEFLAGS) install \
+ && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+ && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+ && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+ distuninstallcheck \
+ && chmod -R a-w "$$dc_install_base" \
+ && ({ \
+ (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+ && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+ distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+ } || { rm -rf "$$dc_destdir"; exit 1; }) \
+ && rm -rf "$$dc_destdir" \
+ && $(MAKE) $(AM_MAKEFLAGS) dist \
+ && rm -rf $(DIST_ARCHIVES) \
+ && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
+ && cd "$$am__cwd" \
+ || exit 1
+ $(am__post_remove_distdir)
+ @(echo "$(distdir) archives ready for distribution: "; \
+ list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+ sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
+distuninstallcheck:
+ @test -n '$(distuninstallcheck_dir)' || { \
+ echo 'ERROR: trying to run $@ with an empty' \
+ '$$(distuninstallcheck_dir)' >&2; \
+ exit 1; \
+ }; \
+ $(am__cd) '$(distuninstallcheck_dir)' || { \
+ echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
+ exit 1; \
+ }; \
+ test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
+ || { echo "ERROR: files left after uninstall:" ; \
+ if test -n "$(DESTDIR)"; then \
+ echo " (check DESTDIR support)"; \
+ fi ; \
+ $(distuninstallcheck_listfiles) ; \
+ exit 1; } >&2
+distcleancheck: distclean
+ @if test '$(srcdir)' = . ; then \
+ echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+ exit 1 ; \
+ fi
+ @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+ || { echo "ERROR: files left in build directory after distclean:" ; \
+ $(distcleancheck_listfiles) ; \
+ exit 1; } >&2
+check-am: all-am
+check: check-recursive
+all-am: Makefile config.h
+installdirs: installdirs-recursive
+installdirs-am:
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-recursive
+ -rm -f $(am__CONFIG_DISTCLEAN_FILES)
+ -rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-hdr \
+ distclean-libtool distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+ -rm -f $(am__CONFIG_DISTCLEAN_FILES)
+ -rm -rf $(top_srcdir)/autom4te.cache
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: $(am__recursive_targets) all install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
+ am--refresh check check-am clean clean-cscope clean-generic \
+ clean-libtool cscope cscopelist-am ctags ctags-am dist \
+ dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \
+ dist-xz dist-zip distcheck distclean distclean-generic \
+ distclean-hdr distclean-libtool distclean-tags distcleancheck \
+ distdir distuninstallcheck dvi dvi-am html html-am info \
+ info-am install install-am install-data install-data-am \
+ install-dvi install-dvi-am install-exec install-exec-am \
+ install-html install-html-am install-info install-info-am \
+ install-man install-pdf install-pdf-am install-ps \
+ install-ps-am install-strip installcheck installcheck-am \
+ installdirs installdirs-am maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-generic \
+ mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
+ uninstall-am
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+OpenFst: Release 1.6
+ * Extensive modernization for C++11 style (1.6.0)
+ * Many classes and constants moved into an internal namespace (1.6.0)
+ * Adds HashMatcher (1.6.0)
+ * Adds Member method to SymbolTable (1.6.0)
+ * Adds the "special" extension and the fstspecial binary; this is similar to
+ fstconvert but accepts arguments for specifying special labels (phi, rho,
+ and sigma) of FSTs (1.6.0)
+ * Exposes allow_negative_label option for Python symbol tables (1.6.0)
+
+OpenFst: Release 1.5
+ * Added p-subsequential determinization (1.5.0)
+ * Generalized epsilon normalization to non-functional case (1.5.0)
+ * Added general gallic (plus is union) semiring (1.5.0)
+ * Added FST compression extension (1.5.0)
+ * Added Python extension (1.5.0)
+ * Added multiple pushdown transducer (MPDT) support (1.5.0)
+ * Fixed Isomorphic function (1.5.0)
+ * Added final method to matchers (1.5.0)
+ * Fixed various compiler issues (1.5.0)
+ * Fixed missing Isomorphic components (1.5.0)
+ * Added UnionWeight (1.5.0)
+ * Added InputEpsilonMapper and OutputEpsilonMapper arc mappers (1.5.1)
+ * Added TrivialComposeFilter for more efficient composition when one
+ of the arguments is epsilon-free (1.5.1)
+ * Added properties bits kUnweightedCycles and kWeightedCycles (1.5.1)
+ * Added missing const qualification to (1.5.1):
+ - SymbolTableIterator access
+ - EncodeMapper writing to file
+ - EncodeMapper SymbolTable access
+ * Replaced internal custom reference-counting (RefCounter) with
+ C++11 smart pointers where possible, and fixed associated
+ reference-counting bugs (1.5.1)
+ * When calling DeleteStates on a MutableFst with a shared impl, the impl
+ is set to a new empty impl rather than copying and deleting (1.5.1)
+ * Prepended `Pdt` to the Expand libraries and classes in the PDT
+ extension, and prepended `MPdt` to the Expand libraries and classes
+ in the MPDT extension, so that both can be used in the same compilation
+ unit (1.5.1)
+ * Added option to PDT Replace for compiling a strongly-regular RTN into a
+ bounded-stack PDT (1.5.1)
+ * Improved symbol table support for PDT Replace, including automatic
+ generation of parentheses symbols (1.5.1)
+ * Improvements to scripting API (1.5.1):
+ - Added methods for FST access and mutation
+ - Added additional checks for arc/weight compatibility
+ - WeightClass::One and WeightClass::Zero now require a specified weight
+ type at time of construction
+ - Improved VectorFstClass constructors
+ - Added linear-time check for cyclic dependencies in Replace
+ - Added EncodeMapperClass, a template-free box for an EncodeMapper
+ * Improvements to the binaries (1.5.1):
+ - Fixed no-op --precision flag to fstdraw (1.5.1)
+ - Fixed no-op --file_list_input flag to farcreate (1.5.1)
+ * Improvements to the Python extension (1.5.1):
+ - Added methods for creating an empty mutable FST
+ - Added methods for FST access via state and arc iteration
+ - Added FST compilation from arclists (cf. fstcompile)
+ - Added FST printing and drawing
+ - Added FarReader and FarWriter classes.
+ * FarReader's GetFst method now returns a pointer (1.5.2)
+ * Fixed FSTERROR macro (1.5.2)
+ * Fixed build flags for dlopen (1.5.2)
+ * Consolidated Python extension into single module (1.5.2)
+ * Python add_arc now takes an Arc object (1.5.2)
+ * Adds optional minimization of non-deterministic FSTs (1.5.3)
+ * Mutation methods of the Python Fst object now support chaining (1.5.3)
+ * Scripting API and Python weight objects now support semiring arithmetic
+ (1.5.3)
+ * Adds RemoveSymbol method to SymbolTable (1.5.4)
+ * Prevents underflow when using LogProbArcSelector in random generation
+ (1.5.4)
+ * Makes random weight generators a single template class (1.5.4)
+ * Makes weight Properties constexpr where possible (1.5.4)
+ * Adds check for error when opening files when compiling strings into FARs
+ (1.5.4)
+ * Adds routines for parsing string flags to the scripting API (1.5.4)
+
+OpenFst: Release 1.4
+ * Port to C++11 (1.4.0)
+ * Disambiguate function added (1.4.0)
+ * Isomorphic function added (1.4.0)
+ * Matcher interface augmented with Priority method.
+ * Special matchers (rho/sigma/phi) can match special symbols
+ on both input FSTs in composition/intersection provided at each
+ state pair they only match one side (1.4.0)
+ * Added ExplicitMatcher to suppress implicit matches (e.g. epsilon
+ self-loops) (1.4.0)
+ * Linear{Tagger,Classifier}Fst extensions added (1.4.0).
+ * Generalized state-reachable to work when input is cyclic (so long as no
+ final state is in a cycle). This ensures label-reachable (and hence label
+ lookahead) works with cyclic input (1.4.0)
+ * Added Condense to build the condensation graph (SCCs condensed to single
+ states) of an FST (1.4.0).
+ * Added an option to Reverse to specify whether a super-initial state
+ should always be created (1.4.0).
+ * Fixed bugs in FirstCacheStore, PowerWeight, and StringCompiler (1.4.0).
+ * Changed SymbolTable to use faster data structure (1.4.0).
+ * Added 'min' disambiguation in determinizaton to keep only the minimum
+ output in a non-functional transducer when plus=min/max
+ (flag --disambiguate_output) (1.4.1)
+ * Compiler issues in linear-fst fixed (1.4.1)
+
+OpenFst: Release 1.3
+ * Support for non-fatal exits on errors: (1.3.1)
+ - Added FLAGS_fst_error_fatal: FST errors are
+ fatal if true (default); o.w. return objects flagged as bad:
+ e.g., FSTs - kError
+ prop. true, FST weights - not a Member().
+ - Added kError property bit signifying bad FST
+ - Added NoWeight() method to FST weight requirements that returns
+ weight that is not a Member().
+ * Various improvements to the FAR extensions (1.3.1)
+ - a single FST is now a FAR type
+ - FLAGS_initial_symbols: Uses the symbol table from the
+ first FST in the archive for all entries"
+ - Input/output to standard input/output for some FAR and arc types
+ * --with-icu configuration option no longer needed (1.3.1)
+ * Improved flags usage esp. if use SET_FLAGS not SetFlags/InitFst (1.3.2)
+ * Added 'fst' as possible far writer type (1.3.2)
+ * phi matcher can now accept 0 as the phi label (1.3.2)
+ * Added ngram-fst extension (1.3.2)
+ * Improved performance of PDT composition (1.3.3)
+ * Memory-map support (1.3.3)
+ * Fixed cross-FST serialization issues (1.3.3)
+ * Fixed NGramFst off-by-one issue (1.3.3)
+ * farextract now allows one to specify a list of comma-separated keys,
+ including key ranges (1.3.3)
+ * Fixed bug in PDT replace that could cause close paren IDs to collide
+ with open paren IDs (1.3.4)
+
+OpenFst: Release 1.2
+ * Added lookahead matching and filtering for faster composition
+ * Added EditFst for mutation of o.w. immutable FSTs
+ * Added script sub-namespace defining type FstClass, a non-templated
+ Fst<Arc> 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 <functional> 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
--- /dev/null
+OpenFst: Release 1.6.0
+
+OpenFst is a library for constructing, combining, optimizing, and searching
+weighted finite-state transducers (FSTs).
+
+REQUIREMENTS:
+ This version is known to work under Linux using g++ (>= 4.7) and OS X using
+ XCode (>= 5). It is expected to work wherever adequate POSIX (dlopen,
+ ssize_t, basename), C99 (snprintf, strtoll, <stdint.h>), and C++11
+ (<unordered_set>, <unordered_map>, <forward_list>) support is available.
+
+INSTALLATION:
+ Follow the generic GNU build system instructions in ./INSTALL. We
+ recommend configuring with --enable-static=no for faster compiles.
+
+ Optional features:
+
+ --enable-bin Enable fst::script and executables (def: yes)
+ --enable-compact-fsts Enable CompactFst extensions (def: no)
+ --enable-compress Enable compression extension (def: no)
+ --enable-const-fsts Enable ConstFst extensions (def: no)
+ --enable-far Enable FAR extensions (def: no)
+ --enable-grm Enable all dependencies of OpenGrm (def: no)
+ --enable-linear-fsts Enable LinearTagger/ClassifierFst extensions (def: no)
+ --enable-lookahead-fsts Enable LookAheadFst extensions (def: no)
+ --enable-mpdt Enable MPDT extensions (def: no)
+ --enable-ngram-fsts Enable NGramFst extensions (def: no)
+ --enable-pdt Enable PDT extensions (def: no)
+ --enable-python Enable Python extension (def: no)
+ --enable-special Enable special-matcher extensions (def: no)
+
+ Configuring with --enable-bin=no gives very fast compiles, but excludes the
+ command line utilities.
+
+ Configuring with --enable-python will attempt to install the Python module to
+ whichever site-packages (or dist-packages, on Debian or Ubuntu) is found
+ during configuration.
+
+ The flag --with-libfstdir specifies where FST extensions should be installed;
+ it defaults to ${libdir}/fst.
+
+ Compiling with -Wall -Wno-sign-compare under g++ should give no warnings from
+ this library.
+
+ If you encounter an error about loading shared objects when attempting to use
+ the library immediately after installation, (e.g, `...cannot open shared
+ object file...`) you may need to refresh your system's shared object cache.
+ On Linux, this is accomplished by invoking ldconfig; the corresponding command
+ on OS X is called update_dyld_shared_cache. Both of these require superuser
+ privileges (and so should be executed with sudo).
+
+USAGE:
+ Assuming you've installed under the default /usr/local, the FST binaries are
+ found on /usr/local/bin.
+
+ To use in your own program, include <fst/fstlib.h> and compile with
+ -I/usr/local/include. The compiler must support C++11 (for g++ add the flag
+ -std=c++11). Link against /usr/local/lib/libfst.so and -ldl. Set your
+ LD_LIBRARY_PATH (or equivalent) to contain /usr/local/lib. The linking is,
+ by default, dynamic so that the Fst and Arc type DSO extensions can be used
+ correctly if desired. Any extensions will be found under /usr/local/lib/fst
+ or /usr/local/include/fst/extensions.
+
+DOCUMENTATION:
+ See www.openfst.org for general documentation.
+ See ./NEWS for updates since the last release.
--- /dev/null
+# generated automatically by aclocal 1.14.1 -*- Autoconf -*-
+
+# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
+m4_ifndef([AC_AUTOCONF_VERSION],
+ [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
+[m4_warning([this file was generated for autoconf 2.69.
+You have another version of autoconf. It may work, but is not guaranteed to.
+If you have problems, you may need to regenerate the build system entirely.
+To do so, use the procedure documented by the package, typically 'autoreconf'.])])
+
+# Copyright (C) 2002-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_AUTOMAKE_VERSION(VERSION)
+# ----------------------------
+# Automake X.Y traces this macro to ensure aclocal.m4 has been
+# generated from the m4 files accompanying Automake X.Y.
+# (This private macro should not be called outside this file.)
+AC_DEFUN([AM_AUTOMAKE_VERSION],
+[am__api_version='1.14'
+dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
+dnl require some minimum version. Point them to the right macro.
+m4_if([$1], [1.14.1], [],
+ [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
+])
+
+# _AM_AUTOCONF_VERSION(VERSION)
+# -----------------------------
+# aclocal traces this macro to find the Autoconf version.
+# This is a private macro too. Using m4_define simplifies
+# the logic in aclocal, which can simply ignore this definition.
+m4_define([_AM_AUTOCONF_VERSION], [])
+
+# AM_SET_CURRENT_AUTOMAKE_VERSION
+# -------------------------------
+# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
+# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
+AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
+[AM_AUTOMAKE_VERSION([1.14.1])dnl
+m4_ifndef([AC_AUTOCONF_VERSION],
+ [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
+_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
+
+# Copyright (C) 2011-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_AR([ACT-IF-FAIL])
+# -------------------------
+# Try to determine the archiver interface, and trigger the ar-lib wrapper
+# if it is needed. If the detection of archiver interface fails, run
+# ACT-IF-FAIL (default is to abort configure with a proper error message).
+AC_DEFUN([AM_PROG_AR],
+[AC_BEFORE([$0], [LT_INIT])dnl
+AC_BEFORE([$0], [AC_PROG_LIBTOOL])dnl
+AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([ar-lib])dnl
+AC_CHECK_TOOLS([AR], [ar lib "link -lib"], [false])
+: ${AR=ar}
+
+AC_CACHE_CHECK([the archiver ($AR) interface], [am_cv_ar_interface],
+ [AC_LANG_PUSH([C])
+ am_cv_ar_interface=ar
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int some_variable = 0;]])],
+ [am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
+ AC_TRY_EVAL([am_ar_try])
+ if test "$ac_status" -eq 0; then
+ am_cv_ar_interface=ar
+ else
+ am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&AS_MESSAGE_LOG_FD'
+ AC_TRY_EVAL([am_ar_try])
+ if test "$ac_status" -eq 0; then
+ am_cv_ar_interface=lib
+ else
+ am_cv_ar_interface=unknown
+ fi
+ fi
+ rm -f conftest.lib libconftest.a
+ ])
+ AC_LANG_POP([C])])
+
+case $am_cv_ar_interface in
+ar)
+ ;;
+lib)
+ # Microsoft lib, so override with the ar-lib wrapper script.
+ # FIXME: It is wrong to rewrite AR.
+ # But if we don't then we get into trouble of one sort or another.
+ # A longer-term fix would be to have automake use am__AR in this case,
+ # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something
+ # similar.
+ AR="$am_aux_dir/ar-lib $AR"
+ ;;
+unknown)
+ m4_default([$1],
+ [AC_MSG_ERROR([could not determine $AR interface])])
+ ;;
+esac
+AC_SUBST([AR])dnl
+])
+
+# AM_AUX_DIR_EXPAND -*- Autoconf -*-
+
+# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
+# $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to
+# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory. The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run. This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+# fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+# fails if $ac_aux_dir is absolute,
+# fails when called from a subdirectory in a VPATH build with
+# a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir. In an in-source build this is usually
+# harmless because $srcdir is '.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir. That would be:
+# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
+# and then we would define $MISSING as
+# MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH. The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN([AM_AUX_DIR_EXPAND],
+[dnl Rely on autoconf to set up CDPATH properly.
+AC_PREREQ([2.50])dnl
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+])
+
+# AM_CONDITIONAL -*- Autoconf -*-
+
+# Copyright (C) 1997-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN([AM_CONDITIONAL],
+[AC_PREREQ([2.52])dnl
+ m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])],
+ [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
+AC_SUBST([$1_TRUE])dnl
+AC_SUBST([$1_FALSE])dnl
+_AM_SUBST_NOTMAKE([$1_TRUE])dnl
+_AM_SUBST_NOTMAKE([$1_FALSE])dnl
+m4_define([_AM_COND_VALUE_$1], [$2])dnl
+if $2; then
+ $1_TRUE=
+ $1_FALSE='#'
+else
+ $1_TRUE='#'
+ $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+ AC_MSG_ERROR([[conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.]])
+fi])])
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
+# written in clear, in which case automake, when reading aclocal.m4,
+# will think it sees a *use*, and therefore will trigger all it's
+# C support machinery. Also note that it means that autoscan, seeing
+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
+
+
+# _AM_DEPENDENCIES(NAME)
+# ----------------------
+# See how the compiler implements dependency checking.
+# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
+# We try a few techniques and use that to set a single cache variable.
+#
+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
+# dependency, and given that the user is not expected to run this macro,
+# just rely on AC_PROG_CC.
+AC_DEFUN([_AM_DEPENDENCIES],
+[AC_REQUIRE([AM_SET_DEPDIR])dnl
+AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
+AC_REQUIRE([AM_MAKE_INCLUDE])dnl
+AC_REQUIRE([AM_DEP_TRACK])dnl
+
+m4_if([$1], [CC], [depcc="$CC" am_compiler_list=],
+ [$1], [CXX], [depcc="$CXX" am_compiler_list=],
+ [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+ [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
+ [$1], [UPC], [depcc="$UPC" am_compiler_list=],
+ [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'],
+ [depcc="$$1" am_compiler_list=])
+
+AC_CACHE_CHECK([dependency style of $depcc],
+ [am_cv_$1_dependencies_compiler_type],
+[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+ # We make a subdir and do the tests there. Otherwise we can end up
+ # making bogus files that we don't know about and never remove. For
+ # instance it was reported that on HP-UX the gcc test will end up
+ # making a dummy file named 'D' -- because '-MD' means "put the output
+ # in D".
+ rm -rf conftest.dir
+ mkdir conftest.dir
+ # Copy depcomp to subdir because otherwise we won't find it if we're
+ # using a relative directory.
+ cp "$am_depcomp" conftest.dir
+ cd conftest.dir
+ # We will build objects and dependencies in a subdirectory because
+ # it helps to detect inapplicable dependency modes. For instance
+ # both Tru64's cc and ICC support -MD to output dependencies as a
+ # side effect of compilation, but ICC will put the dependencies in
+ # the current directory while Tru64 will put them in the object
+ # directory.
+ mkdir sub
+
+ am_cv_$1_dependencies_compiler_type=none
+ if test "$am_compiler_list" = ""; then
+ am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
+ fi
+ am__universal=false
+ m4_case([$1], [CC],
+ [case " $depcc " in #(
+ *\ -arch\ *\ -arch\ *) am__universal=true ;;
+ esac],
+ [CXX],
+ [case " $depcc " in #(
+ *\ -arch\ *\ -arch\ *) am__universal=true ;;
+ esac])
+
+ for depmode in $am_compiler_list; do
+ # Setup a source with many dependencies, because some compilers
+ # like to wrap large dependency lists on column 80 (with \), and
+ # we should not choose a depcomp mode which is confused by this.
+ #
+ # We need to recreate these files for each test, as the compiler may
+ # overwrite some of them when testing with obscure command lines.
+ # This happens at least with the AIX C compiler.
+ : > sub/conftest.c
+ for i in 1 2 3 4 5 6; do
+ echo '#include "conftst'$i'.h"' >> sub/conftest.c
+ # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+ # Solaris 10 /bin/sh.
+ echo '/* dummy */' > sub/conftst$i.h
+ done
+ echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+ # We check with '-c' and '-o' for the sake of the "dashmstdout"
+ # mode. It turns out that the SunPro C++ compiler does not properly
+ # handle '-M -o', and we need to detect this. Also, some Intel
+ # versions had trouble with output in subdirs.
+ am__obj=sub/conftest.${OBJEXT-o}
+ am__minus_obj="-o $am__obj"
+ case $depmode in
+ gcc)
+ # This depmode causes a compiler race in universal mode.
+ test "$am__universal" = false || continue
+ ;;
+ nosideeffect)
+ # After this tag, mechanisms are not by side-effect, so they'll
+ # only be used when explicitly requested.
+ if test "x$enable_dependency_tracking" = xyes; then
+ continue
+ else
+ break
+ fi
+ ;;
+ msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+ # This compiler won't grok '-c -o', but also, the minuso test has
+ # not run yet. These depmodes are late enough in the game, and
+ # so weak that their functioning should not be impacted.
+ am__obj=conftest.${OBJEXT-o}
+ am__minus_obj=
+ ;;
+ none) break ;;
+ esac
+ if depmode=$depmode \
+ source=sub/conftest.c object=$am__obj \
+ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+ >/dev/null 2>conftest.err &&
+ grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+ grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+ grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+ ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+ # icc doesn't choke on unknown options, it will just issue warnings
+ # or remarks (even with -Werror). So we grep stderr for any message
+ # that says an option was ignored or not supported.
+ # When given -MP, icc 7.0 and 7.1 complain thusly:
+ # icc: Command line warning: ignoring option '-M'; no argument required
+ # The diagnosis changed in icc 8.0:
+ # icc: Command line remark: option '-MP' not supported
+ if (grep 'ignoring option' conftest.err ||
+ grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+ am_cv_$1_dependencies_compiler_type=$depmode
+ break
+ fi
+ fi
+ done
+
+ cd ..
+ rm -rf conftest.dir
+else
+ am_cv_$1_dependencies_compiler_type=none
+fi
+])
+AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
+AM_CONDITIONAL([am__fastdep$1], [
+ test "x$enable_dependency_tracking" != xno \
+ && test "$am_cv_$1_dependencies_compiler_type" = gcc3])
+])
+
+
+# AM_SET_DEPDIR
+# -------------
+# Choose a directory name for dependency files.
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
+AC_DEFUN([AM_SET_DEPDIR],
+[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
+])
+
+
+# AM_DEP_TRACK
+# ------------
+AC_DEFUN([AM_DEP_TRACK],
+[AC_ARG_ENABLE([dependency-tracking], [dnl
+AS_HELP_STRING(
+ [--enable-dependency-tracking],
+ [do not reject slow dependency extractors])
+AS_HELP_STRING(
+ [--disable-dependency-tracking],
+ [speeds up one-time build])])
+if test "x$enable_dependency_tracking" != xno; then
+ am_depcomp="$ac_aux_dir/depcomp"
+ AMDEPBACKSLASH='\'
+ am__nodep='_no'
+fi
+AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
+AC_SUBST([AMDEPBACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
+AC_SUBST([am__nodep])dnl
+_AM_SUBST_NOTMAKE([am__nodep])dnl
+])
+
+# Generate code to set up dependency tracking. -*- Autoconf -*-
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# _AM_OUTPUT_DEPENDENCY_COMMANDS
+# ------------------------------
+AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
+[{
+ # Older Autoconf quotes --file arguments for eval, but not when files
+ # are listed without --file. Let's play safe and only enable the eval
+ # if we detect the quoting.
+ case $CONFIG_FILES in
+ *\'*) eval set x "$CONFIG_FILES" ;;
+ *) set x $CONFIG_FILES ;;
+ esac
+ shift
+ for mf
+ do
+ # Strip MF so we end up with the name of the file.
+ mf=`echo "$mf" | sed -e 's/:.*$//'`
+ # Check whether this is an Automake generated Makefile or not.
+ # We used to match only the files named 'Makefile.in', but
+ # some people rename them; so instead we look at the file content.
+ # Grep'ing the first line is not enough: some people post-process
+ # each Makefile.in and add a new line on top of each file to say so.
+ # Grep'ing the whole file is not good either: AIX grep has a line
+ # limit of 2048, but all sed's we know have understand at least 4000.
+ if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
+ dirpart=`AS_DIRNAME("$mf")`
+ else
+ continue
+ fi
+ # Extract the definition of DEPDIR, am__include, and am__quote
+ # from the Makefile without running 'make'.
+ DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+ test -z "$DEPDIR" && continue
+ am__include=`sed -n 's/^am__include = //p' < "$mf"`
+ test -z "$am__include" && continue
+ am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+ # Find all dependency output files, they are included files with
+ # $(DEPDIR) in their names. We invoke sed twice because it is the
+ # simplest approach to changing $(DEPDIR) to its actual value in the
+ # expansion.
+ for file in `sed -n "
+ s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
+ # Make sure the directory exists.
+ test -f "$dirpart/$file" && continue
+ fdir=`AS_DIRNAME(["$file"])`
+ AS_MKDIR_P([$dirpart/$fdir])
+ # echo "creating $dirpart/$file"
+ echo '# dummy' > "$dirpart/$file"
+ done
+ done
+}
+])# _AM_OUTPUT_DEPENDENCY_COMMANDS
+
+
+# AM_OUTPUT_DEPENDENCY_COMMANDS
+# -----------------------------
+# This macro should only be invoked once -- use via AC_REQUIRE.
+#
+# This code is only required when automatic dependency tracking
+# is enabled. FIXME. This creates each '.P' file that we will
+# need in order to bootstrap the dependency handling code.
+AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
+[AC_CONFIG_COMMANDS([depfiles],
+ [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
+ [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
+])
+
+# Do all the work for Automake. -*- Autoconf -*-
+
+# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This macro actually does too much. Some checks are only needed if
+# your package does certain things. But this isn't really a big deal.
+
+dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
+m4_define([AC_PROG_CC],
+m4_defn([AC_PROG_CC])
+[_AM_PROG_CC_C_O
+])
+
+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
+# AM_INIT_AUTOMAKE([OPTIONS])
+# -----------------------------------------------
+# The call with PACKAGE and VERSION arguments is the old style
+# call (pre autoconf-2.50), which is being phased out. PACKAGE
+# and VERSION should now be passed to AC_INIT and removed from
+# the call to AM_INIT_AUTOMAKE.
+# We support both call styles for the transition. After
+# the next Automake release, Autoconf can make the AC_INIT
+# arguments mandatory, and then we can depend on a new Autoconf
+# release and drop the old call support.
+AC_DEFUN([AM_INIT_AUTOMAKE],
+[AC_PREREQ([2.65])dnl
+dnl Autoconf wants to disallow AM_ names. We explicitly allow
+dnl the ones we care about.
+m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
+AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
+AC_REQUIRE([AC_PROG_INSTALL])dnl
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+ # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+ # is not polluted with repeated "-I."
+ AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
+ # test to see if srcdir already configured
+ if test -f $srcdir/config.status; then
+ AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+ fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+ if (cygpath --version) >/dev/null 2>/dev/null; then
+ CYGPATH_W='cygpath -w'
+ else
+ CYGPATH_W=echo
+ fi
+fi
+AC_SUBST([CYGPATH_W])
+
+# Define the identity of the package.
+dnl Distinguish between old-style and new-style calls.
+m4_ifval([$2],
+[AC_DIAGNOSE([obsolete],
+ [$0: two- and three-arguments forms are deprecated.])
+m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
+ AC_SUBST([PACKAGE], [$1])dnl
+ AC_SUBST([VERSION], [$2])],
+[_AM_SET_OPTIONS([$1])dnl
+dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
+m4_if(
+ m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
+ [ok:ok],,
+ [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
+ AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
+ AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
+
+_AM_IF_OPTION([no-define],,
+[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
+ AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
+
+# Some tools Automake needs.
+AC_REQUIRE([AM_SANITY_CHECK])dnl
+AC_REQUIRE([AC_ARG_PROGRAM])dnl
+AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
+AM_MISSING_PROG([AUTOCONF], [autoconf])
+AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
+AM_MISSING_PROG([AUTOHEADER], [autoheader])
+AM_MISSING_PROG([MAKEINFO], [makeinfo])
+AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
+AC_REQUIRE([AC_PROG_MKDIR_P])dnl
+# For better backward compatibility. To be removed once Automake 1.9.x
+# dies out for good. For more background, see:
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
+# We need awk for the "check" target. The system "awk" is bad on
+# some platforms.
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([AC_PROG_MAKE_SET])dnl
+AC_REQUIRE([AM_SET_LEADING_DOT])dnl
+_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
+ [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
+ [_AM_PROG_TAR([v7])])])
+_AM_IF_OPTION([no-dependencies],,
+[AC_PROVIDE_IFELSE([AC_PROG_CC],
+ [_AM_DEPENDENCIES([CC])],
+ [m4_define([AC_PROG_CC],
+ m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_CXX],
+ [_AM_DEPENDENCIES([CXX])],
+ [m4_define([AC_PROG_CXX],
+ m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJC],
+ [_AM_DEPENDENCIES([OBJC])],
+ [m4_define([AC_PROG_OBJC],
+ m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
+ [_AM_DEPENDENCIES([OBJCXX])],
+ [m4_define([AC_PROG_OBJCXX],
+ m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
+])
+AC_REQUIRE([AM_SILENT_RULES])dnl
+dnl The testsuite driver may need to know about EXEEXT, so add the
+dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This
+dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
+AC_CONFIG_COMMANDS_PRE(dnl
+[m4_provide_if([_AM_COMPILER_EXEEXT],
+ [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes. So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+ cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present. This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+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: <http://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+ AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
+ fi
+fi])
+
+dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not
+dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
+dnl mangled by Autoconf and run in a shell conditional statement.
+m4_define([_AC_COMPILER_EXEEXT],
+m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
+
+# When config.status generates a header, we must update the stamp-h file.
+# This file resides in the same directory as the config header
+# that is generated. The stamp files are numbered to have different names.
+
+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
+# loop where config.status creates the headers, so we can generate
+# our stamp files there.
+AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
+[# Compute $1's index in $config_headers.
+_am_arg=$1
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+ case $_am_header in
+ $_am_arg | $_am_arg:* )
+ break ;;
+ * )
+ _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+ esac
+done
+echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
+
+# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_SH
+# ------------------
+# Define $install_sh.
+AC_DEFUN([AM_PROG_INSTALL_SH],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+if test x"${install_sh}" != xset; then
+ case $am_aux_dir in
+ *\ * | *\ *)
+ install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+ *)
+ install_sh="\${SHELL} $am_aux_dir/install-sh"
+ esac
+fi
+AC_SUBST([install_sh])])
+
+# Copyright (C) 2003-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# Check whether the underlying file-system supports filenames
+# with a leading dot. For instance MS-DOS doesn't.
+AC_DEFUN([AM_SET_LEADING_DOT],
+[rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+ am__leading_dot=.
+else
+ am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+AC_SUBST([am__leading_dot])])
+
+# Check to see how 'make' treats includes. -*- Autoconf -*-
+
+# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MAKE_INCLUDE()
+# -----------------
+# Check to see how make treats includes.
+AC_DEFUN([AM_MAKE_INCLUDE],
+[am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+ @echo this is the am__doit target
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+AC_MSG_CHECKING([for style of include used by $am_make])
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# Ignore all kinds of additional output from 'make'.
+case `$am_make -s -f confmf 2> /dev/null` in #(
+*the\ am__doit\ target*)
+ am__include=include
+ am__quote=
+ _am_result=GNU
+ ;;
+esac
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+ echo '.include "confinc"' > confmf
+ case `$am_make -s -f confmf 2> /dev/null` in #(
+ *the\ am__doit\ target*)
+ am__include=.include
+ am__quote="\""
+ _am_result=BSD
+ ;;
+ esac
+fi
+AC_SUBST([am__include])
+AC_SUBST([am__quote])
+AC_MSG_RESULT([$_am_result])
+rm -f confinc confmf
+])
+
+# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*-
+
+# Copyright (C) 1997-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MISSING_PROG(NAME, PROGRAM)
+# ------------------------------
+AC_DEFUN([AM_MISSING_PROG],
+[AC_REQUIRE([AM_MISSING_HAS_RUN])
+$1=${$1-"${am_missing_run}$2"}
+AC_SUBST($1)])
+
+# AM_MISSING_HAS_RUN
+# ------------------
+# Define MISSING if not defined so far and test if it is modern enough.
+# If it is, set am_missing_run to use it, otherwise, to nothing.
+AC_DEFUN([AM_MISSING_HAS_RUN],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([missing])dnl
+if test x"${MISSING+set}" != xset; then
+ case $am_aux_dir in
+ *\ * | *\ *)
+ MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+ *)
+ MISSING="\${SHELL} $am_aux_dir/missing" ;;
+ esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+ am_missing_run="$MISSING "
+else
+ am_missing_run=
+ AC_MSG_WARN(['missing' script is too old or missing])
+fi
+])
+
+# Helper functions for option handling. -*- Autoconf -*-
+
+# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_MANGLE_OPTION(NAME)
+# -----------------------
+AC_DEFUN([_AM_MANGLE_OPTION],
+[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
+
+# _AM_SET_OPTION(NAME)
+# --------------------
+# Set option NAME. Presently that only means defining a flag for this option.
+AC_DEFUN([_AM_SET_OPTION],
+[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
+
+# _AM_SET_OPTIONS(OPTIONS)
+# ------------------------
+# OPTIONS is a space-separated list of Automake options.
+AC_DEFUN([_AM_SET_OPTIONS],
+[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
+
+# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+AC_DEFUN([_AM_IF_OPTION],
+[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_CC_C_O
+# ---------------
+# Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC
+# to automatically call this.
+AC_DEFUN([_AM_PROG_CC_C_O],
+[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([compile])dnl
+AC_LANG_PUSH([C])dnl
+AC_CACHE_CHECK(
+ [whether $CC understands -c and -o together],
+ [am_cv_prog_cc_c_o],
+ [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
+ # Make sure it works both with $CC and with simple cc.
+ # Following AC_PROG_CC_C_O, we do the test twice because some
+ # compilers refuse to overwrite an existing .o file with -o,
+ # though they will create one.
+ am_cv_prog_cc_c_o=yes
+ for am_i in 1 2; do
+ if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
+ && test -f conftest2.$ac_objext; then
+ : OK
+ else
+ am_cv_prog_cc_c_o=no
+ break
+ fi
+ done
+ rm -f core conftest*
+ unset am_i])
+if test "$am_cv_prog_cc_c_o" != yes; then
+ # Losing compiler, so override with the script.
+ # FIXME: It is wrong to rewrite CC.
+ # But if we don't then we get into trouble of one sort or another.
+ # A longer-term fix would be to have automake use am__CC in this case,
+ # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+ CC="$am_aux_dir/compile $CC"
+fi
+AC_LANG_POP([C])])
+
+# For backward compatibility.
+AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# AM_PATH_PYTHON([MINIMUM-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# ---------------------------------------------------------------------------
+# Adds support for distributing Python modules and packages. To
+# install modules, copy them to $(pythondir), using the python_PYTHON
+# automake variable. To install a package with the same name as the
+# automake package, install to $(pkgpythondir), or use the
+# pkgpython_PYTHON automake variable.
+#
+# The variables $(pyexecdir) and $(pkgpyexecdir) are provided as
+# locations to install python extension modules (shared libraries).
+# Another macro is required to find the appropriate flags to compile
+# extension modules.
+#
+# If your package is configured with a different prefix to python,
+# users will have to add the install directory to the PYTHONPATH
+# environment variable, or create a .pth file (see the python
+# documentation for details).
+#
+# If the MINIMUM-VERSION argument is passed, AM_PATH_PYTHON will
+# cause an error if the version of python installed on the system
+# doesn't meet the requirement. MINIMUM-VERSION should consist of
+# numbers and dots only.
+AC_DEFUN([AM_PATH_PYTHON],
+ [
+ dnl Find a Python interpreter. Python versions prior to 2.0 are not
+ dnl supported. (2.0 was released on October 16, 2000).
+ m4_define_default([_AM_PYTHON_INTERPRETER_LIST],
+[python python2 python3 python3.3 python3.2 python3.1 python3.0 python2.7 dnl
+ python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0])
+
+ AC_ARG_VAR([PYTHON], [the Python interpreter])
+
+ m4_if([$1],[],[
+ dnl No version check is needed.
+ # Find any Python interpreter.
+ if test -z "$PYTHON"; then
+ AC_PATH_PROGS([PYTHON], _AM_PYTHON_INTERPRETER_LIST, :)
+ fi
+ am_display_PYTHON=python
+ ], [
+ dnl A version check is needed.
+ if test -n "$PYTHON"; then
+ # If the user set $PYTHON, use it and don't search something else.
+ AC_MSG_CHECKING([whether $PYTHON version is >= $1])
+ AM_PYTHON_CHECK_VERSION([$PYTHON], [$1],
+ [AC_MSG_RESULT([yes])],
+ [AC_MSG_RESULT([no])
+ AC_MSG_ERROR([Python interpreter is too old])])
+ am_display_PYTHON=$PYTHON
+ else
+ # Otherwise, try each interpreter until we find one that satisfies
+ # VERSION.
+ AC_CACHE_CHECK([for a Python interpreter with version >= $1],
+ [am_cv_pathless_PYTHON],[
+ for am_cv_pathless_PYTHON in _AM_PYTHON_INTERPRETER_LIST none; do
+ test "$am_cv_pathless_PYTHON" = none && break
+ AM_PYTHON_CHECK_VERSION([$am_cv_pathless_PYTHON], [$1], [break])
+ done])
+ # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON.
+ if test "$am_cv_pathless_PYTHON" = none; then
+ PYTHON=:
+ else
+ AC_PATH_PROG([PYTHON], [$am_cv_pathless_PYTHON])
+ fi
+ am_display_PYTHON=$am_cv_pathless_PYTHON
+ fi
+ ])
+
+ if test "$PYTHON" = :; then
+ dnl Run any user-specified action, or abort.
+ m4_default([$3], [AC_MSG_ERROR([no suitable Python interpreter found])])
+ else
+
+ dnl Query Python for its version number. Getting [:3] seems to be
+ dnl the best way to do this; it's what "site.py" does in the standard
+ dnl library.
+
+ AC_CACHE_CHECK([for $am_display_PYTHON version], [am_cv_python_version],
+ [am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[[:3]])"`])
+ AC_SUBST([PYTHON_VERSION], [$am_cv_python_version])
+
+ dnl Use the values of $prefix and $exec_prefix for the corresponding
+ dnl values of PYTHON_PREFIX and PYTHON_EXEC_PREFIX. These are made
+ dnl distinct variables so they can be overridden if need be. However,
+ dnl general consensus is that you shouldn't need this ability.
+
+ AC_SUBST([PYTHON_PREFIX], ['${prefix}'])
+ AC_SUBST([PYTHON_EXEC_PREFIX], ['${exec_prefix}'])
+
+ dnl At times (like when building shared libraries) you may want
+ dnl to know which OS platform Python thinks this is.
+
+ AC_CACHE_CHECK([for $am_display_PYTHON platform], [am_cv_python_platform],
+ [am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`])
+ AC_SUBST([PYTHON_PLATFORM], [$am_cv_python_platform])
+
+ # Just factor out some code duplication.
+ am_python_setup_sysconfig="\
+import sys
+# Prefer sysconfig over distutils.sysconfig, for better compatibility
+# with python 3.x. See automake bug#10227.
+try:
+ import sysconfig
+except ImportError:
+ can_use_sysconfig = 0
+else:
+ can_use_sysconfig = 1
+# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs:
+# <https://github.com/pypa/virtualenv/issues/118>
+try:
+ from platform import python_implementation
+ if python_implementation() == 'CPython' and sys.version[[:3]] == '2.7':
+ can_use_sysconfig = 0
+except ImportError:
+ pass"
+
+ dnl Set up 4 directories:
+
+ dnl pythondir -- where to install python scripts. This is the
+ dnl site-packages directory, not the python standard library
+ dnl directory like in previous automake betas. This behavior
+ dnl is more consistent with lispdir.m4 for example.
+ dnl Query distutils for this directory.
+ AC_CACHE_CHECK([for $am_display_PYTHON script directory],
+ [am_cv_python_pythondir],
+ [if test "x$prefix" = xNONE
+ then
+ am_py_prefix=$ac_default_prefix
+ else
+ am_py_prefix=$prefix
+ fi
+ am_cv_python_pythondir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+ sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'})
+else:
+ from distutils import sysconfig
+ sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+ case $am_cv_python_pythondir in
+ $am_py_prefix*)
+ am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'`
+ am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"`
+ ;;
+ *)
+ case $am_py_prefix in
+ /usr|/System*) ;;
+ *)
+ am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages
+ ;;
+ esac
+ ;;
+ esac
+ ])
+ AC_SUBST([pythondir], [$am_cv_python_pythondir])
+
+ dnl pkgpythondir -- $PACKAGE directory under pythondir. Was
+ dnl PYTHON_SITE_PACKAGE in previous betas, but this naming is
+ dnl more consistent with the rest of automake.
+
+ AC_SUBST([pkgpythondir], [\${pythondir}/$PACKAGE])
+
+ dnl pyexecdir -- directory for installing python extension modules
+ dnl (shared libraries)
+ dnl Query distutils for this directory.
+ AC_CACHE_CHECK([for $am_display_PYTHON extension module directory],
+ [am_cv_python_pyexecdir],
+ [if test "x$exec_prefix" = xNONE
+ then
+ am_py_exec_prefix=$am_py_prefix
+ else
+ am_py_exec_prefix=$exec_prefix
+ fi
+ am_cv_python_pyexecdir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+ sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'})
+else:
+ from distutils import sysconfig
+ sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+ case $am_cv_python_pyexecdir in
+ $am_py_exec_prefix*)
+ am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'`
+ am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"`
+ ;;
+ *)
+ case $am_py_exec_prefix in
+ /usr|/System*) ;;
+ *)
+ am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages
+ ;;
+ esac
+ ;;
+ esac
+ ])
+ AC_SUBST([pyexecdir], [$am_cv_python_pyexecdir])
+
+ dnl pkgpyexecdir -- $(pyexecdir)/$(PACKAGE)
+
+ AC_SUBST([pkgpyexecdir], [\${pyexecdir}/$PACKAGE])
+
+ dnl Run any user-specified action.
+ $2
+ fi
+
+])
+
+
+# AM_PYTHON_CHECK_VERSION(PROG, VERSION, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+# ---------------------------------------------------------------------------
+# Run ACTION-IF-TRUE if the Python interpreter PROG has version >= VERSION.
+# Run ACTION-IF-FALSE otherwise.
+# This test uses sys.hexversion instead of the string equivalent (first
+# word of sys.version), in order to cope with versions such as 2.2c1.
+# This supports Python 2.0 or higher. (2.0 was released on October 16, 2000).
+AC_DEFUN([AM_PYTHON_CHECK_VERSION],
+ [prog="import sys
+# split strings by '.' and convert to numeric. Append some zeros
+# because we need at least 4 digits for the hex conversion.
+# map returns an iterator in Python 3.0 and a list in 2.x
+minver = list(map(int, '$2'.split('.'))) + [[0, 0, 0]]
+minverhex = 0
+# xrange is not present in Python 3.0 and range returns an iterator
+for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[[i]]
+sys.exit(sys.hexversion < minverhex)"
+ AS_IF([AM_RUN_LOG([$1 -c "$prog"])], [$3], [$4])])
+
+# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_RUN_LOG(COMMAND)
+# -------------------
+# Run COMMAND, save the exit status in ac_status, and log it.
+# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
+AC_DEFUN([AM_RUN_LOG],
+[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
+ ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+ (exit $ac_status); }])
+
+# Check to make sure that the build environment is sane. -*- Autoconf -*-
+
+# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SANITY_CHECK
+# ---------------
+AC_DEFUN([AM_SANITY_CHECK],
+[AC_MSG_CHECKING([whether build environment is sane])
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name. Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+ *[[\\\"\#\$\&\'\`$am_lf]]*)
+ AC_MSG_ERROR([unsafe absolute working directory name]);;
+esac
+case $srcdir in
+ *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*)
+ AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments. Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+ am_has_slept=no
+ for am_try in 1 2; do
+ echo "timestamp, slept: $am_has_slept" > conftest.file
+ set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+ if test "$[*]" = "X"; then
+ # -L didn't work.
+ set X `ls -t "$srcdir/configure" conftest.file`
+ fi
+ if test "$[*]" != "X $srcdir/configure conftest.file" \
+ && test "$[*]" != "X conftest.file $srcdir/configure"; then
+
+ # If neither matched, then we have a broken ls. This can happen
+ # if, for instance, CONFIG_SHELL is bash and it inherits a
+ # broken ls alias from the environment. This has actually
+ # happened. Such a system could not be considered "sane".
+ AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
+ alias in your environment])
+ fi
+ if test "$[2]" = conftest.file || test $am_try -eq 2; then
+ break
+ fi
+ # Just in case.
+ sleep 1
+ am_has_slept=yes
+ done
+ test "$[2]" = conftest.file
+ )
+then
+ # Ok.
+ :
+else
+ AC_MSG_ERROR([newly created file is older than distributed files!
+Check your system clock])
+fi
+AC_MSG_RESULT([yes])
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+ ( sleep 1 ) &
+ am_sleep_pid=$!
+fi
+AC_CONFIG_COMMANDS_PRE(
+ [AC_MSG_CHECKING([that generated files are newer than configure])
+ if test -n "$am_sleep_pid"; then
+ # Hide warnings about reused PIDs.
+ wait $am_sleep_pid 2>/dev/null
+ fi
+ AC_MSG_RESULT([done])])
+rm -f conftest.file
+])
+
+# Copyright (C) 2009-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SILENT_RULES([DEFAULT])
+# --------------------------
+# Enable less verbose build rules; with the default set to DEFAULT
+# ("yes" being less verbose, "no" or empty being verbose).
+AC_DEFUN([AM_SILENT_RULES],
+[AC_ARG_ENABLE([silent-rules], [dnl
+AS_HELP_STRING(
+ [--enable-silent-rules],
+ [less verbose build output (undo: "make V=1")])
+AS_HELP_STRING(
+ [--disable-silent-rules],
+ [verbose build output (undo: "make V=0")])dnl
+])
+case $enable_silent_rules in @%:@ (((
+ yes) AM_DEFAULT_VERBOSITY=0;;
+ no) AM_DEFAULT_VERBOSITY=1;;
+ *) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
+esac
+dnl
+dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
+dnl do not support nested variable expansions.
+dnl See automake bug#9928 and bug#10237.
+am_make=${MAKE-make}
+AC_CACHE_CHECK([whether $am_make supports nested variables],
+ [am_cv_make_support_nested_variables],
+ [if AS_ECHO([['TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+ @$(TRUE)
+.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
+ am_cv_make_support_nested_variables=yes
+else
+ am_cv_make_support_nested_variables=no
+fi])
+if test $am_cv_make_support_nested_variables = yes; then
+ dnl Using '$V' instead of '$(V)' breaks IRIX make.
+ AM_V='$(V)'
+ AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+ AM_V=$AM_DEFAULT_VERBOSITY
+ AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AC_SUBST([AM_V])dnl
+AM_SUBST_NOTMAKE([AM_V])dnl
+AC_SUBST([AM_DEFAULT_V])dnl
+AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
+AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
+AM_BACKSLASH='\'
+AC_SUBST([AM_BACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
+])
+
+# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_STRIP
+# ---------------------
+# One issue with vendor 'install' (even GNU) is that you can't
+# specify the program used to strip binaries. This is especially
+# annoying in cross-compiling environments, where the build's strip
+# is unlikely to handle the host's binaries.
+# Fortunately install-sh will honor a STRIPPROG variable, so we
+# always use install-sh in "make install-strip", and initialize
+# STRIPPROG with the value of the STRIP variable (set by the user).
+AC_DEFUN([AM_PROG_INSTALL_STRIP],
+[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip". However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
+if test "$cross_compiling" != no; then
+ AC_CHECK_TOOL([STRIP], [strip], :)
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+AC_SUBST([INSTALL_STRIP_PROGRAM])])
+
+# Copyright (C) 2006-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_SUBST_NOTMAKE(VARIABLE)
+# ---------------------------
+# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
+# This macro is traced by Automake.
+AC_DEFUN([_AM_SUBST_NOTMAKE])
+
+# AM_SUBST_NOTMAKE(VARIABLE)
+# --------------------------
+# Public sister of _AM_SUBST_NOTMAKE.
+AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
+
+# Check how to create a tarball. -*- Autoconf -*-
+
+# Copyright (C) 2004-2013 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_TAR(FORMAT)
+# --------------------
+# Check how to create a tarball in format FORMAT.
+# FORMAT should be one of 'v7', 'ustar', or 'pax'.
+#
+# Substitute a variable $(am__tar) that is a command
+# writing to stdout a FORMAT-tarball containing the directory
+# $tardir.
+# tardir=directory && $(am__tar) > result.tar
+#
+# Substitute a variable $(am__untar) that extract such
+# a tarball read from stdin.
+# $(am__untar) < result.tar
+#
+AC_DEFUN([_AM_PROG_TAR],
+[# Always define AMTAR for backward compatibility. Yes, it's still used
+# in the wild :-( We should find a proper way to deprecate it ...
+AC_SUBST([AMTAR], ['$${TAR-tar}'])
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
+
+m4_if([$1], [v7],
+ [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
+
+ [m4_case([$1],
+ [ustar],
+ [# The POSIX 1988 'ustar' format is defined with fixed-size fields.
+ # There is notably a 21 bits limit for the UID and the GID. In fact,
+ # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
+ # and bug#13588).
+ am_max_uid=2097151 # 2^21 - 1
+ am_max_gid=$am_max_uid
+ # The $UID and $GID variables are not portable, so we need to resort
+ # to the POSIX-mandated id(1) utility. Errors in the 'id' calls
+ # below are definitely unexpected, so allow the users to see them
+ # (that is, avoid stderr redirection).
+ am_uid=`id -u || echo unknown`
+ am_gid=`id -g || echo unknown`
+ AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
+ if test $am_uid -le $am_max_uid; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ _am_tools=none
+ fi
+ AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
+ if test $am_gid -le $am_max_gid; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ _am_tools=none
+ fi],
+
+ [pax],
+ [],
+
+ [m4_fatal([Unknown tar format])])
+
+ AC_MSG_CHECKING([how to create a $1 tar archive])
+
+ # Go ahead even if we have the value already cached. We do so because we
+ # need to set the values for the 'am__tar' and 'am__untar' variables.
+ _am_tools=${am_cv_prog_tar_$1-$_am_tools}
+
+ for _am_tool in $_am_tools; do
+ case $_am_tool in
+ gnutar)
+ for _am_tar in tar gnutar gtar; do
+ AM_RUN_LOG([$_am_tar --version]) && break
+ done
+ am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
+ am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
+ am__untar="$_am_tar -xf -"
+ ;;
+ plaintar)
+ # Must skip GNU tar: if it does not support --format= it doesn't create
+ # ustar tarball either.
+ (tar --version) >/dev/null 2>&1 && continue
+ am__tar='tar chf - "$$tardir"'
+ am__tar_='tar chf - "$tardir"'
+ am__untar='tar xf -'
+ ;;
+ pax)
+ am__tar='pax -L -x $1 -w "$$tardir"'
+ am__tar_='pax -L -x $1 -w "$tardir"'
+ am__untar='pax -r'
+ ;;
+ cpio)
+ am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+ am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+ am__untar='cpio -i -H $1 -d'
+ ;;
+ none)
+ am__tar=false
+ am__tar_=false
+ am__untar=false
+ ;;
+ esac
+
+ # If the value was cached, stop now. We just wanted to have am__tar
+ # and am__untar set.
+ test -n "${am_cv_prog_tar_$1}" && break
+
+ # tar/untar a dummy directory, and stop if the command works.
+ rm -rf conftest.dir
+ mkdir conftest.dir
+ echo GrepMe > conftest.dir/file
+ AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
+ rm -rf conftest.dir
+ if test -s conftest.tar; then
+ AM_RUN_LOG([$am__untar <conftest.tar])
+ AM_RUN_LOG([cat conftest.dir/file])
+ grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+ fi
+ done
+ rm -rf conftest.dir
+
+ AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
+ AC_MSG_RESULT([$am_cv_prog_tar_$1])])
+
+AC_SUBST([am__tar])
+AC_SUBST([am__untar])
+]) # _AM_PROG_TAR
+
+m4_include([m4/ac_python_devel.m4])
+m4_include([m4/libtool.m4])
+m4_include([m4/ltoptions.m4])
+m4_include([m4/ltsugar.m4])
+m4_include([m4/ltversion.m4])
+m4_include([m4/lt~obsolete.m4])
--- /dev/null
+#! /bin/sh
+# Wrapper for Microsoft lib.exe
+
+me=ar-lib
+scriptversion=2012-03-01.08; # UTC
+
+# Copyright (C) 2010-2013 Free Software Foundation, Inc.
+# Written by Peter Rosin <peda@lysator.liu.se>.
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+# 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 <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+
+# 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 <<EOF
+Usage: $me [--help] [--version] PROGRAM ACTION ARCHIVE [MEMBER...]
+
+Members may be specified in a file named with @FILE.
+EOF
+ exit $?
+ ;;
+ -v | --v*)
+ echo "$me, version $scriptversion"
+ exit $?
+ ;;
+esac
+
+if test $# -lt 3; then
+ func_error "you must specify a program, an action and an archive"
+fi
+
+AR=$1
+shift
+while :
+do
+ if test $# -lt 2; then
+ func_error "you must specify a program, an action and an archive"
+ fi
+ case $1 in
+ -lib | -LIB \
+ | -ltcg | -LTCG \
+ | -machine* | -MACHINE* \
+ | -subsystem* | -SUBSYSTEM* \
+ | -verbose | -VERBOSE \
+ | -wx* | -WX* )
+ AR="$AR $1"
+ shift
+ ;;
+ *)
+ action=$1
+ shift
+ break
+ ;;
+ esac
+done
+orig_archive=$1
+shift
+func_file_conv "$orig_archive"
+archive=$file
+
+# strip leading dash in $action
+action=${action#-}
+
+delete=
+extract=
+list=
+quick=
+replace=
+index=
+create=
+
+while test -n "$action"
+do
+ case $action in
+ d*) delete=yes ;;
+ x*) extract=yes ;;
+ t*) list=yes ;;
+ q*) quick=yes ;;
+ r*) replace=yes ;;
+ s*) index=yes ;;
+ S*) ;; # the index is always updated implicitly
+ c*) create=yes ;;
+ u*) ;; # TODO: don't ignore the update modifier
+ v*) ;; # TODO: don't ignore the verbose modifier
+ *)
+ func_error "unknown action specified"
+ ;;
+ esac
+ action=${action#?}
+done
+
+case $delete$extract$list$quick$replace,$index in
+ yes,* | ,yes)
+ ;;
+ yesyes*)
+ func_error "more than one action specified"
+ ;;
+ *)
+ func_error "no action specified"
+ ;;
+esac
+
+if test -n "$delete"; then
+ if test ! -f "$orig_archive"; then
+ func_error "archive not found"
+ fi
+ for member
+ do
+ case $1 in
+ @*)
+ func_at_file "${1#@}" -REMOVE "$archive"
+ ;;
+ *)
+ func_file_conv "$1"
+ $AR -NOLOGO -REMOVE:"$file" "$archive" || exit $?
+ ;;
+ esac
+ done
+
+elif test -n "$extract"; then
+ if test ! -f "$orig_archive"; then
+ func_error "archive not found"
+ fi
+ if test $# -gt 0; then
+ for member
+ do
+ case $1 in
+ @*)
+ func_at_file "${1#@}" -EXTRACT "$archive"
+ ;;
+ *)
+ func_file_conv "$1"
+ $AR -NOLOGO -EXTRACT:"$file" "$archive" || exit $?
+ ;;
+ esac
+ done
+ else
+ $AR -NOLOGO -LIST "$archive" | sed -e 's/\\/\\\\/g' | while read member
+ do
+ $AR -NOLOGO -EXTRACT:"$member" "$archive" || exit $?
+ done
+ fi
+
+elif test -n "$quick$replace"; then
+ if test ! -f "$orig_archive"; then
+ if test -z "$create"; then
+ echo "$me: creating $orig_archive"
+ fi
+ orig_archive=
+ else
+ orig_archive=$archive
+ fi
+
+ for member
+ do
+ case $1 in
+ @*)
+ func_file_conv "${1#@}"
+ set x "$@" "@$file"
+ ;;
+ *)
+ func_file_conv "$1"
+ set x "$@" "$file"
+ ;;
+ esac
+ shift
+ shift
+ done
+
+ if test -n "$orig_archive"; then
+ $AR -NOLOGO -OUT:"$archive" "$orig_archive" "$@" || exit $?
+ else
+ $AR -NOLOGO -OUT:"$archive" "$@" || exit $?
+ fi
+
+elif test -n "$list"; then
+ if test ! -f "$orig_archive"; then
+ func_error "archive not found"
+ fi
+ $AR -NOLOGO -LIST "$archive" || exit $?
+fi
--- /dev/null
+#! /bin/sh
+# Wrapper for compilers which do not understand '-c -o'.
+
+scriptversion=2012-10-14.11; # UTC
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Written by Tom Tromey <tromey@cygnus.com>.
+#
+# 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 <http://www.gnu.org/licenses/>.
+
+# 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 <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+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 <bug-automake@gnu.org>.
+EOF
+ exit $?
+ ;;
+ -v | --v*)
+ echo "compile $scriptversion"
+ exit $?
+ ;;
+ cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
+ func_cl_wrapper "$@" # Doesn't return...
+ ;;
+esac
+
+ofile=
+cfile=
+
+for arg
+do
+ if test -n "$eat"; then
+ eat=
+ else
+ case $1 in
+ -o)
+ # configure might choose to run compile as 'compile cc -o foo foo.c'.
+ # So we strip '-o arg' only if arg is an object.
+ eat=1
+ case $2 in
+ *.o | *.obj)
+ ofile=$2
+ ;;
+ *)
+ set x "$@" -o "$2"
+ shift
+ ;;
+ esac
+ ;;
+ *.c)
+ cfile=$1
+ set x "$@" "$1"
+ shift
+ ;;
+ *)
+ set x "$@" "$1"
+ shift
+ ;;
+ esac
+ fi
+ shift
+done
+
+if test -z "$ofile" || test -z "$cfile"; then
+ # If no '-o' option was seen then we might have been invoked from a
+ # pattern rule where we don't need one. That is ok -- this is a
+ # normal compilation that the losing compiler can handle. If no
+ # '.c' file was seen then we are probably linking. That is also
+ # ok.
+ exec "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
+
+# Create the lock directory.
+# Note: use '[/\\:.-]' here to ensure that we don't use the same name
+# that we are using for the .o file. Also, base the name on the expected
+# object file name, since that is what matters with a parallel build.
+lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
+while true; do
+ if mkdir "$lockdir" >/dev/null 2>&1; then
+ break
+ fi
+ sleep 1
+done
+# FIXME: race condition here if user kills between mkdir and trap.
+trap "rmdir '$lockdir'; exit 1" 1 2 15
+
+# Run the compile.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+ test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+ test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
--- /dev/null
+#! /bin/sh
+# Attempt to guess a canonical system name.
+# Copyright 1992-2013 Free Software Foundation, Inc.
+
+timestamp='2013-06-10'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program. This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+#
+# Originally written by Per Bothner.
+#
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+#
+# Please send patches with a ChangeLog entry to config-patches@gnu.org.
+
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+ -h, --help print this help, then exit
+ -t, --time-stamp print date of last modification, then exit
+ -v, --version print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright 1992-2013 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+ case $1 in
+ --time-stamp | --time* | -t )
+ echo "$timestamp" ; exit ;;
+ --version | -v )
+ echo "$version" ; exit ;;
+ --help | --h* | -h )
+ echo "$usage"; exit ;;
+ -- ) # Stop option processing
+ shift; break ;;
+ - ) # Use stdin as input.
+ break ;;
+ -* )
+ echo "$me: invalid option $1$help" >&2
+ exit 1 ;;
+ * )
+ break ;;
+ esac
+done
+
+if test $# != 0; then
+ echo "$me: too many arguments$help" >&2
+ exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,) echo "int x;" > $dummy.c ;
+ for c in cc gcc c89 c99 ; do
+ if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+ CC_FOR_BUILD="$c"; break ;
+ fi ;
+ done ;
+ if test x"$CC_FOR_BUILD" = x ; then
+ CC_FOR_BUILD=no_compiler_found ;
+ fi
+ ;;
+ ,,*) CC_FOR_BUILD=$CC ;;
+ ,*,*) CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+ PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+case "${UNAME_SYSTEM}" in
+Linux|GNU|GNU/*)
+ # If the system lacks a compiler, then just pick glibc.
+ # We could probably try harder.
+ LIBC=gnu
+
+ eval $set_cc_for_build
+ cat <<-EOF > $dummy.c
+ #include <features.h>
+ #if defined(__UCLIBC__)
+ LIBC=uclibc
+ #elif defined(__dietlibc__)
+ LIBC=dietlibc
+ #else
+ LIBC=gnu
+ #endif
+ EOF
+ eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
+ ;;
+esac
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+ *:NetBSD:*:*)
+ # NetBSD (nbsd) targets should (where applicable) match one or
+ # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
+ # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently
+ # switched to ELF, *-*-netbsd* would select the old
+ # object file format. This provides both forward
+ # compatibility and a consistent mechanism for selecting the
+ # object file format.
+ #
+ # Note: NetBSD doesn't particularly care about the vendor
+ # portion of the name. We always set it to "unknown".
+ sysctl="sysctl -n hw.machine_arch"
+ UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
+ /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
+ case "${UNAME_MACHINE_ARCH}" in
+ armeb) machine=armeb-unknown ;;
+ arm*) machine=arm-unknown ;;
+ sh3el) machine=shl-unknown ;;
+ sh3eb) machine=sh-unknown ;;
+ sh5el) machine=sh5le-unknown ;;
+ *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+ esac
+ # The Operating System including object format, if it has switched
+ # to ELF recently, or will in the future.
+ case "${UNAME_MACHINE_ARCH}" in
+ arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+ eval $set_cc_for_build
+ if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+ | grep -q __ELF__
+ then
+ # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+ # Return netbsd for either. FIX?
+ os=netbsd
+ else
+ os=netbsdelf
+ fi
+ ;;
+ *)
+ os=netbsd
+ ;;
+ esac
+ # The OS release
+ # Debian GNU/NetBSD machines have a different userland, and
+ # thus, need a distinct triplet. However, they do not need
+ # kernel version information, so it can be replaced with a
+ # suitable tag, in the style of linux-gnu.
+ case "${UNAME_VERSION}" in
+ Debian*)
+ release='-gnu'
+ ;;
+ *)
+ release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+ ;;
+ esac
+ # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+ # contains redundant information, the shorter form:
+ # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+ echo "${machine}-${os}${release}"
+ exit ;;
+ *:Bitrig:*:*)
+ UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+ echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
+ exit ;;
+ *:OpenBSD:*:*)
+ UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+ echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+ exit ;;
+ *:ekkoBSD:*:*)
+ echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+ exit ;;
+ *:SolidBSD:*:*)
+ echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+ exit ;;
+ macppc:MirBSD:*:*)
+ echo powerpc-unknown-mirbsd${UNAME_RELEASE}
+ exit ;;
+ *:MirBSD:*:*)
+ echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+ exit ;;
+ alpha:OSF1:*:*)
+ case $UNAME_RELEASE in
+ *4.0)
+ UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+ ;;
+ *5.*)
+ UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+ ;;
+ esac
+ # According to Compaq, /usr/sbin/psrinfo has been available on
+ # OSF/1 and Tru64 systems produced since 1995. I hope that
+ # covers most systems running today. This code pipes the CPU
+ # types through head -n 1, so we only detect the type of CPU 0.
+ ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+ case "$ALPHA_CPU_TYPE" in
+ "EV4 (21064)")
+ UNAME_MACHINE="alpha" ;;
+ "EV4.5 (21064)")
+ UNAME_MACHINE="alpha" ;;
+ "LCA4 (21066/21068)")
+ UNAME_MACHINE="alpha" ;;
+ "EV5 (21164)")
+ UNAME_MACHINE="alphaev5" ;;
+ "EV5.6 (21164A)")
+ UNAME_MACHINE="alphaev56" ;;
+ "EV5.6 (21164PC)")
+ UNAME_MACHINE="alphapca56" ;;
+ "EV5.7 (21164PC)")
+ UNAME_MACHINE="alphapca57" ;;
+ "EV6 (21264)")
+ UNAME_MACHINE="alphaev6" ;;
+ "EV6.7 (21264A)")
+ UNAME_MACHINE="alphaev67" ;;
+ "EV6.8CB (21264C)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.8AL (21264B)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.8CX (21264D)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.9A (21264/EV69A)")
+ UNAME_MACHINE="alphaev69" ;;
+ "EV7 (21364)")
+ UNAME_MACHINE="alphaev7" ;;
+ "EV7.9 (21364A)")
+ UNAME_MACHINE="alphaev79" ;;
+ esac
+ # A Pn.n version is a patched version.
+ # A Vn.n version is a released version.
+ # A Tn.n version is a released field test version.
+ # A Xn.n version is an unreleased experimental baselevel.
+ # 1.2 uses "1.2" for uname -r.
+ echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+ # Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+ exitcode=$?
+ trap '' 0
+ exit $exitcode ;;
+ Alpha\ *:Windows_NT*:*)
+ # How do we know it's Interix rather than the generic POSIX subsystem?
+ # Should we change UNAME_MACHINE based on the output of uname instead
+ # of the specific Alpha model?
+ echo alpha-pc-interix
+ exit ;;
+ 21064:Windows_NT:50:3)
+ echo alpha-dec-winnt3.5
+ exit ;;
+ Amiga*:UNIX_System_V:4.0:*)
+ echo m68k-unknown-sysv4
+ exit ;;
+ *:[Aa]miga[Oo][Ss]:*:*)
+ echo ${UNAME_MACHINE}-unknown-amigaos
+ exit ;;
+ *:[Mm]orph[Oo][Ss]:*:*)
+ echo ${UNAME_MACHINE}-unknown-morphos
+ exit ;;
+ *:OS/390:*:*)
+ echo i370-ibm-openedition
+ exit ;;
+ *:z/VM:*:*)
+ echo s390-ibm-zvmoe
+ exit ;;
+ *:OS400:*:*)
+ echo powerpc-ibm-os400
+ exit ;;
+ arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+ echo arm-acorn-riscix${UNAME_RELEASE}
+ exit ;;
+ arm*:riscos:*:*|arm*:RISCOS:*:*)
+ echo arm-unknown-riscos
+ exit ;;
+ SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+ echo hppa1.1-hitachi-hiuxmpp
+ exit ;;
+ Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+ # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+ if test "`(/bin/universe) 2>/dev/null`" = att ; then
+ echo pyramid-pyramid-sysv3
+ else
+ echo pyramid-pyramid-bsd
+ fi
+ exit ;;
+ NILE*:*:*:dcosx)
+ echo pyramid-pyramid-svr4
+ exit ;;
+ DRS?6000:unix:4.0:6*)
+ echo sparc-icl-nx6
+ exit ;;
+ DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+ case `/usr/bin/uname -p` in
+ sparc) echo sparc-icl-nx7; exit ;;
+ esac ;;
+ s390x:SunOS:*:*)
+ echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ sun4H:SunOS:5.*:*)
+ echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+ echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+ echo i386-pc-auroraux${UNAME_RELEASE}
+ exit ;;
+ i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+ eval $set_cc_for_build
+ SUN_ARCH="i386"
+ # If there is a compiler, see if it is configured for 64-bit objects.
+ # Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+ # This test works for both compilers.
+ if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+ if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+ grep IS_64BIT_ARCH >/dev/null
+ then
+ SUN_ARCH="x86_64"
+ fi
+ fi
+ echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ sun4*:SunOS:6*:*)
+ # According to config.sub, this is the proper way to canonicalize
+ # SunOS6. Hard to guess exactly what SunOS6 will be like, but
+ # it's likely to be more like Solaris than SunOS4.
+ echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ sun4*:SunOS:*:*)
+ case "`/usr/bin/arch -k`" in
+ Series*|S4*)
+ UNAME_RELEASE=`uname -v`
+ ;;
+ esac
+ # Japanese Language versions have a version number like `4.1.3-JL'.
+ echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+ exit ;;
+ sun3*:SunOS:*:*)
+ echo m68k-sun-sunos${UNAME_RELEASE}
+ exit ;;
+ sun*:*:4.2BSD:*)
+ UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+ test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+ case "`/bin/arch`" in
+ sun3)
+ echo m68k-sun-sunos${UNAME_RELEASE}
+ ;;
+ sun4)
+ echo sparc-sun-sunos${UNAME_RELEASE}
+ ;;
+ esac
+ exit ;;
+ aushp:SunOS:*:*)
+ echo sparc-auspex-sunos${UNAME_RELEASE}
+ exit ;;
+ # The situation for MiNT is a little confusing. The machine name
+ # can be virtually everything (everything which is not
+ # "atarist" or "atariste" at least should have a processor
+ # > m68000). The system name ranges from "MiNT" over "FreeMiNT"
+ # to the lowercase version "mint" (or "freemint"). Finally
+ # the system name "TOS" denotes a system which is actually not
+ # MiNT. But MiNT is downward compatible to TOS, so this should
+ # be no problem.
+ atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit ;;
+ atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit ;;
+ *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit ;;
+ milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+ echo m68k-milan-mint${UNAME_RELEASE}
+ exit ;;
+ hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+ echo m68k-hades-mint${UNAME_RELEASE}
+ exit ;;
+ *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+ echo m68k-unknown-mint${UNAME_RELEASE}
+ exit ;;
+ m68k:machten:*:*)
+ echo m68k-apple-machten${UNAME_RELEASE}
+ exit ;;
+ powerpc:machten:*:*)
+ echo powerpc-apple-machten${UNAME_RELEASE}
+ exit ;;
+ RISC*:Mach:*:*)
+ echo mips-dec-mach_bsd4.3
+ exit ;;
+ RISC*:ULTRIX:*:*)
+ echo mips-dec-ultrix${UNAME_RELEASE}
+ exit ;;
+ VAX*:ULTRIX*:*:*)
+ echo vax-dec-ultrix${UNAME_RELEASE}
+ exit ;;
+ 2020:CLIX:*:* | 2430:CLIX:*:*)
+ echo clipper-intergraph-clix${UNAME_RELEASE}
+ exit ;;
+ mips:*:*:UMIPS | mips:*:*:RISCos)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h> /* 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 <sys/systemcfg.h>
+
+ main()
+ {
+ if (!__power_pc())
+ exit(1);
+ puts("powerpc-ibm-aix3.2.5");
+ exit(0);
+ }
+EOF
+ if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+ then
+ echo "$SYSTEM_NAME"
+ else
+ echo rs6000-ibm-aix3.2.5
+ fi
+ elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+ echo rs6000-ibm-aix3.2.4
+ else
+ echo rs6000-ibm-aix3.2
+ fi
+ exit ;;
+ *:AIX:*:[4567])
+ IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+ if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+ IBM_ARCH=rs6000
+ else
+ IBM_ARCH=powerpc
+ fi
+ if [ -x /usr/bin/oslevel ] ; then
+ IBM_REV=`/usr/bin/oslevel`
+ else
+ IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+ fi
+ echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+ exit ;;
+ *:AIX:*:*)
+ echo rs6000-ibm-aix
+ exit ;;
+ ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+ echo romp-ibm-bsd4.4
+ exit ;;
+ ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and
+ echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to
+ exit ;; # report: romp-ibm BSD 4.3
+ *:BOSX:*:*)
+ echo rs6000-bull-bosx
+ exit ;;
+ DPX/2?00:B.O.S.:*:*)
+ echo m68k-bull-sysv3
+ exit ;;
+ 9000/[34]??:4.3bsd:1.*:*)
+ echo m68k-hp-bsd
+ exit ;;
+ hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+ echo m68k-hp-bsd4.4
+ exit ;;
+ 9000/[34678]??:HP-UX:*:*)
+ HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+ case "${UNAME_MACHINE}" in
+ 9000/31? ) HP_ARCH=m68000 ;;
+ 9000/[34]?? ) HP_ARCH=m68k ;;
+ 9000/[678][0-9][0-9])
+ if [ -x /usr/bin/getconf ]; then
+ sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+ sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+ case "${sc_cpu_version}" in
+ 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+ 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+ 532) # CPU_PA_RISC2_0
+ case "${sc_kernel_bits}" in
+ 32) HP_ARCH="hppa2.0n" ;;
+ 64) HP_ARCH="hppa2.0w" ;;
+ '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20
+ esac ;;
+ esac
+ fi
+ if [ "${HP_ARCH}" = "" ]; then
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+
+ #define _HPUX_SOURCE
+ #include <stdlib.h>
+ #include <unistd.h>
+
+ 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 <unistd.h>
+ int
+ main ()
+ {
+ long cpu = sysconf (_SC_CPU_VERSION);
+ /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+ true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct
+ results, however. */
+ if (CPU_IS_PA_RISC (cpu))
+ {
+ switch (cpu)
+ {
+ case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+ case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+ case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+ default: puts ("hppa-hitachi-hiuxwe2"); break;
+ }
+ }
+ else if (CPU_IS_HP_MC68K (cpu))
+ puts ("m68k-hitachi-hiuxwe2");
+ else puts ("unknown-hitachi-hiuxwe2");
+ exit (0);
+ }
+EOF
+ $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+ { echo "$SYSTEM_NAME"; exit; }
+ echo unknown-hitachi-hiuxwe2
+ exit ;;
+ 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+ echo hppa1.1-hp-bsd
+ exit ;;
+ 9000/8??:4.3bsd:*:*)
+ echo hppa1.0-hp-bsd
+ exit ;;
+ *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+ echo hppa1.0-hp-mpeix
+ exit ;;
+ hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+ echo hppa1.1-hp-osf
+ exit ;;
+ hp8??:OSF1:*:*)
+ echo hppa1.0-hp-osf
+ exit ;;
+ i*86:OSF1:*:*)
+ if [ -x /usr/sbin/sysversion ] ; then
+ echo ${UNAME_MACHINE}-unknown-osf1mk
+ else
+ echo ${UNAME_MACHINE}-unknown-osf1
+ fi
+ exit ;;
+ parisc*:Lites*:*:*)
+ echo hppa1.1-hp-lites
+ exit ;;
+ C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+ echo c1-convex-bsd
+ exit ;;
+ C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+ if getsysinfo -f scalar_acc
+ then echo c32-convex-bsd
+ else echo c2-convex-bsd
+ fi
+ exit ;;
+ C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+ echo c34-convex-bsd
+ exit ;;
+ C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+ echo c38-convex-bsd
+ exit ;;
+ C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+ echo c4-convex-bsd
+ exit ;;
+ CRAY*Y-MP:*:*:*)
+ echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*[A-Z]90:*:*:*)
+ echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+ -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*TS:*:*:*)
+ echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*T3E:*:*:*)
+ echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*SV1:*:*:*)
+ echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ *:UNICOS/mp:*:*)
+ echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+ FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+ FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+ FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+ echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+ exit ;;
+ 5000:UNIX_System_V:4.*:*)
+ FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+ FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
+ echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+ exit ;;
+ i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+ echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+ exit ;;
+ sparc*:BSD/OS:*:*)
+ echo sparc-unknown-bsdi${UNAME_RELEASE}
+ exit ;;
+ *:BSD/OS:*:*)
+ echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+ exit ;;
+ *:FreeBSD:*:*)
+ UNAME_PROCESSOR=`/usr/bin/uname -p`
+ case ${UNAME_PROCESSOR} in
+ amd64)
+ echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+ *)
+ echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+ esac
+ exit ;;
+ i*:CYGWIN*:*)
+ echo ${UNAME_MACHINE}-pc-cygwin
+ exit ;;
+ *:MINGW64*:*)
+ echo ${UNAME_MACHINE}-pc-mingw64
+ exit ;;
+ *:MINGW*:*)
+ echo ${UNAME_MACHINE}-pc-mingw32
+ exit ;;
+ i*:MSYS*:*)
+ echo ${UNAME_MACHINE}-pc-msys
+ exit ;;
+ i*:windows32*:*)
+ # uname -m includes "-pc" on this system.
+ echo ${UNAME_MACHINE}-mingw32
+ exit ;;
+ i*:PW*:*)
+ echo ${UNAME_MACHINE}-pc-pw32
+ exit ;;
+ *:Interix*:*)
+ case ${UNAME_MACHINE} in
+ x86)
+ echo i586-pc-interix${UNAME_RELEASE}
+ exit ;;
+ authenticamd | genuineintel | EM64T)
+ echo x86_64-unknown-interix${UNAME_RELEASE}
+ exit ;;
+ IA64)
+ echo ia64-unknown-interix${UNAME_RELEASE}
+ exit ;;
+ esac ;;
+ [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+ echo i${UNAME_MACHINE}-pc-mks
+ exit ;;
+ 8664:Windows_NT:*)
+ echo x86_64-pc-mks
+ exit ;;
+ i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+ # How do we know it's Interix rather than the generic POSIX subsystem?
+ # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+ # UNAME_MACHINE based on the output of uname instead of i386?
+ echo i586-pc-interix
+ exit ;;
+ i*:UWIN*:*)
+ echo ${UNAME_MACHINE}-pc-uwin
+ exit ;;
+ amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+ echo x86_64-unknown-cygwin
+ exit ;;
+ p*:CYGWIN*:*)
+ echo powerpcle-unknown-cygwin
+ exit ;;
+ prep*:SunOS:5.*:*)
+ echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ *:GNU:*:*)
+ # the GNU system
+ echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+ exit ;;
+ *:GNU/*:*:*)
+ # other systems with GNU libc and userland
+ echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
+ exit ;;
+ i*86:Minix:*:*)
+ echo ${UNAME_MACHINE}-pc-minix
+ exit ;;
+ aarch64:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ aarch64_be:Linux:*:*)
+ UNAME_MACHINE=aarch64_be
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ alpha:Linux:*:*)
+ case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+ EV5) UNAME_MACHINE=alphaev5 ;;
+ EV56) UNAME_MACHINE=alphaev56 ;;
+ PCA56) UNAME_MACHINE=alphapca56 ;;
+ PCA57) UNAME_MACHINE=alphapca56 ;;
+ EV6) UNAME_MACHINE=alphaev6 ;;
+ EV67) UNAME_MACHINE=alphaev67 ;;
+ EV68*) UNAME_MACHINE=alphaev68 ;;
+ esac
+ objdump --private-headers /bin/sh | grep -q ld.so.1
+ if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ arc:Linux:*:* | arceb:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ arm*:Linux:*:*)
+ eval $set_cc_for_build
+ if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+ | grep -q __ARM_EABI__
+ then
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ else
+ if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+ | grep -q __ARM_PCS_VFP
+ then
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
+ else
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
+ fi
+ fi
+ exit ;;
+ avr32*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ cris:Linux:*:*)
+ echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+ exit ;;
+ crisv32:Linux:*:*)
+ echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+ exit ;;
+ frv:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ hexagon:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ i*86:Linux:*:*)
+ echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+ exit ;;
+ ia64:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ m32r*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ m68*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ mips:Linux:*:* | mips64:Linux:*:*)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #undef CPU
+ #undef ${UNAME_MACHINE}
+ #undef ${UNAME_MACHINE}el
+ #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+ CPU=${UNAME_MACHINE}el
+ #else
+ #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+ CPU=${UNAME_MACHINE}
+ #else
+ CPU=
+ #endif
+ #endif
+EOF
+ eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
+ test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+ ;;
+ or1k:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ or32:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ padre:Linux:*:*)
+ echo sparc-unknown-linux-${LIBC}
+ exit ;;
+ parisc64:Linux:*:* | hppa64:Linux:*:*)
+ echo hppa64-unknown-linux-${LIBC}
+ exit ;;
+ parisc:Linux:*:* | hppa:Linux:*:*)
+ # Look for CPU level
+ case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+ PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
+ PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
+ *) echo hppa-unknown-linux-${LIBC} ;;
+ esac
+ exit ;;
+ ppc64:Linux:*:*)
+ echo powerpc64-unknown-linux-${LIBC}
+ exit ;;
+ ppc:Linux:*:*)
+ echo powerpc-unknown-linux-${LIBC}
+ exit ;;
+ ppc64le:Linux:*:*)
+ echo powerpc64le-unknown-linux-${LIBC}
+ exit ;;
+ ppcle:Linux:*:*)
+ echo powerpcle-unknown-linux-${LIBC}
+ exit ;;
+ s390:Linux:*:* | s390x:Linux:*:*)
+ echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
+ exit ;;
+ sh64*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ sh*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ sparc:Linux:*:* | sparc64:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ tile*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ vax:Linux:*:*)
+ echo ${UNAME_MACHINE}-dec-linux-${LIBC}
+ exit ;;
+ x86_64:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ xtensa*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+ exit ;;
+ i*86:DYNIX/ptx:4*:*)
+ # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+ # earlier versions are messed up and put the nodename in both
+ # sysname and nodename.
+ echo i386-sequent-sysv4
+ exit ;;
+ i*86:UNIX_SV:4.2MP:2.*)
+ # Unixware is an offshoot of SVR4, but it has its own version
+ # number series starting with 2...
+ # I am not positive that other SVR4 systems won't match this,
+ # I just have to hope. -- rms.
+ # Use sysv4.2uw... so that sysv4* matches it.
+ echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+ exit ;;
+ i*86:OS/2:*:*)
+ # If we were able to find `uname', then EMX Unix compatibility
+ # is probably installed.
+ echo ${UNAME_MACHINE}-pc-os2-emx
+ exit ;;
+ i*86:XTS-300:*:STOP)
+ echo ${UNAME_MACHINE}-unknown-stop
+ exit ;;
+ i*86:atheos:*:*)
+ echo ${UNAME_MACHINE}-unknown-atheos
+ exit ;;
+ i*86:syllable:*:*)
+ echo ${UNAME_MACHINE}-pc-syllable
+ exit ;;
+ i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
+ echo i386-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ i*86:*DOS:*:*)
+ echo ${UNAME_MACHINE}-pc-msdosdjgpp
+ exit ;;
+ i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+ UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+ if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+ echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+ else
+ echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+ fi
+ exit ;;
+ i*86:*:5:[678]*)
+ # UnixWare 7.x, OpenUNIX and OpenServer 6.
+ case `/bin/uname -X | grep "^Machine"` in
+ *486*) UNAME_MACHINE=i486 ;;
+ *Pentium) UNAME_MACHINE=i586 ;;
+ *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+ esac
+ echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+ exit ;;
+ i*86:*:3.2:*)
+ if test -f /usr/options/cb.name; then
+ UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+ echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+ elif /bin/uname -X 2>/dev/null >/dev/null ; then
+ UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+ (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+ (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+ && UNAME_MACHINE=i586
+ (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+ && UNAME_MACHINE=i686
+ (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+ && UNAME_MACHINE=i686
+ echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+ else
+ echo ${UNAME_MACHINE}-pc-sysv32
+ fi
+ exit ;;
+ pc:*:*:*)
+ # Left here for compatibility:
+ # uname -m prints for DJGPP always 'pc', but it prints nothing about
+ # the processor, so we play safe by assuming i586.
+ # Note: whatever this is, it MUST be the same as what config.sub
+ # prints for the "djgpp" host, or else GDB configury will decide that
+ # this is a cross-build.
+ echo i586-pc-msdosdjgpp
+ exit ;;
+ Intel:Mach:3*:*)
+ echo i386-pc-mach3
+ exit ;;
+ paragon:*:*:*)
+ echo i860-intel-osf1
+ exit ;;
+ i860:*:4.*:*) # i860-SVR4
+ if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+ echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+ else # Add other i860-SVR4 vendors below as they are discovered.
+ echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4
+ fi
+ exit ;;
+ mini*:CTIX:SYS*5:*)
+ # "miniframe"
+ echo m68010-convergent-sysv
+ exit ;;
+ mc68k:UNIX:SYSTEM5:3.51m)
+ echo m68k-convergent-sysv
+ exit ;;
+ M680?0:D-NIX:5.3:*)
+ echo m68k-diab-dnix
+ exit ;;
+ M68*:*:R3V[5678]*:*)
+ test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+ 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+ OS_REL=''
+ test -r /etc/.relid \
+ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+ && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+ /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+ 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+ && { echo i486-ncr-sysv4; exit; } ;;
+ NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+ OS_REL='.3'
+ test -r /etc/.relid \
+ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+ && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+ /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+ && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+ /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+ m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+ echo m68k-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ mc68030:UNIX_System_V:4.*:*)
+ echo m68k-atari-sysv4
+ exit ;;
+ TSUNAMI:LynxOS:2.*:*)
+ echo sparc-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ rs6000:LynxOS:2.*:*)
+ echo rs6000-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
+ echo powerpc-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ SM[BE]S:UNIX_SV:*:*)
+ echo mips-dde-sysv${UNAME_RELEASE}
+ exit ;;
+ RM*:ReliantUNIX-*:*:*)
+ echo mips-sni-sysv4
+ exit ;;
+ RM*:SINIX-*:*:*)
+ echo mips-sni-sysv4
+ exit ;;
+ *:SINIX-*:*:*)
+ if uname -p 2>/dev/null >/dev/null ; then
+ UNAME_MACHINE=`(uname -p) 2>/dev/null`
+ echo ${UNAME_MACHINE}-sni-sysv4
+ else
+ echo ns32k-sni-sysv
+ fi
+ exit ;;
+ PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+ # says <Richard.M.Bartel@ccMail.Census.GOV>
+ echo i586-unisys-sysv4
+ exit ;;
+ *:UNIX_System_V:4*:FTX*)
+ # From Gerald Hewes <hewes@openmarket.com>.
+ # How about differentiating between stratus architectures? -djm
+ echo hppa1.1-stratus-sysv4
+ exit ;;
+ *:*:*:FTX*)
+ # From seanf@swdc.stratus.com.
+ echo i860-stratus-sysv4
+ exit ;;
+ i*86:VOS:*:*)
+ # From Paul.Green@stratus.com.
+ echo ${UNAME_MACHINE}-stratus-vos
+ exit ;;
+ *:VOS:*:*)
+ # From Paul.Green@stratus.com.
+ echo hppa1.1-stratus-vos
+ exit ;;
+ mc68*:A/UX:*:*)
+ echo m68k-apple-aux${UNAME_RELEASE}
+ exit ;;
+ news*:NEWS-OS:6*:*)
+ echo mips-sony-newsos6
+ exit ;;
+ R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+ if [ -d /usr/nec ]; then
+ echo mips-nec-sysv${UNAME_RELEASE}
+ else
+ echo mips-unknown-sysv${UNAME_RELEASE}
+ fi
+ exit ;;
+ BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
+ echo powerpc-be-beos
+ exit ;;
+ BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only.
+ echo powerpc-apple-beos
+ exit ;;
+ BePC:BeOS:*:*) # BeOS running on Intel PC compatible.
+ echo i586-pc-beos
+ exit ;;
+ BePC:Haiku:*:*) # Haiku running on Intel PC compatible.
+ echo i586-pc-haiku
+ exit ;;
+ x86_64:Haiku:*:*)
+ echo x86_64-unknown-haiku
+ exit ;;
+ SX-4:SUPER-UX:*:*)
+ echo sx4-nec-superux${UNAME_RELEASE}
+ exit ;;
+ SX-5:SUPER-UX:*:*)
+ echo sx5-nec-superux${UNAME_RELEASE}
+ exit ;;
+ SX-6:SUPER-UX:*:*)
+ echo sx6-nec-superux${UNAME_RELEASE}
+ exit ;;
+ SX-7:SUPER-UX:*:*)
+ echo sx7-nec-superux${UNAME_RELEASE}
+ exit ;;
+ SX-8:SUPER-UX:*:*)
+ echo sx8-nec-superux${UNAME_RELEASE}
+ exit ;;
+ SX-8R:SUPER-UX:*:*)
+ echo sx8r-nec-superux${UNAME_RELEASE}
+ exit ;;
+ Power*:Rhapsody:*:*)
+ echo powerpc-apple-rhapsody${UNAME_RELEASE}
+ exit ;;
+ *:Rhapsody:*:*)
+ echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+ exit ;;
+ *:Darwin:*:*)
+ UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+ eval $set_cc_for_build
+ if test "$UNAME_PROCESSOR" = unknown ; then
+ UNAME_PROCESSOR=powerpc
+ fi
+ if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
+ if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+ grep IS_64BIT_ARCH >/dev/null
+ then
+ case $UNAME_PROCESSOR in
+ i386) UNAME_PROCESSOR=x86_64 ;;
+ powerpc) UNAME_PROCESSOR=powerpc64 ;;
+ esac
+ fi
+ fi
+ echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+ exit ;;
+ *:procnto*:*:* | *:QNX:[0123456789]*:*)
+ UNAME_PROCESSOR=`uname -p`
+ if test "$UNAME_PROCESSOR" = "x86"; then
+ UNAME_PROCESSOR=i386
+ UNAME_MACHINE=pc
+ fi
+ echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+ exit ;;
+ *:QNX:*:4*)
+ echo i386-pc-qnx
+ exit ;;
+ NEO-?:NONSTOP_KERNEL:*:*)
+ echo neo-tandem-nsk${UNAME_RELEASE}
+ exit ;;
+ NSE-*:NONSTOP_KERNEL:*:*)
+ echo nse-tandem-nsk${UNAME_RELEASE}
+ exit ;;
+ NSR-?:NONSTOP_KERNEL:*:*)
+ echo nsr-tandem-nsk${UNAME_RELEASE}
+ exit ;;
+ *:NonStop-UX:*:*)
+ echo mips-compaq-nonstopux
+ exit ;;
+ BS2000:POSIX*:*:*)
+ echo bs2000-siemens-sysv
+ exit ;;
+ DS/*:UNIX_System_V:*:*)
+ echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+ exit ;;
+ *:Plan9:*:*)
+ # "uname -m" is not consistent, so use $cputype instead. 386
+ # is converted to i386 for consistency with other x86
+ # operating systems.
+ if test "$cputype" = "386"; then
+ UNAME_MACHINE=i386
+ else
+ UNAME_MACHINE="$cputype"
+ fi
+ echo ${UNAME_MACHINE}-unknown-plan9
+ exit ;;
+ *:TOPS-10:*:*)
+ echo pdp10-unknown-tops10
+ exit ;;
+ *:TENEX:*:*)
+ echo pdp10-unknown-tenex
+ exit ;;
+ KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+ echo pdp10-dec-tops20
+ exit ;;
+ XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+ echo pdp10-xkl-tops20
+ exit ;;
+ *:TOPS-20:*:*)
+ echo pdp10-unknown-tops20
+ exit ;;
+ *:ITS:*:*)
+ echo pdp10-unknown-its
+ exit ;;
+ SEI:*:*:SEIUX)
+ echo mips-sei-seiux${UNAME_RELEASE}
+ exit ;;
+ *:DragonFly:*:*)
+ echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+ exit ;;
+ *:*VMS:*:*)
+ UNAME_MACHINE=`(uname -p) 2>/dev/null`
+ case "${UNAME_MACHINE}" in
+ A*) echo alpha-dec-vms ; exit ;;
+ I*) echo ia64-dec-vms ; exit ;;
+ V*) echo vax-dec-vms ; exit ;;
+ esac ;;
+ *:XENIX:*:SysV)
+ echo i386-pc-xenix
+ exit ;;
+ i*86:skyos:*:*)
+ echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
+ exit ;;
+ i*86:rdos:*:*)
+ echo ${UNAME_MACHINE}-pc-rdos
+ exit ;;
+ i*86:AROS:*:*)
+ echo ${UNAME_MACHINE}-pc-aros
+ exit ;;
+ x86_64:VMkernel:*:*)
+ echo ${UNAME_MACHINE}-unknown-esx
+ exit ;;
+esac
+
+eval $set_cc_for_build
+cat >$dummy.c <<EOF
+#ifdef _SEQUENT_
+# include <sys/types.h>
+# include <sys/utsname.h>
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+ /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed,
+ I don't know.... */
+ printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+ printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+ "4"
+#else
+ ""
+#endif
+ ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+ printf ("arm-acorn-riscix\n"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+ printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+ int version;
+ version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+ if (version < 4)
+ printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+ else
+ printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+ exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+ printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+ printf ("ns32k-encore-mach\n"); exit (0);
+#else
+ printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+ printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+ printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+ printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+ struct utsname un;
+
+ uname(&un);
+
+ if (strncmp(un.version, "V2", 2) == 0) {
+ printf ("i386-sequent-ptx2\n"); exit (0);
+ }
+ if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+ printf ("i386-sequent-ptx1\n"); exit (0);
+ }
+ printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+# if !defined (ultrix)
+# include <sys/param.h>
+# if defined (BSD)
+# if BSD == 43
+ printf ("vax-dec-bsd4.3\n"); exit (0);
+# else
+# if BSD == 199006
+ printf ("vax-dec-bsd4.3reno\n"); exit (0);
+# else
+ printf ("vax-dec-bsd\n"); exit (0);
+# endif
+# endif
+# else
+ printf ("vax-dec-bsd\n"); exit (0);
+# endif
+# else
+ printf ("vax-dec-ultrix\n"); exit (0);
+# endif
+#endif
+
+#if defined (alliant) && defined (i860)
+ printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+ exit (1);
+}
+EOF
+
+$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
+ { echo "$SYSTEM_NAME"; exit; }
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+ case `getsysinfo -f cpu_type` in
+ c1*)
+ echo c1-convex-bsd
+ exit ;;
+ c2*)
+ if getsysinfo -f scalar_acc
+ then echo c32-convex-bsd
+ else echo c2-convex-bsd
+ fi
+ exit ;;
+ c34*)
+ echo c34-convex-bsd
+ exit ;;
+ c38*)
+ echo c38-convex-bsd
+ exit ;;
+ c4*)
+ echo c4-convex-bsd
+ exit ;;
+ esac
+fi
+
+cat >&2 <<EOF
+$0: unable to guess system type
+
+This script, last modified $timestamp, has failed to recognize
+the operating system you are using. It is advised that you
+download the most up to date version of the config scripts from
+
+ http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+and
+ http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+
+If the version you run ($0) is already up to date, please
+send the following data and any information you think might be
+pertinent to <config-patches@gnu.org> in order to provide the needed
+information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo = `(hostinfo) 2>/dev/null`
+/bin/universe = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
--- /dev/null
+/* config.h.in. Generated from configure.ac by autoheader. */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+ */
+#undef LT_OBJDIR
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Version number of package */
+#undef VERSION
--- /dev/null
+#! /bin/sh
+# Configuration validation subroutine script.
+# Copyright 1992-2013 Free Software Foundation, Inc.
+
+timestamp='2013-08-10'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <http://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program. This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+
+
+# Please send patches with a ChangeLog entry to config-patches@gnu.org.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# You can get the latest version of this script from:
+# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support. The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+ $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+ -h, --help print this help, then exit
+ -t, --time-stamp print date of last modification, then exit
+ -v, --version print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright 1992-2013 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+ case $1 in
+ --time-stamp | --time* | -t )
+ echo "$timestamp" ; exit ;;
+ --version | -v )
+ echo "$version" ; exit ;;
+ --help | --h* | -h )
+ echo "$usage"; exit ;;
+ -- ) # Stop option processing
+ shift; break ;;
+ - ) # Use stdin as input.
+ break ;;
+ -* )
+ echo "$me: invalid option $1$help"
+ exit 1 ;;
+
+ *local*)
+ # First pass through any local machine types.
+ echo $1
+ exit ;;
+
+ * )
+ break ;;
+ esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+ exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+ exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+ nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
+ linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
+ knetbsd*-gnu* | netbsd*-gnu* | \
+ kopensolaris*-gnu* | \
+ storm-chaos* | os2-emx* | rtmk-nova*)
+ os=-$maybe_os
+ basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+ ;;
+ android-linux)
+ os=-linux-android
+ basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
+ ;;
+ *)
+ basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+ if [ $basic_machine != $1 ]
+ then os=`echo $1 | sed 's/.*-/-/'`
+ else os=; fi
+ ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work. We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+ -sun*os*)
+ # Prevent following clause from handling this invalid input.
+ ;;
+ -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+ -apple | -axis | -knuth | -cray | -microblaze*)
+ os=
+ basic_machine=$1
+ ;;
+ -bluegene*)
+ os=-cnk
+ ;;
+ -sim | -cisco | -oki | -wec | -winbond)
+ os=
+ basic_machine=$1
+ ;;
+ -scout)
+ ;;
+ -wrs)
+ os=-vxworks
+ basic_machine=$1
+ ;;
+ -chorusos*)
+ os=-chorusos
+ basic_machine=$1
+ ;;
+ -chorusrdb)
+ os=-chorusrdb
+ basic_machine=$1
+ ;;
+ -hiux*)
+ os=-hiuxwe2
+ ;;
+ -sco6)
+ os=-sco5v6
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco5)
+ os=-sco3.2v5
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco4)
+ os=-sco3.2v4
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco3.2.[4-9]*)
+ os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco3.2v[4-9]*)
+ # Don't forget version if it is 3.2v4 or newer.
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco5v6*)
+ # Don't forget version if it is 3.2v4 or newer.
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco*)
+ os=-sco3.2v2
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -udk*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -isc)
+ os=-isc2.2
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -clix*)
+ basic_machine=clipper-intergraph
+ ;;
+ -isc*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -lynx*178)
+ os=-lynxos178
+ ;;
+ -lynx*5)
+ os=-lynxos5
+ ;;
+ -lynx*)
+ os=-lynxos
+ ;;
+ -ptx*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+ ;;
+ -windowsnt*)
+ os=`echo $os | sed -e 's/windowsnt/winnt/'`
+ ;;
+ -psos*)
+ os=-psos
+ ;;
+ -mint | -mint[0-9]*)
+ basic_machine=m68k-atari
+ os=-mint
+ ;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+ # Recognize the basic CPU types without company name.
+ # Some are omitted here because they have special meanings below.
+ 1750a | 580 \
+ | a29k \
+ | aarch64 | aarch64_be \
+ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+ | am33_2.0 \
+ | arc | arceb \
+ | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
+ | avr | avr32 \
+ | be32 | be64 \
+ | bfin \
+ | c4x | c8051 | clipper \
+ | d10v | d30v | dlx | dsp16xx \
+ | epiphany \
+ | fido | fr30 | frv \
+ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+ | hexagon \
+ | i370 | i860 | i960 | ia64 \
+ | ip2k | iq2000 \
+ | le32 | le64 \
+ | lm32 \
+ | m32c | m32r | m32rle | m68000 | m68k | m88k \
+ | maxq | mb | microblaze | microblazeel | mcore | mep | metag \
+ | mips | mipsbe | mipseb | mipsel | mipsle \
+ | mips16 \
+ | mips64 | mips64el \
+ | mips64octeon | mips64octeonel \
+ | mips64orion | mips64orionel \
+ | mips64r5900 | mips64r5900el \
+ | mips64vr | mips64vrel \
+ | mips64vr4100 | mips64vr4100el \
+ | mips64vr4300 | mips64vr4300el \
+ | mips64vr5000 | mips64vr5000el \
+ | mips64vr5900 | mips64vr5900el \
+ | mipsisa32 | mipsisa32el \
+ | mipsisa32r2 | mipsisa32r2el \
+ | mipsisa64 | mipsisa64el \
+ | mipsisa64r2 | mipsisa64r2el \
+ | mipsisa64sb1 | mipsisa64sb1el \
+ | mipsisa64sr71k | mipsisa64sr71kel \
+ | mipsr5900 | mipsr5900el \
+ | mipstx39 | mipstx39el \
+ | mn10200 | mn10300 \
+ | moxie \
+ | mt \
+ | msp430 \
+ | nds32 | nds32le | nds32be \
+ | nios | nios2 | nios2eb | nios2el \
+ | ns16k | ns32k \
+ | open8 \
+ | or1k | or32 \
+ | pdp10 | pdp11 | pj | pjl \
+ | powerpc | powerpc64 | powerpc64le | powerpcle \
+ | pyramid \
+ | rl78 | rx \
+ | score \
+ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+ | sh64 | sh64le \
+ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+ | spu \
+ | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
+ | ubicom32 \
+ | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
+ | we32k \
+ | x86 | xc16x | xstormy16 | xtensa \
+ | z8k | z80)
+ basic_machine=$basic_machine-unknown
+ ;;
+ c54x)
+ basic_machine=tic54x-unknown
+ ;;
+ c55x)
+ basic_machine=tic55x-unknown
+ ;;
+ c6x)
+ basic_machine=tic6x-unknown
+ ;;
+ m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | picochip)
+ basic_machine=$basic_machine-unknown
+ os=-none
+ ;;
+ m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+ ;;
+ ms1)
+ basic_machine=mt-unknown
+ ;;
+
+ strongarm | thumb | xscale)
+ basic_machine=arm-unknown
+ ;;
+ xgate)
+ basic_machine=$basic_machine-unknown
+ os=-none
+ ;;
+ xscaleeb)
+ basic_machine=armeb-unknown
+ ;;
+
+ xscaleel)
+ basic_machine=armel-unknown
+ ;;
+
+ # We use `pc' rather than `unknown'
+ # because (1) that's what they normally are, and
+ # (2) the word "unknown" tends to confuse beginning users.
+ i*86 | x86_64)
+ basic_machine=$basic_machine-pc
+ ;;
+ # Object if more than one company name word.
+ *-*-*)
+ echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+ exit 1
+ ;;
+ # Recognize the basic CPU types with company name.
+ 580-* \
+ | a29k-* \
+ | aarch64-* | aarch64_be-* \
+ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
+ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \
+ | avr-* | avr32-* \
+ | be32-* | be64-* \
+ | bfin-* | bs2000-* \
+ | c[123]* | c30-* | [cjt]90-* | c4x-* \
+ | c8051-* | clipper-* | craynv-* | cydra-* \
+ | d10v-* | d30v-* | dlx-* \
+ | elxsi-* \
+ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+ | h8300-* | h8500-* \
+ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+ | hexagon-* \
+ | i*86-* | i860-* | i960-* | ia64-* \
+ | ip2k-* | iq2000-* \
+ | le32-* | le64-* \
+ | lm32-* \
+ | m32c-* | m32r-* | m32rle-* \
+ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
+ | microblaze-* | microblazeel-* \
+ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+ | mips16-* \
+ | mips64-* | mips64el-* \
+ | mips64octeon-* | mips64octeonel-* \
+ | mips64orion-* | mips64orionel-* \
+ | mips64r5900-* | mips64r5900el-* \
+ | mips64vr-* | mips64vrel-* \
+ | mips64vr4100-* | mips64vr4100el-* \
+ | mips64vr4300-* | mips64vr4300el-* \
+ | mips64vr5000-* | mips64vr5000el-* \
+ | mips64vr5900-* | mips64vr5900el-* \
+ | mipsisa32-* | mipsisa32el-* \
+ | mipsisa32r2-* | mipsisa32r2el-* \
+ | mipsisa64-* | mipsisa64el-* \
+ | mipsisa64r2-* | mipsisa64r2el-* \
+ | mipsisa64sb1-* | mipsisa64sb1el-* \
+ | mipsisa64sr71k-* | mipsisa64sr71kel-* \
+ | mipsr5900-* | mipsr5900el-* \
+ | mipstx39-* | mipstx39el-* \
+ | mmix-* \
+ | mt-* \
+ | msp430-* \
+ | nds32-* | nds32le-* | nds32be-* \
+ | nios-* | nios2-* | nios2eb-* | nios2el-* \
+ | none-* | np1-* | ns16k-* | ns32k-* \
+ | open8-* \
+ | orion-* \
+ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+ | pyramid-* \
+ | rl78-* | romp-* | rs6000-* | rx-* \
+ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+ | sparclite-* \
+ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
+ | tahoe-* \
+ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+ | tile*-* \
+ | tron-* \
+ | ubicom32-* \
+ | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
+ | vax-* \
+ | we32k-* \
+ | x86-* | x86_64-* | xc16x-* | xps100-* \
+ | xstormy16-* | xtensa*-* \
+ | ymp-* \
+ | z8k-* | z80-*)
+ ;;
+ # Recognize the basic CPU types without company name, with glob match.
+ xtensa*)
+ basic_machine=$basic_machine-unknown
+ ;;
+ # Recognize the various machine names and aliases which stand
+ # for a CPU type and a company and sometimes even an OS.
+ 386bsd)
+ basic_machine=i386-unknown
+ os=-bsd
+ ;;
+ 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+ basic_machine=m68000-att
+ ;;
+ 3b*)
+ basic_machine=we32k-att
+ ;;
+ a29khif)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ abacus)
+ basic_machine=abacus-unknown
+ ;;
+ adobe68k)
+ basic_machine=m68010-adobe
+ os=-scout
+ ;;
+ alliant | fx80)
+ basic_machine=fx80-alliant
+ ;;
+ altos | altos3068)
+ basic_machine=m68k-altos
+ ;;
+ am29k)
+ basic_machine=a29k-none
+ os=-bsd
+ ;;
+ amd64)
+ basic_machine=x86_64-pc
+ ;;
+ amd64-*)
+ basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ amdahl)
+ basic_machine=580-amdahl
+ os=-sysv
+ ;;
+ amiga | amiga-*)
+ basic_machine=m68k-unknown
+ ;;
+ amigaos | amigados)
+ basic_machine=m68k-unknown
+ os=-amigaos
+ ;;
+ amigaunix | amix)
+ basic_machine=m68k-unknown
+ os=-sysv4
+ ;;
+ apollo68)
+ basic_machine=m68k-apollo
+ os=-sysv
+ ;;
+ apollo68bsd)
+ basic_machine=m68k-apollo
+ os=-bsd
+ ;;
+ aros)
+ basic_machine=i386-pc
+ os=-aros
+ ;;
+ aux)
+ basic_machine=m68k-apple
+ os=-aux
+ ;;
+ balance)
+ basic_machine=ns32k-sequent
+ os=-dynix
+ ;;
+ blackfin)
+ basic_machine=bfin-unknown
+ os=-linux
+ ;;
+ blackfin-*)
+ basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
+ os=-linux
+ ;;
+ bluegene*)
+ basic_machine=powerpc-ibm
+ os=-cnk
+ ;;
+ c54x-*)
+ basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ c55x-*)
+ basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ c6x-*)
+ basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ c90)
+ basic_machine=c90-cray
+ os=-unicos
+ ;;
+ cegcc)
+ basic_machine=arm-unknown
+ os=-cegcc
+ ;;
+ convex-c1)
+ basic_machine=c1-convex
+ os=-bsd
+ ;;
+ convex-c2)
+ basic_machine=c2-convex
+ os=-bsd
+ ;;
+ convex-c32)
+ basic_machine=c32-convex
+ os=-bsd
+ ;;
+ convex-c34)
+ basic_machine=c34-convex
+ os=-bsd
+ ;;
+ convex-c38)
+ basic_machine=c38-convex
+ os=-bsd
+ ;;
+ cray | j90)
+ basic_machine=j90-cray
+ os=-unicos
+ ;;
+ craynv)
+ basic_machine=craynv-cray
+ os=-unicosmp
+ ;;
+ cr16 | cr16-*)
+ basic_machine=cr16-unknown
+ os=-elf
+ ;;
+ crds | unos)
+ basic_machine=m68k-crds
+ ;;
+ crisv32 | crisv32-* | etraxfs*)
+ basic_machine=crisv32-axis
+ ;;
+ cris | cris-* | etrax*)
+ basic_machine=cris-axis
+ ;;
+ crx)
+ basic_machine=crx-unknown
+ os=-elf
+ ;;
+ da30 | da30-*)
+ basic_machine=m68k-da30
+ ;;
+ decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+ basic_machine=mips-dec
+ ;;
+ decsystem10* | dec10*)
+ basic_machine=pdp10-dec
+ os=-tops10
+ ;;
+ decsystem20* | dec20*)
+ basic_machine=pdp10-dec
+ os=-tops20
+ ;;
+ delta | 3300 | motorola-3300 | motorola-delta \
+ | 3300-motorola | delta-motorola)
+ basic_machine=m68k-motorola
+ ;;
+ delta88)
+ basic_machine=m88k-motorola
+ os=-sysv3
+ ;;
+ dicos)
+ basic_machine=i686-pc
+ os=-dicos
+ ;;
+ djgpp)
+ basic_machine=i586-pc
+ os=-msdosdjgpp
+ ;;
+ dpx20 | dpx20-*)
+ basic_machine=rs6000-bull
+ os=-bosx
+ ;;
+ dpx2* | dpx2*-bull)
+ basic_machine=m68k-bull
+ os=-sysv3
+ ;;
+ ebmon29k)
+ basic_machine=a29k-amd
+ os=-ebmon
+ ;;
+ elxsi)
+ basic_machine=elxsi-elxsi
+ os=-bsd
+ ;;
+ encore | umax | mmax)
+ basic_machine=ns32k-encore
+ ;;
+ es1800 | OSE68k | ose68k | ose | OSE)
+ basic_machine=m68k-ericsson
+ os=-ose
+ ;;
+ fx2800)
+ basic_machine=i860-alliant
+ ;;
+ genix)
+ basic_machine=ns32k-ns
+ ;;
+ gmicro)
+ basic_machine=tron-gmicro
+ os=-sysv
+ ;;
+ go32)
+ basic_machine=i386-pc
+ os=-go32
+ ;;
+ h3050r* | hiux*)
+ basic_machine=hppa1.1-hitachi
+ os=-hiuxwe2
+ ;;
+ h8300hms)
+ basic_machine=h8300-hitachi
+ os=-hms
+ ;;
+ h8300xray)
+ basic_machine=h8300-hitachi
+ os=-xray
+ ;;
+ h8500hms)
+ basic_machine=h8500-hitachi
+ os=-hms
+ ;;
+ harris)
+ basic_machine=m88k-harris
+ os=-sysv3
+ ;;
+ hp300-*)
+ basic_machine=m68k-hp
+ ;;
+ hp300bsd)
+ basic_machine=m68k-hp
+ os=-bsd
+ ;;
+ hp300hpux)
+ basic_machine=m68k-hp
+ os=-hpux
+ ;;
+ hp3k9[0-9][0-9] | hp9[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hp9k2[0-9][0-9] | hp9k31[0-9])
+ basic_machine=m68000-hp
+ ;;
+ hp9k3[2-9][0-9])
+ basic_machine=m68k-hp
+ ;;
+ hp9k6[0-9][0-9] | hp6[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hp9k7[0-79][0-9] | hp7[0-79][0-9])
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k78[0-9] | hp78[0-9])
+ # FIXME: really hppa2.0-hp
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+ # FIXME: really hppa2.0-hp
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[0-9][13679] | hp8[0-9][13679])
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[0-9][0-9] | hp8[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hppa-next)
+ os=-nextstep3
+ ;;
+ hppaosf)
+ basic_machine=hppa1.1-hp
+ os=-osf
+ ;;
+ hppro)
+ basic_machine=hppa1.1-hp
+ os=-proelf
+ ;;
+ i370-ibm* | ibm*)
+ basic_machine=i370-ibm
+ ;;
+ i*86v32)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv32
+ ;;
+ i*86v4*)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv4
+ ;;
+ i*86v)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv
+ ;;
+ i*86sol2)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-solaris2
+ ;;
+ i386mach)
+ basic_machine=i386-mach
+ os=-mach
+ ;;
+ i386-vsta | vsta)
+ basic_machine=i386-unknown
+ os=-vsta
+ ;;
+ iris | iris4d)
+ basic_machine=mips-sgi
+ case $os in
+ -irix*)
+ ;;
+ *)
+ os=-irix4
+ ;;
+ esac
+ ;;
+ isi68 | isi)
+ basic_machine=m68k-isi
+ os=-sysv
+ ;;
+ m68knommu)
+ basic_machine=m68k-unknown
+ os=-linux
+ ;;
+ m68knommu-*)
+ basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
+ os=-linux
+ ;;
+ m88k-omron*)
+ basic_machine=m88k-omron
+ ;;
+ magnum | m3230)
+ basic_machine=mips-mips
+ os=-sysv
+ ;;
+ merlin)
+ basic_machine=ns32k-utek
+ os=-sysv
+ ;;
+ microblaze*)
+ basic_machine=microblaze-xilinx
+ ;;
+ mingw64)
+ basic_machine=x86_64-pc
+ os=-mingw64
+ ;;
+ mingw32)
+ basic_machine=i686-pc
+ os=-mingw32
+ ;;
+ mingw32ce)
+ basic_machine=arm-unknown
+ os=-mingw32ce
+ ;;
+ miniframe)
+ basic_machine=m68000-convergent
+ ;;
+ *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+ basic_machine=m68k-atari
+ os=-mint
+ ;;
+ mips3*-*)
+ basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+ ;;
+ mips3*)
+ basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+ ;;
+ monitor)
+ basic_machine=m68k-rom68k
+ os=-coff
+ ;;
+ morphos)
+ basic_machine=powerpc-unknown
+ os=-morphos
+ ;;
+ msdos)
+ basic_machine=i386-pc
+ os=-msdos
+ ;;
+ ms1-*)
+ basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
+ ;;
+ msys)
+ basic_machine=i686-pc
+ os=-msys
+ ;;
+ mvs)
+ basic_machine=i370-ibm
+ os=-mvs
+ ;;
+ nacl)
+ basic_machine=le32-unknown
+ os=-nacl
+ ;;
+ ncr3000)
+ basic_machine=i486-ncr
+ os=-sysv4
+ ;;
+ netbsd386)
+ basic_machine=i386-unknown
+ os=-netbsd
+ ;;
+ netwinder)
+ basic_machine=armv4l-rebel
+ os=-linux
+ ;;
+ news | news700 | news800 | news900)
+ basic_machine=m68k-sony
+ os=-newsos
+ ;;
+ news1000)
+ basic_machine=m68030-sony
+ os=-newsos
+ ;;
+ news-3600 | risc-news)
+ basic_machine=mips-sony
+ os=-newsos
+ ;;
+ necv70)
+ basic_machine=v70-nec
+ os=-sysv
+ ;;
+ next | m*-next )
+ basic_machine=m68k-next
+ case $os in
+ -nextstep* )
+ ;;
+ -ns2*)
+ os=-nextstep2
+ ;;
+ *)
+ os=-nextstep3
+ ;;
+ esac
+ ;;
+ nh3000)
+ basic_machine=m68k-harris
+ os=-cxux
+ ;;
+ nh[45]000)
+ basic_machine=m88k-harris
+ os=-cxux
+ ;;
+ nindy960)
+ basic_machine=i960-intel
+ os=-nindy
+ ;;
+ mon960)
+ basic_machine=i960-intel
+ os=-mon960
+ ;;
+ nonstopux)
+ basic_machine=mips-compaq
+ os=-nonstopux
+ ;;
+ np1)
+ basic_machine=np1-gould
+ ;;
+ neo-tandem)
+ basic_machine=neo-tandem
+ ;;
+ nse-tandem)
+ basic_machine=nse-tandem
+ ;;
+ nsr-tandem)
+ basic_machine=nsr-tandem
+ ;;
+ op50n-* | op60c-*)
+ basic_machine=hppa1.1-oki
+ os=-proelf
+ ;;
+ openrisc | openrisc-*)
+ basic_machine=or32-unknown
+ ;;
+ os400)
+ basic_machine=powerpc-ibm
+ os=-os400
+ ;;
+ OSE68000 | ose68000)
+ basic_machine=m68000-ericsson
+ os=-ose
+ ;;
+ os68k)
+ basic_machine=m68k-none
+ os=-os68k
+ ;;
+ pa-hitachi)
+ basic_machine=hppa1.1-hitachi
+ os=-hiuxwe2
+ ;;
+ paragon)
+ basic_machine=i860-intel
+ os=-osf
+ ;;
+ parisc)
+ basic_machine=hppa-unknown
+ os=-linux
+ ;;
+ parisc-*)
+ basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
+ os=-linux
+ ;;
+ pbd)
+ basic_machine=sparc-tti
+ ;;
+ pbb)
+ basic_machine=m68k-tti
+ ;;
+ pc532 | pc532-*)
+ basic_machine=ns32k-pc532
+ ;;
+ pc98)
+ basic_machine=i386-pc
+ ;;
+ pc98-*)
+ basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentium | p5 | k5 | k6 | nexgen | viac3)
+ basic_machine=i586-pc
+ ;;
+ pentiumpro | p6 | 6x86 | athlon | athlon_*)
+ basic_machine=i686-pc
+ ;;
+ pentiumii | pentium2 | pentiumiii | pentium3)
+ basic_machine=i686-pc
+ ;;
+ pentium4)
+ basic_machine=i786-pc
+ ;;
+ pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+ basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentiumpro-* | p6-* | 6x86-* | athlon-*)
+ basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+ basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentium4-*)
+ basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pn)
+ basic_machine=pn-gould
+ ;;
+ power) basic_machine=power-ibm
+ ;;
+ ppc | ppcbe) basic_machine=powerpc-unknown
+ ;;
+ ppc-* | ppcbe-*)
+ basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppcle | powerpclittle | ppc-le | powerpc-little)
+ basic_machine=powerpcle-unknown
+ ;;
+ ppcle-* | powerpclittle-*)
+ basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppc64) basic_machine=powerpc64-unknown
+ ;;
+ ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+ basic_machine=powerpc64le-unknown
+ ;;
+ ppc64le-* | powerpc64little-*)
+ basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ps2)
+ basic_machine=i386-ibm
+ ;;
+ pw32)
+ basic_machine=i586-unknown
+ os=-pw32
+ ;;
+ rdos | rdos64)
+ basic_machine=x86_64-pc
+ os=-rdos
+ ;;
+ rdos32)
+ basic_machine=i386-pc
+ os=-rdos
+ ;;
+ rom68k)
+ basic_machine=m68k-rom68k
+ os=-coff
+ ;;
+ rm[46]00)
+ basic_machine=mips-siemens
+ ;;
+ rtpc | rtpc-*)
+ basic_machine=romp-ibm
+ ;;
+ s390 | s390-*)
+ basic_machine=s390-ibm
+ ;;
+ s390x | s390x-*)
+ basic_machine=s390x-ibm
+ ;;
+ sa29200)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ sb1)
+ basic_machine=mipsisa64sb1-unknown
+ ;;
+ sb1el)
+ basic_machine=mipsisa64sb1el-unknown
+ ;;
+ sde)
+ basic_machine=mipsisa32-sde
+ os=-elf
+ ;;
+ sei)
+ basic_machine=mips-sei
+ os=-seiux
+ ;;
+ sequent)
+ basic_machine=i386-sequent
+ ;;
+ sh)
+ basic_machine=sh-hitachi
+ os=-hms
+ ;;
+ sh5el)
+ basic_machine=sh5le-unknown
+ ;;
+ sh64)
+ basic_machine=sh64-unknown
+ ;;
+ sparclite-wrs | simso-wrs)
+ basic_machine=sparclite-wrs
+ os=-vxworks
+ ;;
+ sps7)
+ basic_machine=m68k-bull
+ os=-sysv2
+ ;;
+ spur)
+ basic_machine=spur-unknown
+ ;;
+ st2000)
+ basic_machine=m68k-tandem
+ ;;
+ stratus)
+ basic_machine=i860-stratus
+ os=-sysv4
+ ;;
+ strongarm-* | thumb-*)
+ basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ sun2)
+ basic_machine=m68000-sun
+ ;;
+ sun2os3)
+ basic_machine=m68000-sun
+ os=-sunos3
+ ;;
+ sun2os4)
+ basic_machine=m68000-sun
+ os=-sunos4
+ ;;
+ sun3os3)
+ basic_machine=m68k-sun
+ os=-sunos3
+ ;;
+ sun3os4)
+ basic_machine=m68k-sun
+ os=-sunos4
+ ;;
+ sun4os3)
+ basic_machine=sparc-sun
+ os=-sunos3
+ ;;
+ sun4os4)
+ basic_machine=sparc-sun
+ os=-sunos4
+ ;;
+ sun4sol2)
+ basic_machine=sparc-sun
+ os=-solaris2
+ ;;
+ sun3 | sun3-*)
+ basic_machine=m68k-sun
+ ;;
+ sun4)
+ basic_machine=sparc-sun
+ ;;
+ sun386 | sun386i | roadrunner)
+ basic_machine=i386-sun
+ ;;
+ sv1)
+ basic_machine=sv1-cray
+ os=-unicos
+ ;;
+ symmetry)
+ basic_machine=i386-sequent
+ os=-dynix
+ ;;
+ t3e)
+ basic_machine=alphaev5-cray
+ os=-unicos
+ ;;
+ t90)
+ basic_machine=t90-cray
+ os=-unicos
+ ;;
+ tile*)
+ basic_machine=$basic_machine-unknown
+ os=-linux-gnu
+ ;;
+ tx39)
+ basic_machine=mipstx39-unknown
+ ;;
+ tx39el)
+ basic_machine=mipstx39el-unknown
+ ;;
+ toad1)
+ basic_machine=pdp10-xkl
+ os=-tops20
+ ;;
+ tower | tower-32)
+ basic_machine=m68k-ncr
+ ;;
+ tpf)
+ basic_machine=s390x-ibm
+ os=-tpf
+ ;;
+ udi29k)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ ultra3)
+ basic_machine=a29k-nyu
+ os=-sym1
+ ;;
+ v810 | necv810)
+ basic_machine=v810-nec
+ os=-none
+ ;;
+ vaxv)
+ basic_machine=vax-dec
+ os=-sysv
+ ;;
+ vms)
+ basic_machine=vax-dec
+ os=-vms
+ ;;
+ vpp*|vx|vx-*)
+ basic_machine=f301-fujitsu
+ ;;
+ vxworks960)
+ basic_machine=i960-wrs
+ os=-vxworks
+ ;;
+ vxworks68)
+ basic_machine=m68k-wrs
+ os=-vxworks
+ ;;
+ vxworks29k)
+ basic_machine=a29k-wrs
+ os=-vxworks
+ ;;
+ w65*)
+ basic_machine=w65-wdc
+ os=-none
+ ;;
+ w89k-*)
+ basic_machine=hppa1.1-winbond
+ os=-proelf
+ ;;
+ xbox)
+ basic_machine=i686-pc
+ os=-mingw32
+ ;;
+ xps | xps100)
+ basic_machine=xps100-honeywell
+ ;;
+ xscale-* | xscalee[bl]-*)
+ basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
+ ;;
+ ymp)
+ basic_machine=ymp-cray
+ os=-unicos
+ ;;
+ z8k-*-coff)
+ basic_machine=z8k-unknown
+ os=-sim
+ ;;
+ z80-*-coff)
+ basic_machine=z80-unknown
+ os=-sim
+ ;;
+ none)
+ basic_machine=none-none
+ os=-none
+ ;;
+
+# Here we handle the default manufacturer of certain CPU types. It is in
+# some cases the only manufacturer, in others, it is the most popular.
+ w89k)
+ basic_machine=hppa1.1-winbond
+ ;;
+ op50n)
+ basic_machine=hppa1.1-oki
+ ;;
+ op60c)
+ basic_machine=hppa1.1-oki
+ ;;
+ romp)
+ basic_machine=romp-ibm
+ ;;
+ mmix)
+ basic_machine=mmix-knuth
+ ;;
+ rs6000)
+ basic_machine=rs6000-ibm
+ ;;
+ vax)
+ basic_machine=vax-dec
+ ;;
+ pdp10)
+ # there are many clones, so DEC is not a safe bet
+ basic_machine=pdp10-unknown
+ ;;
+ pdp11)
+ basic_machine=pdp11-dec
+ ;;
+ we32k)
+ basic_machine=we32k-att
+ ;;
+ sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
+ basic_machine=sh-unknown
+ ;;
+ sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
+ basic_machine=sparc-sun
+ ;;
+ cydra)
+ basic_machine=cydra-cydrome
+ ;;
+ orion)
+ basic_machine=orion-highlevel
+ ;;
+ orion105)
+ basic_machine=clipper-highlevel
+ ;;
+ mac | mpw | mac-mpw)
+ basic_machine=m68k-apple
+ ;;
+ pmac | pmac-mpw)
+ basic_machine=powerpc-apple
+ ;;
+ *-unknown)
+ # Make sure to match an already-canonicalized machine name.
+ ;;
+ *)
+ echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+ exit 1
+ ;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+ *-digital*)
+ basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+ ;;
+ *-commodore*)
+ basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+ ;;
+ *)
+ ;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+ # First match some system type aliases
+ # that might get confused with valid system types.
+ # -solaris* is a basic system type, with this one exception.
+ -auroraux)
+ os=-auroraux
+ ;;
+ -solaris1 | -solaris1.*)
+ os=`echo $os | sed -e 's|solaris1|sunos4|'`
+ ;;
+ -solaris)
+ os=-solaris2
+ ;;
+ -svr4*)
+ os=-sysv4
+ ;;
+ -unixware*)
+ os=-sysv4.2uw
+ ;;
+ -gnu/linux*)
+ os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+ ;;
+ # First accept the basic system types.
+ # The portable systems comes first.
+ # Each alternative MUST END IN A *, to match a version number.
+ # -sysv* is not here because it comes later, after sysvr4.
+ -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
+ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
+ | -sym* | -kopensolaris* | -plan9* \
+ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+ | -aos* | -aros* \
+ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+ | -bitrig* | -openbsd* | -solidbsd* \
+ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+ | -chorusos* | -chorusrdb* | -cegcc* \
+ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+ | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
+ | -linux-newlib* | -linux-musl* | -linux-uclibc* \
+ | -uxpv* | -beos* | -mpeix* | -udk* \
+ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
+ # Remember, each alternative MUST END IN *, to match a version number.
+ ;;
+ -qnx*)
+ case $basic_machine in
+ x86-* | i*86-*)
+ ;;
+ *)
+ os=-nto$os
+ ;;
+ esac
+ ;;
+ -nto-qnx*)
+ ;;
+ -nto*)
+ os=`echo $os | sed -e 's|nto|nto-qnx|'`
+ ;;
+ -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
+ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+ ;;
+ -mac*)
+ os=`echo $os | sed -e 's|mac|macos|'`
+ ;;
+ -linux-dietlibc)
+ os=-linux-dietlibc
+ ;;
+ -linux*)
+ os=`echo $os | sed -e 's|linux|linux-gnu|'`
+ ;;
+ -sunos5*)
+ os=`echo $os | sed -e 's|sunos5|solaris2|'`
+ ;;
+ -sunos6*)
+ os=`echo $os | sed -e 's|sunos6|solaris3|'`
+ ;;
+ -opened*)
+ os=-openedition
+ ;;
+ -os400*)
+ os=-os400
+ ;;
+ -wince*)
+ os=-wince
+ ;;
+ -osfrose*)
+ os=-osfrose
+ ;;
+ -osf*)
+ os=-osf
+ ;;
+ -utek*)
+ os=-bsd
+ ;;
+ -dynix*)
+ os=-bsd
+ ;;
+ -acis*)
+ os=-aos
+ ;;
+ -atheos*)
+ os=-atheos
+ ;;
+ -syllable*)
+ os=-syllable
+ ;;
+ -386bsd)
+ os=-bsd
+ ;;
+ -ctix* | -uts*)
+ os=-sysv
+ ;;
+ -nova*)
+ os=-rtmk-nova
+ ;;
+ -ns2 )
+ os=-nextstep2
+ ;;
+ -nsk*)
+ os=-nsk
+ ;;
+ # Preserve the version number of sinix5.
+ -sinix5.*)
+ os=`echo $os | sed -e 's|sinix|sysv|'`
+ ;;
+ -sinix*)
+ os=-sysv4
+ ;;
+ -tpf*)
+ os=-tpf
+ ;;
+ -triton*)
+ os=-sysv3
+ ;;
+ -oss*)
+ os=-sysv3
+ ;;
+ -svr4)
+ os=-sysv4
+ ;;
+ -svr3)
+ os=-sysv3
+ ;;
+ -sysvr4)
+ os=-sysv4
+ ;;
+ # This must come after -sysvr4.
+ -sysv*)
+ ;;
+ -ose*)
+ os=-ose
+ ;;
+ -es1800*)
+ os=-ose
+ ;;
+ -xenix)
+ os=-xenix
+ ;;
+ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+ os=-mint
+ ;;
+ -aros*)
+ os=-aros
+ ;;
+ -zvmoe)
+ os=-zvmoe
+ ;;
+ -dicos*)
+ os=-dicos
+ ;;
+ -nacl*)
+ ;;
+ -none)
+ ;;
+ *)
+ # Get rid of the `-' at the beginning of $os.
+ os=`echo $os | sed 's/[^-]*-//'`
+ echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+ exit 1
+ ;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system. Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+ score-*)
+ os=-elf
+ ;;
+ spu-*)
+ os=-elf
+ ;;
+ *-acorn)
+ os=-riscix1.2
+ ;;
+ arm*-rebel)
+ os=-linux
+ ;;
+ arm*-semi)
+ os=-aout
+ ;;
+ c4x-* | tic4x-*)
+ os=-coff
+ ;;
+ c8051-*)
+ os=-elf
+ ;;
+ hexagon-*)
+ os=-elf
+ ;;
+ tic54x-*)
+ os=-coff
+ ;;
+ tic55x-*)
+ os=-coff
+ ;;
+ tic6x-*)
+ os=-coff
+ ;;
+ # This must come before the *-dec entry.
+ pdp10-*)
+ os=-tops20
+ ;;
+ pdp11-*)
+ os=-none
+ ;;
+ *-dec | vax-*)
+ os=-ultrix4.2
+ ;;
+ m68*-apollo)
+ os=-domain
+ ;;
+ i386-sun)
+ os=-sunos4.0.2
+ ;;
+ m68000-sun)
+ os=-sunos3
+ ;;
+ m68*-cisco)
+ os=-aout
+ ;;
+ mep-*)
+ os=-elf
+ ;;
+ mips*-cisco)
+ os=-elf
+ ;;
+ mips*-*)
+ os=-elf
+ ;;
+ or1k-*)
+ os=-elf
+ ;;
+ or32-*)
+ os=-coff
+ ;;
+ *-tti) # must be before sparc entry or we get the wrong os.
+ os=-sysv3
+ ;;
+ sparc-* | *-sun)
+ os=-sunos4.1.1
+ ;;
+ *-be)
+ os=-beos
+ ;;
+ *-haiku)
+ os=-haiku
+ ;;
+ *-ibm)
+ os=-aix
+ ;;
+ *-knuth)
+ os=-mmixware
+ ;;
+ *-wec)
+ os=-proelf
+ ;;
+ *-winbond)
+ os=-proelf
+ ;;
+ *-oki)
+ os=-proelf
+ ;;
+ *-hp)
+ os=-hpux
+ ;;
+ *-hitachi)
+ os=-hiux
+ ;;
+ i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+ os=-sysv
+ ;;
+ *-cbm)
+ os=-amigaos
+ ;;
+ *-dg)
+ os=-dgux
+ ;;
+ *-dolphin)
+ os=-sysv3
+ ;;
+ m68k-ccur)
+ os=-rtu
+ ;;
+ m88k-omron*)
+ os=-luna
+ ;;
+ *-next )
+ os=-nextstep
+ ;;
+ *-sequent)
+ os=-ptx
+ ;;
+ *-crds)
+ os=-unos
+ ;;
+ *-ns)
+ os=-genix
+ ;;
+ i370-*)
+ os=-mvs
+ ;;
+ *-next)
+ os=-nextstep3
+ ;;
+ *-gould)
+ os=-sysv
+ ;;
+ *-highlevel)
+ os=-bsd
+ ;;
+ *-encore)
+ os=-bsd
+ ;;
+ *-sgi)
+ os=-irix
+ ;;
+ *-siemens)
+ os=-sysv4
+ ;;
+ *-masscomp)
+ os=-rtu
+ ;;
+ f30[01]-fujitsu | f700-fujitsu)
+ os=-uxpv
+ ;;
+ *-rom68k)
+ os=-coff
+ ;;
+ *-*bug)
+ os=-coff
+ ;;
+ *-apple)
+ os=-macos
+ ;;
+ *-atari*)
+ os=-mint
+ ;;
+ *)
+ os=-none
+ ;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer. We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+ *-unknown)
+ case $os in
+ -riscix*)
+ vendor=acorn
+ ;;
+ -sunos*)
+ vendor=sun
+ ;;
+ -cnk*|-aix*)
+ vendor=ibm
+ ;;
+ -beos*)
+ vendor=be
+ ;;
+ -hpux*)
+ vendor=hp
+ ;;
+ -mpeix*)
+ vendor=hp
+ ;;
+ -hiux*)
+ vendor=hitachi
+ ;;
+ -unos*)
+ vendor=crds
+ ;;
+ -dgux*)
+ vendor=dg
+ ;;
+ -luna*)
+ vendor=omron
+ ;;
+ -genix*)
+ vendor=ns
+ ;;
+ -mvs* | -opened*)
+ vendor=ibm
+ ;;
+ -os400*)
+ vendor=ibm
+ ;;
+ -ptx*)
+ vendor=sequent
+ ;;
+ -tpf*)
+ vendor=ibm
+ ;;
+ -vxsim* | -vxworks* | -windiss*)
+ vendor=wrs
+ ;;
+ -aux*)
+ vendor=apple
+ ;;
+ -hms*)
+ vendor=hitachi
+ ;;
+ -mpw* | -macos*)
+ vendor=apple
+ ;;
+ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+ vendor=atari
+ ;;
+ -vos*)
+ vendor=stratus
+ ;;
+ esac
+ basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+ ;;
+esac
+
+echo $basic_machine$os
+exit
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
--- /dev/null
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69 for OpenFst 1.6.0.
+#
+# Report bugs to <help@www.openfst.org>.
+#
+#
+# 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 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='OpenFst'
+PACKAGE_TARNAME='openfst'
+PACKAGE_VERSION='1.6.0'
+PACKAGE_STRING='OpenFst 1.6.0'
+PACKAGE_BUGREPORT='help@www.openfst.org'
+PACKAGE_URL=''
+
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+# include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_unique_file="src/lib/fst.cc"
+ac_subst_vars='am__EXEEXT_FALSE
+am__EXEEXT_TRUE
+LTLIBOBJS
+LIBOBJS
+DL_LIBS
+libfstdir
+HAVE_GRM_FALSE
+HAVE_GRM_TRUE
+HAVE_SCRIPT_FALSE
+HAVE_SCRIPT_TRUE
+HAVE_BIN_FALSE
+HAVE_BIN_TRUE
+HAVE_SPECIAL_FALSE
+HAVE_SPECIAL_TRUE
+PYTHON_EXTRA_LDFLAGS
+PYTHON_EXTRA_LIBS
+PYTHON_SITE_PKG
+PYTHON_LDFLAGS
+PYTHON_CPPFLAGS
+pkgpyexecdir
+pyexecdir
+pkgpythondir
+pythondir
+PYTHON_PLATFORM
+PYTHON_EXEC_PREFIX
+PYTHON_PREFIX
+PYTHON_VERSION
+PYTHON
+HAVE_PYTHON_FALSE
+HAVE_PYTHON_TRUE
+HAVE_PDT_FALSE
+HAVE_PDT_TRUE
+HAVE_NGRAM_FALSE
+HAVE_NGRAM_TRUE
+HAVE_MPDT_FALSE
+HAVE_MPDT_TRUE
+HAVE_LOOKAHEAD_FALSE
+HAVE_LOOKAHEAD_TRUE
+HAVE_LINEAR_FALSE
+HAVE_LINEAR_TRUE
+HAVE_FAR_FALSE
+HAVE_FAR_TRUE
+HAVE_CONST_FALSE
+HAVE_CONST_TRUE
+HAVE_COMPRESS_FALSE
+HAVE_COMPRESS_TRUE
+HAVE_COMPACT_FALSE
+HAVE_COMPACT_TRUE
+CXXCPP
+CPP
+OTOOL64
+OTOOL
+LIPO
+NMEDIT
+DSYMUTIL
+MANIFEST_TOOL
+RANLIB
+DLLTOOL
+OBJDUMP
+LN_S
+NM
+ac_ct_DUMPBIN
+DUMPBIN
+LD
+FGREP
+EGREP
+GREP
+SED
+host_os
+host_vendor
+host_cpu
+host
+build_os
+build_vendor
+build_cpu
+build
+LIBTOOL
+am__fastdepCXX_FALSE
+am__fastdepCXX_TRUE
+CXXDEPMODE
+ac_ct_CXX
+CXXFLAGS
+CXX
+am__fastdepCC_FALSE
+am__fastdepCC_TRUE
+CCDEPMODE
+am__nodep
+AMDEPBACKSLASH
+AMDEP_FALSE
+AMDEP_TRUE
+am__quote
+am__include
+DEPDIR
+OBJEXT
+EXEEXT
+ac_ct_CC
+CPPFLAGS
+LDFLAGS
+CFLAGS
+CC
+ac_ct_AR
+AR
+AM_BACKSLASH
+AM_DEFAULT_VERBOSITY
+AM_DEFAULT_V
+AM_V
+am__untar
+am__tar
+AMTAR
+am__leading_dot
+SET_MAKE
+AWK
+mkdir_p
+MKDIR_P
+INSTALL_STRIP_PROGRAM
+STRIP
+install_sh
+MAKEINFO
+AUTOHEADER
+AUTOMAKE
+AUTOCONF
+ACLOCAL
+VERSION
+PACKAGE
+CYGPATH_W
+am__isrc
+INSTALL_DATA
+INSTALL_SCRIPT
+INSTALL_PROGRAM
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_silent_rules
+enable_dependency_tracking
+enable_static
+enable_shared
+with_pic
+enable_fast_install
+with_gnu_ld
+with_sysroot
+enable_libtool_lock
+enable_compact_fsts
+enable_compress
+enable_const_fsts
+enable_far
+enable_linear_fsts
+enable_lookahead_fsts
+enable_mpdt
+enable_ngram_fsts
+enable_pdt
+enable_python
+enable_special
+enable_bin
+enable_grm
+with_libfstdir
+'
+ ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CXX
+CXXFLAGS
+CCC
+CPP
+CXXCPP
+PYTHON
+PYTHON_VERSION'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+ # If the previous option needs an argument, assign it.
+ if test -n "$ac_prev"; then
+ eval $ac_prev=\$ac_option
+ ac_prev=
+ continue
+ fi
+
+ case $ac_option in
+ *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+ *=) ac_optarg= ;;
+ *) ac_optarg=yes ;;
+ esac
+
+ # Accept the important Cygnus configure options, so we can diagnose typos.
+
+ case $ac_dashdash$ac_option in
+ --)
+ ac_dashdash=yes ;;
+
+ -bindir | --bindir | --bindi | --bind | --bin | --bi)
+ ac_prev=bindir ;;
+ -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+ bindir=$ac_optarg ;;
+
+ -build | --build | --buil | --bui | --bu)
+ ac_prev=build_alias ;;
+ -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+ build_alias=$ac_optarg ;;
+
+ -cache-file | --cache-file | --cache-fil | --cache-fi \
+ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+ ac_prev=cache_file ;;
+ -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+ cache_file=$ac_optarg ;;
+
+ --config-cache | -C)
+ cache_file=config.cache ;;
+
+ -datadir | --datadir | --datadi | --datad)
+ ac_prev=datadir ;;
+ -datadir=* | --datadir=* | --datadi=* | --datad=*)
+ datadir=$ac_optarg ;;
+
+ -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+ | --dataroo | --dataro | --datar)
+ ac_prev=datarootdir ;;
+ -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+ datarootdir=$ac_optarg ;;
+
+ -disable-* | --disable-*)
+ ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+ as_fn_error $? "invalid feature name: $ac_useropt"
+ ac_useropt_orig=$ac_useropt
+ ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+ case $ac_user_opts in
+ *"
+"enable_$ac_useropt"
+"*) ;;
+ *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+ ac_unrecognized_sep=', ';;
+ esac
+ eval enable_$ac_useropt=no ;;
+
+ -docdir | --docdir | --docdi | --doc | --do)
+ ac_prev=docdir ;;
+ -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+ docdir=$ac_optarg ;;
+
+ -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+ ac_prev=dvidir ;;
+ -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+ dvidir=$ac_optarg ;;
+
+ -enable-* | --enable-*)
+ ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+ as_fn_error $? "invalid feature name: $ac_useropt"
+ ac_useropt_orig=$ac_useropt
+ ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+ case $ac_user_opts in
+ *"
+"enable_$ac_useropt"
+"*) ;;
+ *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+ ac_unrecognized_sep=', ';;
+ esac
+ eval enable_$ac_useropt=\$ac_optarg ;;
+
+ -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+ | --exec | --exe | --ex)
+ ac_prev=exec_prefix ;;
+ -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+ | --exec=* | --exe=* | --ex=*)
+ exec_prefix=$ac_optarg ;;
+
+ -gas | --gas | --ga | --g)
+ # Obsolete; use --with-gas.
+ with_gas=yes ;;
+
+ -help | --help | --hel | --he | -h)
+ ac_init_help=long ;;
+ -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+ ac_init_help=recursive ;;
+ -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+ ac_init_help=short ;;
+
+ -host | --host | --hos | --ho)
+ ac_prev=host_alias ;;
+ -host=* | --host=* | --hos=* | --ho=*)
+ host_alias=$ac_optarg ;;
+
+ -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+ ac_prev=htmldir ;;
+ -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+ | --ht=*)
+ htmldir=$ac_optarg ;;
+
+ -includedir | --includedir | --includedi | --included | --include \
+ | --includ | --inclu | --incl | --inc)
+ ac_prev=includedir ;;
+ -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+ | --includ=* | --inclu=* | --incl=* | --inc=*)
+ includedir=$ac_optarg ;;
+
+ -infodir | --infodir | --infodi | --infod | --info | --inf)
+ ac_prev=infodir ;;
+ -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+ infodir=$ac_optarg ;;
+
+ -libdir | --libdir | --libdi | --libd)
+ ac_prev=libdir ;;
+ -libdir=* | --libdir=* | --libdi=* | --libd=*)
+ libdir=$ac_optarg ;;
+
+ -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+ | --libexe | --libex | --libe)
+ ac_prev=libexecdir ;;
+ -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+ | --libexe=* | --libex=* | --libe=*)
+ libexecdir=$ac_optarg ;;
+
+ -localedir | --localedir | --localedi | --localed | --locale)
+ ac_prev=localedir ;;
+ -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+ localedir=$ac_optarg ;;
+
+ -localstatedir | --localstatedir | --localstatedi | --localstated \
+ | --localstate | --localstat | --localsta | --localst | --locals)
+ ac_prev=localstatedir ;;
+ -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+ localstatedir=$ac_optarg ;;
+
+ -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+ ac_prev=mandir ;;
+ -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+ mandir=$ac_optarg ;;
+
+ -nfp | --nfp | --nf)
+ # Obsolete; use --without-fp.
+ with_fp=no ;;
+
+ -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+ | --no-cr | --no-c | -n)
+ no_create=yes ;;
+
+ -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+ no_recursion=yes ;;
+
+ -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+ | --oldin | --oldi | --old | --ol | --o)
+ ac_prev=oldincludedir ;;
+ -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+ oldincludedir=$ac_optarg ;;
+
+ -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+ ac_prev=prefix ;;
+ -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+ prefix=$ac_optarg ;;
+
+ -program-prefix | --program-prefix | --program-prefi | --program-pref \
+ | --program-pre | --program-pr | --program-p)
+ ac_prev=program_prefix ;;
+ -program-prefix=* | --program-prefix=* | --program-prefi=* \
+ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+ program_prefix=$ac_optarg ;;
+
+ -program-suffix | --program-suffix | --program-suffi | --program-suff \
+ | --program-suf | --program-su | --program-s)
+ ac_prev=program_suffix ;;
+ -program-suffix=* | --program-suffix=* | --program-suffi=* \
+ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+ program_suffix=$ac_optarg ;;
+
+ -program-transform-name | --program-transform-name \
+ | --program-transform-nam | --program-transform-na \
+ | --program-transform-n | --program-transform- \
+ | --program-transform | --program-transfor \
+ | --program-transfo | --program-transf \
+ | --program-trans | --program-tran \
+ | --progr-tra | --program-tr | --program-t)
+ ac_prev=program_transform_name ;;
+ -program-transform-name=* | --program-transform-name=* \
+ | --program-transform-nam=* | --program-transform-na=* \
+ | --program-transform-n=* | --program-transform-=* \
+ | --program-transform=* | --program-transfor=* \
+ | --program-transfo=* | --program-transf=* \
+ | --program-trans=* | --program-tran=* \
+ | --progr-tra=* | --program-tr=* | --program-t=*)
+ program_transform_name=$ac_optarg ;;
+
+ -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+ ac_prev=pdfdir ;;
+ -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+ pdfdir=$ac_optarg ;;
+
+ -psdir | --psdir | --psdi | --psd | --ps)
+ ac_prev=psdir ;;
+ -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+ psdir=$ac_optarg ;;
+
+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+ | -silent | --silent | --silen | --sile | --sil)
+ silent=yes ;;
+
+ -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+ ac_prev=sbindir ;;
+ -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+ | --sbi=* | --sb=*)
+ sbindir=$ac_optarg ;;
+
+ -sharedstatedir | --sharedstatedir | --sharedstatedi \
+ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+ | --sharedst | --shareds | --shared | --share | --shar \
+ | --sha | --sh)
+ ac_prev=sharedstatedir ;;
+ -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+ | --sha=* | --sh=*)
+ sharedstatedir=$ac_optarg ;;
+
+ -site | --site | --sit)
+ ac_prev=site ;;
+ -site=* | --site=* | --sit=*)
+ site=$ac_optarg ;;
+
+ -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+ ac_prev=srcdir ;;
+ -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+ srcdir=$ac_optarg ;;
+
+ -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+ | --syscon | --sysco | --sysc | --sys | --sy)
+ ac_prev=sysconfdir ;;
+ -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+ sysconfdir=$ac_optarg ;;
+
+ -target | --target | --targe | --targ | --tar | --ta | --t)
+ ac_prev=target_alias ;;
+ -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+ target_alias=$ac_optarg ;;
+
+ -v | -verbose | --verbose | --verbos | --verbo | --verb)
+ verbose=yes ;;
+
+ -version | --version | --versio | --versi | --vers | -V)
+ ac_init_version=: ;;
+
+ -with-* | --with-*)
+ ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+ as_fn_error $? "invalid package name: $ac_useropt"
+ ac_useropt_orig=$ac_useropt
+ ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+ case $ac_user_opts in
+ *"
+"with_$ac_useropt"
+"*) ;;
+ *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+ ac_unrecognized_sep=', ';;
+ esac
+ eval with_$ac_useropt=\$ac_optarg ;;
+
+ -without-* | --without-*)
+ ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+ as_fn_error $? "invalid package name: $ac_useropt"
+ ac_useropt_orig=$ac_useropt
+ ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
+ case $ac_user_opts in
+ *"
+"with_$ac_useropt"
+"*) ;;
+ *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+ ac_unrecognized_sep=', ';;
+ esac
+ eval with_$ac_useropt=no ;;
+
+ --x)
+ # Obsolete; use --with-x.
+ with_x=yes ;;
+
+ -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+ | --x-incl | --x-inc | --x-in | --x-i)
+ ac_prev=x_includes ;;
+ -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+ x_includes=$ac_optarg ;;
+
+ -x-libraries | --x-libraries | --x-librarie | --x-librari \
+ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+ ac_prev=x_libraries ;;
+ -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+ x_libraries=$ac_optarg ;;
+
+ -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+ ;;
+
+ *=*)
+ ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+ # Reject names that are not valid shell variable names.
+ case $ac_envvar in #(
+ '' | [0-9]* | *[!_$as_cr_alnum]* )
+ as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+ esac
+ eval $ac_envvar=\$ac_optarg
+ export $ac_envvar ;;
+
+ *)
+ # FIXME: should be removed in autoconf 3.0.
+ $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+ expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+ $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+ : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+ ;;
+
+ esac
+done
+
+if test -n "$ac_prev"; then
+ ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+ as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+ case $enable_option_checking in
+ no) ;;
+ fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+ *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+ esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
+ datadir sysconfdir sharedstatedir localstatedir includedir \
+ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+ libdir localedir mandir
+do
+ eval ac_val=\$$ac_var
+ # Remove trailing slashes.
+ case $ac_val in
+ */ )
+ ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
+ eval $ac_var=\$ac_val;;
+ esac
+ # Be sure to have absolute directory names.
+ case $ac_val in
+ [\\/$]* | ?:[\\/]* ) continue;;
+ NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+ esac
+ as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+ if test "x$build_alias" = x; then
+ cross_compiling=maybe
+ elif test "x$build_alias" != "x$host_alias"; then
+ cross_compiling=yes
+ fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+ as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+ as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+ ac_srcdir_defaulted=yes
+ # Try the directory containing this script, then the parent directory.
+ ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$as_myself" : 'X\(//\)[^/]' \| \
+ X"$as_myself" : 'X\(//\)$' \| \
+ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+ srcdir=$ac_confdir
+ if test ! -r "$srcdir/$ac_unique_file"; then
+ srcdir=..
+ fi
+else
+ ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+ test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+ as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+ cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+ pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+ srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+ eval ac_env_${ac_var}_set=\${${ac_var}+set}
+ eval ac_env_${ac_var}_value=\$${ac_var}
+ eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+ eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+ # Omit some internal or obsolete options to make the list less imposing.
+ # This message is too long to be a string in the A/UX 3.1 sh.
+ cat <<_ACEOF
+\`configure' configures OpenFst 1.6.0 to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE. See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+ -h, --help display this help and exit
+ --help=short display options specific to this package
+ --help=recursive display the short help of all the included packages
+ -V, --version display version information and exit
+ -q, --quiet, --silent do not print \`checking ...' messages
+ --cache-file=FILE cache test results in FILE [disabled]
+ -C, --config-cache alias for \`--cache-file=config.cache'
+ -n, --no-create do not create output files
+ --srcdir=DIR find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+ --prefix=PREFIX install architecture-independent files in PREFIX
+ [$ac_default_prefix]
+ --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
+ [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+ --bindir=DIR user executables [EPREFIX/bin]
+ --sbindir=DIR system admin executables [EPREFIX/sbin]
+ --libexecdir=DIR program executables [EPREFIX/libexec]
+ --sysconfdir=DIR read-only single-machine data [PREFIX/etc]
+ --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
+ --localstatedir=DIR modifiable single-machine data [PREFIX/var]
+ --libdir=DIR object code libraries [EPREFIX/lib]
+ --includedir=DIR C header files [PREFIX/include]
+ --oldincludedir=DIR C header files for non-gcc [/usr/include]
+ --datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
+ --datadir=DIR read-only architecture-independent data [DATAROOTDIR]
+ --infodir=DIR info documentation [DATAROOTDIR/info]
+ --localedir=DIR locale-dependent data [DATAROOTDIR/locale]
+ --mandir=DIR man documentation [DATAROOTDIR/man]
+ --docdir=DIR documentation root [DATAROOTDIR/doc/openfst]
+ --htmldir=DIR html documentation [DOCDIR]
+ --dvidir=DIR dvi documentation [DOCDIR]
+ --pdfdir=DIR pdf documentation [DOCDIR]
+ --psdir=DIR ps documentation [DOCDIR]
+_ACEOF
+
+ cat <<\_ACEOF
+
+Program names:
+ --program-prefix=PREFIX prepend PREFIX to installed program names
+ --program-suffix=SUFFIX append SUFFIX to installed program names
+ --program-transform-name=PROGRAM run sed PROGRAM on installed program names
+
+System types:
+ --build=BUILD configure for building on BUILD [guessed]
+ --host=HOST cross-compile to build programs to run on HOST [BUILD]
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+ case $ac_init_help in
+ short | recursive ) echo "Configuration of OpenFst 1.6.0:";;
+ esac
+ cat <<\_ACEOF
+
+Optional Features:
+ --disable-option-checking ignore unrecognized --enable/--with options
+ --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
+ --enable-FEATURE[=ARG] include FEATURE [ARG=yes]
+ --enable-silent-rules less verbose build output (undo: "make V=1")
+ --disable-silent-rules verbose build output (undo: "make V=0")
+ --enable-dependency-tracking
+ do not reject slow dependency extractors
+ --disable-dependency-tracking
+ speeds up one-time build
+ --enable-static[=PKGS] build static libraries [default=no]
+ --enable-shared[=PKGS] build shared libraries [default=yes]
+ --enable-fast-install[=PKGS]
+ optimize for fast installation [default=yes]
+ --disable-libtool-lock avoid locking (might break parallel builds)
+ --enable-compact-fsts enable CompactFst extensions
+ --enable-compress enable compression extension
+ --enable-const-fsts enable ConstFst extensions
+ --enable-far enable FAR extensions
+ --enable-linear-fsts enable LinearTagger/ClassifierFst extensions
+ --enable-lookahead-fsts enable LookAheadFst extensions
+ --enable-mpdt enable MPDT extensions
+ --enable-ngram-fsts enable NGramFst extension
+ --enable-pdt enable PDT extensions
+ --enable-python enable Python extensions
+ --enable-special enable special-matcher extensions
+ --enable-bin enable fst::script and command-line binaries
+ --enable-grm enable all dependencies of OpenGrm
+
+Optional Packages:
+ --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
+ --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
+ --with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use
+ both]
+ --with-gnu-ld assume the C compiler uses GNU ld [default=no]
+ --with-sysroot=DIR Search for dependent libraries within DIR
+ (or the compiler's sysroot if not specified).
+--with-libfstdir=DIR fst dynamic extensions [LIBDIR/fst]
+
+Some influential environment variables:
+ CC C compiler command
+ CFLAGS C compiler flags
+ LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
+ nonstandard directory <lib dir>
+ LIBS libraries to pass to the linker, e.g. -l<library>
+ CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+ you have headers in a nonstandard directory <include dir>
+ CXX C++ compiler command
+ CXXFLAGS C++ compiler flags
+ CPP C preprocessor
+ CXXCPP C++ preprocessor
+ PYTHON the Python interpreter
+ PYTHON_VERSION
+ The installed Python version to use, for example '2.3'. This
+ string will be appended to the Python interpreter canonical
+ name.
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <help@www.openfst.org>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+ # If there are subdirs, report their specific --help.
+ for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+ test -d "$ac_dir" ||
+ { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+ continue
+ ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+ ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+ # A ".." for each directory in $ac_dir_suffix.
+ ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+ case $ac_top_builddir_sub in
+ "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+ *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+ esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+ .) # We are building in place.
+ ac_srcdir=.
+ ac_top_srcdir=$ac_top_builddir_sub
+ ac_abs_top_srcdir=$ac_pwd ;;
+ [\\/]* | ?:[\\/]* ) # Absolute name.
+ ac_srcdir=$srcdir$ac_dir_suffix;
+ ac_top_srcdir=$srcdir
+ ac_abs_top_srcdir=$srcdir ;;
+ *) # Relative name.
+ ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+ ac_top_srcdir=$ac_top_build_prefix$srcdir
+ ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+ cd "$ac_dir" || { ac_status=$?; continue; }
+ # Check for guested configure.
+ if test -f "$ac_srcdir/configure.gnu"; then
+ echo &&
+ $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+ elif test -f "$ac_srcdir/configure"; then
+ echo &&
+ $SHELL "$ac_srcdir/configure" --help=recursive
+ else
+ $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+ fi || ac_status=$?
+ cd "$ac_pwd" || { ac_status=$?; break; }
+ done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+ cat <<\_ACEOF
+OpenFst configure 1.6.0
+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 <limits.h> declares $2.
+ For example, HP-UX 11i <limits.h> declares gettimeofday. */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+ which can conflict with char $2 (); below.
+ Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+ <limits.h> exists even on freestanding compilers. */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+ to always fail with ENOSYS. Some functions are actually named
+ something starting with __ and the normal name is an alias. */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ eval "$3=yes"
+else
+ eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+ eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+
+# ac_fn_cxx_try_cpp LINENO
+# ------------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_cpp ()
+{
+ as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+ if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+ ac_status=$?
+ if test -s conftest.err; then
+ grep -v '^ *+' conftest.err >conftest.er1
+ cat conftest.er1 >&5
+ mv -f conftest.er1 conftest.err
+ fi
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } > conftest.i && {
+ test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
+ test ! -s conftest.err
+ }; then :
+ ac_retval=0
+else
+ $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ ac_retval=1
+fi
+ eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+ as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_cpp
+
+# ac_fn_cxx_try_link LINENO
+# -------------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_link ()
+{
+ as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+ rm -f conftest.$ac_objext conftest$ac_exeext
+ if { { ac_try="$ac_link"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+ (eval "$ac_link") 2>conftest.err
+ ac_status=$?
+ if test -s conftest.err; then
+ grep -v '^ *+' conftest.err >conftest.er1
+ cat conftest.er1 >&5
+ mv -f conftest.er1 conftest.err
+ fi
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } && {
+ test -z "$ac_cxx_werror_flag" ||
+ test ! -s conftest.err
+ } && test -s conftest$ac_exeext && {
+ test "$cross_compiling" = yes ||
+ test -x conftest$ac_exeext
+ }; then :
+ ac_retval=0
+else
+ $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ ac_retval=1
+fi
+ # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+ # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+ # interfere with the next link command; also delete a directory that is
+ # left behind by Apple's compiler. We do this before executing the actions.
+ rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+ eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+ as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_link
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by OpenFst $as_me 1.6.0, which was
+generated by GNU Autoconf 2.69. Invocation command line was
+
+ $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
+
+/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
+/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
+/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
+/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
+/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ $as_echo "PATH: $as_dir"
+ done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+ for ac_arg
+ do
+ case $ac_arg in
+ -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+ | -silent | --silent | --silen | --sile | --sil)
+ continue ;;
+ *\'*)
+ ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ esac
+ case $ac_pass in
+ 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+ 2)
+ as_fn_append ac_configure_args1 " '$ac_arg'"
+ if test $ac_must_keep_next = true; then
+ ac_must_keep_next=false # Got value, back to normal.
+ else
+ case $ac_arg in
+ *=* | --config-cache | -C | -disable-* | --disable-* \
+ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+ | -with-* | --with-* | -without-* | --without-* | --x)
+ case "$ac_configure_args0 " in
+ "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+ esac
+ ;;
+ -* ) ac_must_keep_next=true ;;
+ esac
+ fi
+ as_fn_append ac_configure_args " '$ac_arg'"
+ ;;
+ esac
+ done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log. We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+ # Save into config.log some information that might help in debugging.
+ {
+ echo
+
+ $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+ echo
+ # The following way of writing the cache mishandles newlines in values,
+(
+ for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+ eval ac_val=\$$ac_var
+ case $ac_val in #(
+ *${as_nl}*)
+ case $ac_var in #(
+ *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+ esac
+ case $ac_var in #(
+ _ | IFS | as_nl) ;; #(
+ BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+ *) { eval $ac_var=; unset $ac_var;} ;;
+ esac ;;
+ esac
+ done
+ (set) 2>&1 |
+ case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+ *${as_nl}ac_space=\ *)
+ sed -n \
+ "s/'\''/'\''\\\\'\'''\''/g;
+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+ ;; #(
+ *)
+ sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+ ;;
+ esac |
+ sort
+)
+ echo
+
+ $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+ echo
+ for ac_var in $ac_subst_vars
+ do
+ eval ac_val=\$$ac_var
+ case $ac_val in
+ *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+ esac
+ $as_echo "$ac_var='\''$ac_val'\''"
+ done | sort
+ echo
+
+ if test -n "$ac_subst_files"; then
+ $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+ echo
+ for ac_var in $ac_subst_files
+ do
+ eval ac_val=\$$ac_var
+ case $ac_val in
+ *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+ esac
+ $as_echo "$ac_var='\''$ac_val'\''"
+ done | sort
+ echo
+ fi
+
+ if test -s confdefs.h; then
+ $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+ echo
+ cat confdefs.h
+ echo
+ fi
+ test "$ac_signal" != 0 &&
+ $as_echo "$as_me: caught signal $ac_signal"
+ $as_echo "$as_me: exit $exit_status"
+ } >&5
+ rm -f core *.core core.conftest.* &&
+ rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+ exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+ trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+ # We do not want a PATH search for config.site.
+ case $CONFIG_SITE in #((
+ -*) ac_site_file1=./$CONFIG_SITE;;
+ */*) ac_site_file1=$CONFIG_SITE;;
+ *) ac_site_file1=./$CONFIG_SITE;;
+ esac
+elif test "x$prefix" != xNONE; then
+ ac_site_file1=$prefix/share/config.site
+ ac_site_file2=$prefix/etc/config.site
+else
+ ac_site_file1=$ac_default_prefix/share/config.site
+ ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+ test "x$ac_site_file" = xNONE && continue
+ if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+ sed 's/^/| /' "$ac_site_file" >&5
+ . "$ac_site_file" \
+ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+ fi
+done
+
+if test -r "$cache_file"; then
+ # Some versions of bash will fail to source /dev/null (special files
+ # actually), so we avoid doing that. DJGPP emulates it as a regular file.
+ if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+ case $cache_file in
+ [\\/]* | ?:[\\/]* ) . "$cache_file";;
+ *) . "./$cache_file";;
+ esac
+ fi
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+ >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+ eval ac_old_set=\$ac_cv_env_${ac_var}_set
+ eval ac_new_set=\$ac_env_${ac_var}_set
+ eval ac_old_val=\$ac_cv_env_${ac_var}_value
+ eval ac_new_val=\$ac_env_${ac_var}_value
+ case $ac_old_set,$ac_new_set in
+ set,)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+ ac_cache_corrupted=: ;;
+ ,set)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+ ac_cache_corrupted=: ;;
+ ,);;
+ *)
+ if test "x$ac_old_val" != "x$ac_new_val"; then
+ # differences in whitespace do not lead to failure.
+ ac_old_val_w=`echo x $ac_old_val`
+ ac_new_val_w=`echo x $ac_new_val`
+ if test "$ac_old_val_w" != "$ac_new_val_w"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+ ac_cache_corrupted=:
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+ eval $ac_var=\$ac_old_val
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
+$as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
+ { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
+$as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
+ fi;;
+ esac
+ # Pass precious variables to config.status.
+ if test "$ac_new_set" = set; then
+ case $ac_new_val in
+ *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+ *) ac_arg=$ac_var=$ac_new_val ;;
+ esac
+ case " $ac_configure_args " in
+ *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
+ *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+ esac
+ fi
+done
+if $ac_cache_corrupted; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+ { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+ as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+am__api_version='1.14'
+
+ac_aux_dir=
+for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
+ if test -f "$ac_dir/install-sh"; then
+ ac_aux_dir=$ac_dir
+ ac_install_sh="$ac_aux_dir/install-sh -c"
+ break
+ elif test -f "$ac_dir/install.sh"; then
+ ac_aux_dir=$ac_dir
+ ac_install_sh="$ac_aux_dir/install.sh -c"
+ break
+ elif test -f "$ac_dir/shtool"; then
+ ac_aux_dir=$ac_dir
+ ac_install_sh="$ac_aux_dir/shtool install -c"
+ break
+ fi
+done
+if test -z "$ac_aux_dir"; then
+ as_fn_error $? "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
+
+
+# Find a good install program. We prefer a C program (faster),
+# so one script is as good as another. But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+$as_echo_n "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if ${ac_cv_path_install+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in #((
+ ./ | .// | /[cC]/* | \
+ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+ ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
+ /usr/ucb/* ) ;;
+ *)
+ # OSF1 and SCO ODT 3.0 have their own names for install.
+ # Don't use installbsd from OSF since it installs stuff as root
+ # by default.
+ for ac_prog in ginstall scoinst install; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+ if test $ac_prog = install &&
+ grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+ # AIX install. It has an incompatible calling convention.
+ :
+ elif test $ac_prog = install &&
+ grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+ # program-specific install script used by HP pwplus--don't use.
+ :
+ else
+ rm -rf conftest.one conftest.two conftest.dir
+ echo one > conftest.one
+ echo two > conftest.two
+ mkdir conftest.dir
+ if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
+ test -s conftest.one && test -s conftest.two &&
+ test -s conftest.dir/conftest.one &&
+ test -s conftest.dir/conftest.two
+ then
+ ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+ break 3
+ fi
+ fi
+ fi
+ done
+ done
+ ;;
+esac
+
+ done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+ if test "${ac_cv_path_install+set}" = set; then
+ INSTALL=$ac_cv_path_install
+ else
+ # As a last resort, use the slow shell script. Don't cache a
+ # value for INSTALL within a source directory, because that will
+ # break other packages using the cache if that directory is
+ # removed, or if the value is a relative name.
+ INSTALL=$ac_install_sh
+ fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+$as_echo "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+$as_echo_n "checking whether build environment is sane... " >&6; }
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name. Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+ *[\\\"\#\$\&\'\`$am_lf]*)
+ as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
+esac
+case $srcdir in
+ *[\\\"\#\$\&\'\`$am_lf\ \ ]*)
+ as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments. Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+ am_has_slept=no
+ for am_try in 1 2; do
+ echo "timestamp, slept: $am_has_slept" > conftest.file
+ set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+ if test "$*" = "X"; then
+ # -L didn't work.
+ set X `ls -t "$srcdir/configure" conftest.file`
+ fi
+ if test "$*" != "X $srcdir/configure conftest.file" \
+ && test "$*" != "X conftest.file $srcdir/configure"; then
+
+ # If neither matched, then we have a broken ls. This can happen
+ # if, for instance, CONFIG_SHELL is bash and it inherits a
+ # broken ls alias from the environment. This has actually
+ # happened. Such a system could not be considered "sane".
+ as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
+ alias in your environment" "$LINENO" 5
+ fi
+ if test "$2" = conftest.file || test $am_try -eq 2; then
+ break
+ fi
+ # Just in case.
+ sleep 1
+ am_has_slept=yes
+ done
+ test "$2" = conftest.file
+ )
+then
+ # Ok.
+ :
+else
+ as_fn_error $? "newly created file is older than distributed files!
+Check your system clock" "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+ ( sleep 1 ) &
+ am_sleep_pid=$!
+fi
+
+rm -f conftest.file
+
+test "$program_prefix" != NONE &&
+ program_transform_name="s&^&$program_prefix&;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+ program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+# Double any \ or $.
+# By default was `s,x,x', remove it if useless.
+ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
+program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
+
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+
+if test x"${MISSING+set}" != xset; then
+ case $am_aux_dir in
+ *\ * | *\ *)
+ MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+ *)
+ MISSING="\${SHELL} $am_aux_dir/missing" ;;
+ esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+ am_missing_run="$MISSING "
+else
+ am_missing_run=
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
+fi
+
+if test x"${install_sh}" != xset; then
+ case $am_aux_dir in
+ *\ * | *\ *)
+ install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+ *)
+ install_sh="\${SHELL} $am_aux_dir/install-sh"
+ esac
+fi
+
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip". However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+if test "$cross_compiling" != no; then
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$STRIP"; then
+ ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+ ac_ct_STRIP=$STRIP
+ # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_STRIP"; then
+ ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_STRIP="strip"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_STRIP" = x; then
+ STRIP=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ STRIP=$ac_ct_STRIP
+ fi
+else
+ STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
+$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
+if test -z "$MKDIR_P"; then
+ if ${ac_cv_path_mkdir+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_prog in mkdir gmkdir; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
+ case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
+ 'mkdir (GNU coreutils) '* | \
+ 'mkdir (coreutils) '* | \
+ 'mkdir (fileutils) '4.1*)
+ ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
+ break 3;;
+ esac
+ done
+ done
+ done
+IFS=$as_save_IFS
+
+fi
+
+ test -d ./--version && rmdir ./--version
+ if test "${ac_cv_path_mkdir+set}" = set; then
+ MKDIR_P="$ac_cv_path_mkdir -p"
+ else
+ # As a last resort, use the slow shell script. Don't cache a
+ # value for MKDIR_P within a source directory, because that will
+ # break other packages using the cache if that directory is
+ # removed, or if the value is a relative name.
+ MKDIR_P="$ac_install_sh -d"
+ fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+$as_echo "$MKDIR_P" >&6; }
+
+for ac_prog in gawk mawk nawk awk
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$AWK"; then
+ ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_AWK="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$AWK" && break
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+ @echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+ *@@@%%%=?*=@@@%%%*)
+ eval ac_cv_prog_make_${ac_make}_set=yes;;
+ *)
+ eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+ SET_MAKE=
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+ am__leading_dot=.
+else
+ am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+
+# Check whether --enable-silent-rules was given.
+if test "${enable_silent_rules+set}" = set; then :
+ enableval=$enable_silent_rules;
+fi
+
+case $enable_silent_rules in # (((
+ yes) AM_DEFAULT_VERBOSITY=0;;
+ no) AM_DEFAULT_VERBOSITY=1;;
+ *) AM_DEFAULT_VERBOSITY=1;;
+esac
+am_make=${MAKE-make}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
+if ${am_cv_make_support_nested_variables+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if $as_echo 'TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+ @$(TRUE)
+.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
+ am_cv_make_support_nested_variables=yes
+else
+ am_cv_make_support_nested_variables=no
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+$as_echo "$am_cv_make_support_nested_variables" >&6; }
+if test $am_cv_make_support_nested_variables = yes; then
+ AM_V='$(V)'
+ AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+ AM_V=$AM_DEFAULT_VERBOSITY
+ AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AM_BACKSLASH='\'
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+ # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+ # is not polluted with repeated "-I."
+ am__isrc=' -I$(srcdir)'
+ # test to see if srcdir already configured
+ if test -f $srcdir/config.status; then
+ as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+ fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+ if (cygpath --version) >/dev/null 2>/dev/null; then
+ CYGPATH_W='cygpath -w'
+ else
+ CYGPATH_W=echo
+ fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='openfst'
+ VERSION='1.6.0'
+
+
+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:
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+mkdir_p='$(MKDIR_P)'
+
+# We need awk for the "check" target. The system "awk" is bad on
+# some platforms.
+# Always define AMTAR for backward compatibility. Yes, it's still used
+# in the wild :-( We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar pax cpio none'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes. So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+ cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present. This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+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: <http://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+ as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
+ fi
+fi
+DEPDIR="${am__leading_dot}deps"
+
+ac_config_commands="$ac_config_commands depfiles"
+
+
+am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+ @echo this is the am__doit target
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
+$as_echo_n "checking for style of include used by $am_make... " >&6; }
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# Ignore all kinds of additional output from 'make'.
+case `$am_make -s -f confmf 2> /dev/null` in #(
+*the\ am__doit\ target*)
+ am__include=include
+ am__quote=
+ _am_result=GNU
+ ;;
+esac
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+ echo '.include "confinc"' > confmf
+ case `$am_make -s -f confmf 2> /dev/null` in #(
+ *the\ am__doit\ target*)
+ am__include=.include
+ am__quote="\""
+ _am_result=BSD
+ ;;
+ esac
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
+$as_echo "$_am_result" >&6; }
+rm -f confinc confmf
+
+# Check whether --enable-dependency-tracking was given.
+if test "${enable_dependency_tracking+set}" = set; then :
+ enableval=$enable_dependency_tracking;
+fi
+
+if test "x$enable_dependency_tracking" != xno; then
+ am_depcomp="$ac_aux_dir/depcomp"
+ AMDEPBACKSLASH='\'
+ am__nodep='_no'
+fi
+ if test "x$enable_dependency_tracking" != xno; then
+ AMDEP_TRUE=
+ AMDEP_FALSE='#'
+else
+ AMDEP_TRUE='#'
+ AMDEP_FALSE=
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CC="${ac_tool_prefix}gcc"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+ ac_ct_CC=$CC
+ # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_CC"; then
+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_CC="gcc"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_CC" = x; then
+ CC=""
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ CC=$ac_ct_CC
+ fi
+else
+ CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CC="${ac_tool_prefix}cc"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ fi
+fi
+if test -z "$CC"; then
+ # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+ ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+ ac_prog_rejected=yes
+ continue
+ fi
+ ac_cv_prog_CC="cc"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+ # We found a bogon in the path, so make sure we never use it.
+ set dummy $ac_cv_prog_CC
+ shift
+ if test $# != 0; then
+ # We chose a different compiler from the bogus one.
+ # However, it has the same basename, so the bogon will be chosen
+ # first if we set CC to just the basename; use the full file name.
+ shift
+ ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+ fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+ if test -n "$ac_tool_prefix"; then
+ for ac_prog in cl.exe
+ do
+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$CC" && break
+ done
+fi
+if test -z "$CC"; then
+ ac_ct_CC=$CC
+ for ac_prog in cl.exe
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_CC"; then
+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_CC="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$ac_ct_CC" && break
+done
+
+ if test "x$ac_ct_CC" = x; then
+ CC=""
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ CC=$ac_ct_CC
+ fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+ { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+ (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+ ac_status=$?
+ if test -s conftest.err; then
+ sed '10a\
+... rest of stderr output deleted ...
+ 10q' conftest.err >conftest.er1
+ cat conftest.er1 >&5
+ fi
+ rm -f conftest.er1 conftest.err
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+ case $ac_file in
+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+ * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+ esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+ (eval "$ac_link_default") 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then :
+ # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile. We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+ test -f "$ac_file" || continue
+ case $ac_file in
+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+ ;;
+ [ab].out )
+ # We found the default executable, but exeext='' is most
+ # certainly right.
+ break;;
+ *.* )
+ if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+ then :; else
+ ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+ fi
+ # We set ac_cv_exeext here because the later test for it is not
+ # safe: cross compilers may not add the suffix if given an `-o'
+ # argument, so we may need to know it at that point already.
+ # Even if this section looks crufty: it has the advantage of
+ # actually working.
+ break;;
+ * )
+ break;;
+ esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+ ac_file=''
+fi
+if test -z "$ac_file"; then :
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+ (eval "$ac_link") 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then :
+ # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+ test -f "$ac_file" || continue
+ case $ac_file in
+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+ *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+ break;;
+ * ) break;;
+ esac
+done
+else
+ { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#include <stdio.h>
+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 <stdarg.h>
+#include <stdio.h>
+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
+
+
+CPPFLAGS="$CPPFLAGS -funsigned-char"
+CXXFLAGS="$CXXFLAGS -std=c++11"
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+if test -z "$CXX"; then
+ if test -n "$CCC"; then
+ CXX=$CCC
+ else
+ if test -n "$ac_tool_prefix"; then
+ for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+ do
+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$CXX"; then
+ ac_cv_prog_CXX="$CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+CXX=$ac_cv_prog_CXX
+if test -n "$CXX"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
+$as_echo "$CXX" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$CXX" && break
+ done
+fi
+if test -z "$CXX"; then
+ ac_ct_CXX=$CXX
+ for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_CXX"; then
+ ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_CXX="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
+if test -n "$ac_ct_CXX"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
+$as_echo "$ac_ct_CXX" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$ac_ct_CXX" && break
+done
+
+ if test "x$ac_ct_CXX" = x; then
+ CXX="g++"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ CXX=$ac_ct_CXX
+ fi
+fi
+
+ fi
+fi
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+ { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+ *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+ (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+ ac_status=$?
+ if test -s conftest.err; then
+ sed '10a\
+... rest of stderr output deleted ...
+ 10q' conftest.err >conftest.er1
+ cat conftest.er1 >&5
+ fi
+ rm -f conftest.er1 conftest.err
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
+$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
+if ${ac_cv_cxx_compiler_gnu+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+#ifndef __GNUC__
+ choke me
+#endif
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+ ac_compiler_gnu=yes
+else
+ ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
+$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+ GXX=yes
+else
+ GXX=
+fi
+ac_test_CXXFLAGS=${CXXFLAGS+set}
+ac_save_CXXFLAGS=$CXXFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
+$as_echo_n "checking whether $CXX accepts -g... " >&6; }
+if ${ac_cv_prog_cxx_g+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_save_cxx_werror_flag=$ac_cxx_werror_flag
+ ac_cxx_werror_flag=yes
+ ac_cv_prog_cxx_g=no
+ CXXFLAGS="-g"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+ ac_cv_prog_cxx_g=yes
+else
+ CXXFLAGS=""
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+else
+ ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+ CXXFLAGS="-g"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+ ac_cv_prog_cxx_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
+$as_echo "$ac_cv_prog_cxx_g" >&6; }
+if test "$ac_test_CXXFLAGS" = set; then
+ CXXFLAGS=$ac_save_CXXFLAGS
+elif test $ac_cv_prog_cxx_g = yes; then
+ if test "$GXX" = yes; then
+ CXXFLAGS="-g -O2"
+ else
+ CXXFLAGS="-g"
+ fi
+else
+ if test "$GXX" = yes; then
+ CXXFLAGS="-O2"
+ else
+ CXXFLAGS=
+ fi
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+depcc="$CXX" am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CXX_dependencies_compiler_type+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+ # We make a subdir and do the tests there. Otherwise we can end up
+ # making bogus files that we don't know about and never remove. For
+ # instance it was reported that on HP-UX the gcc test will end up
+ # making a dummy file named 'D' -- because '-MD' means "put the output
+ # in D".
+ rm -rf conftest.dir
+ mkdir conftest.dir
+ # Copy depcomp to subdir because otherwise we won't find it if we're
+ # using a relative directory.
+ cp "$am_depcomp" conftest.dir
+ cd conftest.dir
+ # We will build objects and dependencies in a subdirectory because
+ # it helps to detect inapplicable dependency modes. For instance
+ # both Tru64's cc and ICC support -MD to output dependencies as a
+ # side effect of compilation, but ICC will put the dependencies in
+ # the current directory while Tru64 will put them in the object
+ # directory.
+ mkdir sub
+
+ am_cv_CXX_dependencies_compiler_type=none
+ if test "$am_compiler_list" = ""; then
+ am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+ fi
+ am__universal=false
+ case " $depcc " in #(
+ *\ -arch\ *\ -arch\ *) am__universal=true ;;
+ esac
+
+ for depmode in $am_compiler_list; do
+ # Setup a source with many dependencies, because some compilers
+ # like to wrap large dependency lists on column 80 (with \), and
+ # we should not choose a depcomp mode which is confused by this.
+ #
+ # We need to recreate these files for each test, as the compiler may
+ # overwrite some of them when testing with obscure command lines.
+ # This happens at least with the AIX C compiler.
+ : > sub/conftest.c
+ for i in 1 2 3 4 5 6; do
+ echo '#include "conftst'$i'.h"' >> sub/conftest.c
+ # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+ # Solaris 10 /bin/sh.
+ echo '/* dummy */' > sub/conftst$i.h
+ done
+ echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+ # We check with '-c' and '-o' for the sake of the "dashmstdout"
+ # mode. It turns out that the SunPro C++ compiler does not properly
+ # handle '-M -o', and we need to detect this. Also, some Intel
+ # versions had trouble with output in subdirs.
+ am__obj=sub/conftest.${OBJEXT-o}
+ am__minus_obj="-o $am__obj"
+ case $depmode in
+ gcc)
+ # This depmode causes a compiler race in universal mode.
+ test "$am__universal" = false || continue
+ ;;
+ nosideeffect)
+ # After this tag, mechanisms are not by side-effect, so they'll
+ # only be used when explicitly requested.
+ if test "x$enable_dependency_tracking" = xyes; then
+ continue
+ else
+ break
+ fi
+ ;;
+ msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+ # This compiler won't grok '-c -o', but also, the minuso test has
+ # not run yet. These depmodes are late enough in the game, and
+ # so weak that their functioning should not be impacted.
+ am__obj=conftest.${OBJEXT-o}
+ am__minus_obj=
+ ;;
+ none) break ;;
+ esac
+ if depmode=$depmode \
+ source=sub/conftest.c object=$am__obj \
+ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+ >/dev/null 2>conftest.err &&
+ grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+ grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+ grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+ ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+ # icc doesn't choke on unknown options, it will just issue warnings
+ # or remarks (even with -Werror). So we grep stderr for any message
+ # that says an option was ignored or not supported.
+ # When given -MP, icc 7.0 and 7.1 complain thusly:
+ # icc: Command line warning: ignoring option '-M'; no argument required
+ # The diagnosis changed in icc 8.0:
+ # icc: Command line remark: option '-MP' not supported
+ if (grep 'ignoring option' conftest.err ||
+ grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+ am_cv_CXX_dependencies_compiler_type=$depmode
+ break
+ fi
+ fi
+ done
+
+ cd ..
+ rm -rf conftest.dir
+else
+ am_cv_CXX_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
+CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
+
+ if
+ test "x$enable_dependency_tracking" != xno \
+ && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
+ am__fastdepCXX_TRUE=
+ am__fastdepCXX_FALSE='#'
+else
+ am__fastdepCXX_TRUE='#'
+ am__fastdepCXX_FALSE=
+fi
+
+
+# Check whether --enable-static was given.
+if test "${enable_static+set}" = set; then :
+ enableval=$enable_static; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_static=yes ;;
+ no) enable_static=no ;;
+ *)
+ enable_static=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for pkg in $enableval; do
+ IFS="$lt_save_ifs"
+ if test "X$pkg" = "X$p"; then
+ enable_static=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac
+else
+ enable_static=no
+fi
+
+
+
+
+
+
+
+
+
+case `pwd` in
+ *\ * | *\ *)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
+$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
+esac
+
+
+
+macro_version='2.4.2'
+macro_revision='1.3337'
+
+
+
+
+
+
+
+
+
+
+
+
+
+ltmain="$ac_aux_dir/ltmain.sh"
+
+# Make sure we can run config.sub.
+$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
+ as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+$as_echo_n "checking build system type... " >&6; }
+if ${ac_cv_build+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_build_alias=$build_alias
+test "x$ac_build_alias" = x &&
+ ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
+test "x$ac_build_alias" = x &&
+ as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
+ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
+ as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+$as_echo "$ac_cv_build" >&6; }
+case $ac_cv_build in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
+esac
+build=$ac_cv_build
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_build
+shift
+build_cpu=$1
+build_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+build_os=$*
+IFS=$ac_save_IFS
+case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+$as_echo_n "checking host system type... " >&6; }
+if ${ac_cv_host+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test "x$host_alias" = x; then
+ ac_cv_host=$ac_cv_build
+else
+ ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
+ as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+$as_echo "$ac_cv_host" >&6; }
+case $ac_cv_host in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
+esac
+host=$ac_cv_host
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_host
+shift
+host_cpu=$1
+host_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+host_os=$*
+IFS=$ac_save_IFS
+case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+
+
+# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
+$as_echo_n "checking how to print strings... " >&6; }
+# Test print first, because it will be a builtin if present.
+if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
+ test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+ ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+ ECHO='printf %s\n'
+else
+ # Use this function as a fallback that always works.
+ func_fallback_echo ()
+ {
+ eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+ }
+ ECHO='func_fallback_echo'
+fi
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+ $ECHO ""
+}
+
+case "$ECHO" in
+ printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
+$as_echo "printf" >&6; } ;;
+ print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
+$as_echo "print -r" >&6; } ;;
+ *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
+$as_echo "cat" >&6; } ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if ${ac_cv_path_SED+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+ for ac_i in 1 2 3 4 5 6 7; do
+ ac_script="$ac_script$as_nl$ac_script"
+ done
+ echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+ { ac_script=; unset ac_script;}
+ if test -z "$SED"; then
+ ac_path_SED_found=false
+ # Loop through the user's path and test for each of PROGNAME-LIST
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_prog in sed gsed; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+ as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+ # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+ ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+ ac_count=0
+ $as_echo_n 0123456789 >"conftest.in"
+ while :
+ do
+ cat "conftest.in" "conftest.in" >"conftest.tmp"
+ mv "conftest.tmp" "conftest.in"
+ cp "conftest.in" "conftest.nl"
+ $as_echo '' >> "conftest.nl"
+ "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+ as_fn_arith $ac_count + 1 && ac_count=$as_val
+ if test $ac_count -gt ${ac_path_SED_max-0}; then
+ # Best one so far, save it but keep looking for a better one
+ ac_cv_path_SED="$ac_path_SED"
+ ac_path_SED_max=$ac_count
+ fi
+ # 10*(2^10) chars as input seems more than enough
+ test $ac_count -gt 10 && break
+ done
+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+ $ac_path_SED_found && break 3
+ done
+ done
+ done
+IFS=$as_save_IFS
+ if test -z "$ac_cv_path_SED"; then
+ as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+ fi
+else
+ ac_cv_path_SED=$SED
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+ rm -f conftest.sed
+
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -z "$GREP"; then
+ ac_path_GREP_found=false
+ # Loop through the user's path and test for each of PROGNAME-LIST
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_prog in grep ggrep; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+ as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+ # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+ ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+ ac_count=0
+ $as_echo_n 0123456789 >"conftest.in"
+ while :
+ do
+ cat "conftest.in" "conftest.in" >"conftest.tmp"
+ mv "conftest.tmp" "conftest.in"
+ cp "conftest.in" "conftest.nl"
+ $as_echo 'GREP' >> "conftest.nl"
+ "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+ as_fn_arith $ac_count + 1 && ac_count=$as_val
+ if test $ac_count -gt ${ac_path_GREP_max-0}; then
+ # Best one so far, save it but keep looking for a better one
+ ac_cv_path_GREP="$ac_path_GREP"
+ ac_path_GREP_max=$ac_count
+ fi
+ # 10*(2^10) chars as input seems more than enough
+ test $ac_count -gt 10 && break
+ done
+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+ $ac_path_GREP_found && break 3
+ done
+ done
+ done
+IFS=$as_save_IFS
+ if test -z "$ac_cv_path_GREP"; then
+ as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+ fi
+else
+ ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+ then ac_cv_path_EGREP="$GREP -E"
+ else
+ if test -z "$EGREP"; then
+ ac_path_EGREP_found=false
+ # Loop through the user's path and test for each of PROGNAME-LIST
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_prog in egrep; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+ as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+ # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+ ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+ ac_count=0
+ $as_echo_n 0123456789 >"conftest.in"
+ while :
+ do
+ cat "conftest.in" "conftest.in" >"conftest.tmp"
+ mv "conftest.tmp" "conftest.in"
+ cp "conftest.in" "conftest.nl"
+ $as_echo 'EGREP' >> "conftest.nl"
+ "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+ as_fn_arith $ac_count + 1 && ac_count=$as_val
+ if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+ # Best one so far, save it but keep looking for a better one
+ ac_cv_path_EGREP="$ac_path_EGREP"
+ ac_path_EGREP_max=$ac_count
+ fi
+ # 10*(2^10) chars as input seems more than enough
+ test $ac_count -gt 10 && break
+ done
+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+ $ac_path_EGREP_found && break 3
+ done
+ done
+ done
+IFS=$as_save_IFS
+ if test -z "$ac_cv_path_EGREP"; then
+ as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+ fi
+else
+ ac_cv_path_EGREP=$EGREP
+fi
+
+ fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+$as_echo_n "checking for fgrep... " >&6; }
+if ${ac_cv_path_FGREP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+ then ac_cv_path_FGREP="$GREP -F"
+ else
+ if test -z "$FGREP"; then
+ ac_path_FGREP_found=false
+ # Loop through the user's path and test for each of PROGNAME-LIST
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_prog in fgrep; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
+ as_fn_executable_p "$ac_path_FGREP" || continue
+# Check for GNU ac_path_FGREP and select it if it is found.
+ # Check for GNU $ac_path_FGREP
+case `"$ac_path_FGREP" --version 2>&1` in
+*GNU*)
+ ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
+*)
+ ac_count=0
+ $as_echo_n 0123456789 >"conftest.in"
+ while :
+ do
+ cat "conftest.in" "conftest.in" >"conftest.tmp"
+ mv "conftest.tmp" "conftest.in"
+ cp "conftest.in" "conftest.nl"
+ $as_echo 'FGREP' >> "conftest.nl"
+ "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+ diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+ as_fn_arith $ac_count + 1 && ac_count=$as_val
+ if test $ac_count -gt ${ac_path_FGREP_max-0}; then
+ # Best one so far, save it but keep looking for a better one
+ ac_cv_path_FGREP="$ac_path_FGREP"
+ ac_path_FGREP_max=$ac_count
+ fi
+ # 10*(2^10) chars as input seems more than enough
+ test $ac_count -gt 10 && break
+ done
+ rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+ $ac_path_FGREP_found && break 3
+ done
+ done
+ done
+IFS=$as_save_IFS
+ if test -z "$ac_cv_path_FGREP"; then
+ as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+ fi
+else
+ ac_cv_path_FGREP=$FGREP
+fi
+
+ fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+$as_echo "$ac_cv_path_FGREP" >&6; }
+ FGREP="$ac_cv_path_FGREP"
+
+
+test -z "$GREP" && GREP=grep
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then :
+ withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+else
+ with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test "$GCC" = yes; then
+ # Check if gcc -print-prog-name=ld gives a path.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+$as_echo_n "checking for ld used by $CC... " >&6; }
+ case $host in
+ *-*-mingw*)
+ # gcc leaves a trailing carriage return which upsets mingw
+ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+ *)
+ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+ esac
+ case $ac_prog in
+ # Accept absolute paths.
+ [\\/]* | ?:[\\/]*)
+ re_direlt='/[^/][^/]*/\.\./'
+ # Canonicalize the pathname of ld
+ ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+ while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+ ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+ done
+ test -z "$LD" && LD="$ac_prog"
+ ;;
+ "")
+ # If it fails, then pretend we aren't using GCC.
+ ac_prog=ld
+ ;;
+ *)
+ # If it is relative, then search for the first ld in PATH.
+ with_gnu_ld=unknown
+ ;;
+ esac
+elif test "$with_gnu_ld" = yes; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+$as_echo_n "checking for GNU ld... " >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+$as_echo_n "checking for non-GNU ld... " >&6; }
+fi
+if ${lt_cv_path_LD+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -z "$LD"; then
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+ for ac_dir in $PATH; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+ lt_cv_path_LD="$ac_dir/$ac_prog"
+ # Check to see if the program is GNU ld. I'd rather use --version,
+ # but apparently some variants of GNU ld only accept -v.
+ # Break only if it was the GNU/non-GNU ld that we prefer.
+ case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+ *GNU* | *'with BFD'*)
+ test "$with_gnu_ld" != no && break
+ ;;
+ *)
+ test "$with_gnu_ld" != yes && break
+ ;;
+ esac
+ fi
+ done
+ IFS="$lt_save_ifs"
+else
+ lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi
+fi
+
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&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 </dev/null` in
+*GNU* | *'with BFD'*)
+ lt_cv_prog_gnu_ld=yes
+ ;;
+*)
+ lt_cv_prog_gnu_ld=no
+ ;;
+esac
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+$as_echo "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
+$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
+if ${lt_cv_path_NM+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$NM"; then
+ # Let the user override the test.
+ lt_cv_path_NM="$NM"
+else
+ lt_nm_to_check="${ac_tool_prefix}nm"
+ if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+ lt_nm_to_check="$lt_nm_to_check nm"
+ fi
+ for lt_tmp_nm in $lt_nm_to_check; do
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+ for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ tmp_nm="$ac_dir/$lt_tmp_nm"
+ if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+ # Check to see if the nm accepts a BSD-compat flag.
+ # Adding the `sed 1q' prevents false positives on HP-UX, which says:
+ # nm: unknown option "B" ignored
+ # Tru64's nm complains that /dev/null is an invalid object file
+ case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
+ */dev/null* | *'Invalid file or object type'*)
+ lt_cv_path_NM="$tmp_nm -B"
+ break
+ ;;
+ *)
+ case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+ */dev/null*)
+ lt_cv_path_NM="$tmp_nm -p"
+ break
+ ;;
+ *)
+ lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+ continue # so that we can try to find one that supports BSD flags
+ ;;
+ esac
+ ;;
+ esac
+ fi
+ done
+ IFS="$lt_save_ifs"
+ done
+ : ${lt_cv_path_NM=no}
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
+$as_echo "$lt_cv_path_NM" >&6; }
+if test "$lt_cv_path_NM" != "no"; then
+ NM="$lt_cv_path_NM"
+else
+ # Didn't find any BSD compatible name lister, look for dumpbin.
+ if test -n "$DUMPBIN"; then :
+ # Let the user override the test.
+ else
+ if test -n "$ac_tool_prefix"; then
+ for ac_prog in dumpbin "link -dump"
+ do
+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DUMPBIN+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$DUMPBIN"; then
+ ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+DUMPBIN=$ac_cv_prog_DUMPBIN
+if test -n "$DUMPBIN"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+$as_echo "$DUMPBIN" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$DUMPBIN" && break
+ done
+fi
+if test -z "$DUMPBIN"; then
+ ac_ct_DUMPBIN=$DUMPBIN
+ for ac_prog in dumpbin "link -dump"
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_DUMPBIN"; then
+ ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
+if test -n "$ac_ct_DUMPBIN"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
+$as_echo "$ac_ct_DUMPBIN" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$ac_ct_DUMPBIN" && break
+done
+
+ if test "x$ac_ct_DUMPBIN" = x; then
+ DUMPBIN=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ DUMPBIN=$ac_ct_DUMPBIN
+ fi
+fi
+
+ case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
+ *COFF*)
+ DUMPBIN="$DUMPBIN -symbols"
+ ;;
+ *)
+ DUMPBIN=:
+ ;;
+ esac
+ fi
+
+ if test "$DUMPBIN" != ":"; then
+ NM="$DUMPBIN"
+ fi
+fi
+test -z "$NM" && NM=nm
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
+$as_echo_n "checking the name lister ($NM) interface... " >&6; }
+if ${lt_cv_nm_interface+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_nm_interface="BSD nm"
+ echo "int some_variable = 0;" > conftest.$ac_ext
+ (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
+ (eval "$ac_compile" 2>conftest.err)
+ cat conftest.err >&5
+ (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
+ (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+ cat conftest.err >&5
+ (eval echo "\"\$as_me:$LINENO: output\"" >&5)
+ cat conftest.out >&5
+ if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+ lt_cv_nm_interface="MS dumpbin"
+ fi
+ rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
+$as_echo "$lt_cv_nm_interface" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
+$as_echo_n "checking whether ln -s works... " >&6; }
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
+$as_echo "no, using $LN_S" >&6; }
+fi
+
+# find the maximum length of command line arguments
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
+$as_echo_n "checking the maximum length of command line arguments... " >&6; }
+if ${lt_cv_sys_max_cmd_len+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ i=0
+ teststring="ABCD"
+
+ case $build_os in
+ msdosdjgpp*)
+ # On DJGPP, this test can blow up pretty badly due to problems in libc
+ # (any single argument exceeding 2000 bytes causes a buffer overrun
+ # during glob expansion). Even if it were fixed, the result of this
+ # check would be larger than it should be.
+ lt_cv_sys_max_cmd_len=12288; # 12K is about right
+ ;;
+
+ gnu*)
+ # Under GNU Hurd, this test is not required because there is
+ # no limit to the length of command line arguments.
+ # Libtool will interpret -1 as no limit whatsoever
+ lt_cv_sys_max_cmd_len=-1;
+ ;;
+
+ cygwin* | mingw* | cegcc*)
+ # On Win9x/ME, this test blows up -- it succeeds, but takes
+ # about 5 minutes as the teststring grows exponentially.
+ # Worse, since 9x/ME are not pre-emptively multitasking,
+ # you end up with a "frozen" computer, even though with patience
+ # the test eventually succeeds (with a max line length of 256k).
+ # Instead, let's just punt: use the minimum linelength reported by
+ # all of the supported platforms: 8192 (on NT/2K/XP).
+ lt_cv_sys_max_cmd_len=8192;
+ ;;
+
+ mint*)
+ # On MiNT this can take a long time and run out of memory.
+ lt_cv_sys_max_cmd_len=8192;
+ ;;
+
+ amigaos*)
+ # On AmigaOS with pdksh, this test takes hours, literally.
+ # So we just punt and use a minimum line length of 8192.
+ lt_cv_sys_max_cmd_len=8192;
+ ;;
+
+ netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+ # This has been around since 386BSD, at least. Likely further.
+ if test -x /sbin/sysctl; then
+ lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+ elif test -x /usr/sbin/sysctl; then
+ lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+ else
+ lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs
+ fi
+ # And add a safety zone
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+ ;;
+
+ interix*)
+ # We know the value 262144 and hardcode it with a safety zone (like BSD)
+ lt_cv_sys_max_cmd_len=196608
+ ;;
+
+ os2*)
+ # The test takes a long time on OS/2.
+ lt_cv_sys_max_cmd_len=8192
+ ;;
+
+ osf*)
+ # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+ # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+ # nice to cause kernel panics so lets avoid the loop below.
+ # First set a reasonable default.
+ lt_cv_sys_max_cmd_len=16384
+ #
+ if test -x /sbin/sysconfig; then
+ case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+ *1*) lt_cv_sys_max_cmd_len=-1 ;;
+ esac
+ fi
+ ;;
+ sco3.2v5*)
+ lt_cv_sys_max_cmd_len=102400
+ ;;
+ sysv5* | sco5v6* | sysv4.2uw2*)
+ kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+ if test -n "$kargmax"; then
+ lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ ]//'`
+ else
+ lt_cv_sys_max_cmd_len=32768
+ fi
+ ;;
+ *)
+ lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+ if test -n "$lt_cv_sys_max_cmd_len" && \
+ test undefined != "$lt_cv_sys_max_cmd_len"; then
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+ else
+ # Make teststring a little bigger before we do anything with it.
+ # a 1K string should be a reasonable start.
+ for i in 1 2 3 4 5 6 7 8 ; do
+ teststring=$teststring$teststring
+ done
+ SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+ # If test is not a shell built-in, we'll probably end up computing a
+ # maximum length that is only half of the actual maximum length, but
+ # we can't tell.
+ while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \
+ = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+ test $i != 17 # 1/2 MB should be enough
+ do
+ i=`expr $i + 1`
+ teststring=$teststring$teststring
+ done
+ # Only check the string length outside the loop.
+ lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+ teststring=
+ # Add a significant safety factor because C++ compilers can tack on
+ # massive amounts of additional arguments before passing them to the
+ # linker. It appears as though 1/2 is a usable value.
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+ fi
+ ;;
+ esac
+
+fi
+
+if test -n $lt_cv_sys_max_cmd_len ; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
+$as_echo "$lt_cv_sys_max_cmd_len" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
+$as_echo "none" >&6; }
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+
+
+
+
+
+: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5
+$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; }
+# Try some XSI features
+xsi_shell=no
+( _lt_dummy="a/b/c"
+ test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \
+ = c,a/b,b/c, \
+ && eval 'test $(( 1 + 1 )) -eq 2 \
+ && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
+ && xsi_shell=yes
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5
+$as_echo "$xsi_shell" >&6; }
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5
+$as_echo_n "checking whether the shell understands \"+=\"... " >&6; }
+lt_shell_append=no
+( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
+ >/dev/null 2>&1 \
+ && lt_shell_append=yes
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5
+$as_echo "$lt_shell_append" >&6; }
+
+
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+ lt_unset=unset
+else
+ lt_unset=false
+fi
+
+
+
+
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+ # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+ lt_SP2NL='tr \040 \012'
+ lt_NL2SP='tr \015\012 \040\040'
+ ;;
+ *) # EBCDIC based system
+ lt_SP2NL='tr \100 \n'
+ lt_NL2SP='tr \r\n \100\100'
+ ;;
+esac
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
+$as_echo_n "checking how to convert $build file names to $host format... " >&6; }
+if ${lt_cv_to_host_file_cmd+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ case $host in
+ *-*-mingw* )
+ case $build in
+ *-*-mingw* ) # actually msys
+ lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
+ ;;
+ *-*-cygwin* )
+ lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
+ ;;
+ * ) # otherwise, assume *nix
+ lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
+ ;;
+ esac
+ ;;
+ *-*-cygwin* )
+ case $build in
+ *-*-mingw* ) # actually msys
+ lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
+ ;;
+ *-*-cygwin* )
+ lt_cv_to_host_file_cmd=func_convert_file_noop
+ ;;
+ * ) # otherwise, assume *nix
+ lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
+ ;;
+ esac
+ ;;
+ * ) # unhandled hosts (and "normal" native builds)
+ lt_cv_to_host_file_cmd=func_convert_file_noop
+ ;;
+esac
+
+fi
+
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
+$as_echo "$lt_cv_to_host_file_cmd" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
+$as_echo_n "checking how to convert $build file names to toolchain format... " >&6; }
+if ${lt_cv_to_tool_file_cmd+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ #assume ordinary cross tools, or native build.
+lt_cv_to_tool_file_cmd=func_convert_file_noop
+case $host in
+ *-*-mingw* )
+ case $build in
+ *-*-mingw* ) # actually msys
+ lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
+ ;;
+ esac
+ ;;
+esac
+
+fi
+
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
+$as_echo "$lt_cv_to_tool_file_cmd" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
+$as_echo_n "checking for $LD option to reload object files... " >&6; }
+if ${lt_cv_ld_reload_flag+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_ld_reload_flag='-r'
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
+$as_echo "$lt_cv_ld_reload_flag" >&6; }
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+ cygwin* | mingw* | pw32* | cegcc*)
+ if test "$GCC" != yes; then
+ reload_cmds=false
+ fi
+ ;;
+ darwin*)
+ if test "$GCC" = yes; then
+ reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+ else
+ reload_cmds='$LD$reload_flag -o $output$reload_objs'
+ fi
+ ;;
+esac
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OBJDUMP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$OBJDUMP"; then
+ ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+$as_echo "$OBJDUMP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+ ac_ct_OBJDUMP=$OBJDUMP
+ # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_OBJDUMP"; then
+ ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_OBJDUMP="objdump"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+$as_echo "$ac_ct_OBJDUMP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_OBJDUMP" = x; then
+ OBJDUMP="false"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ OBJDUMP=$ac_ct_OBJDUMP
+ fi
+else
+ OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
+$as_echo_n "checking how to recognize dependent libraries... " >&6; }
+if ${lt_cv_deplibs_check_method+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given extended regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix[4-9]*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+beos*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+bsdi[45]*)
+ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
+ lt_cv_file_magic_cmd='/usr/bin/file -L'
+ lt_cv_file_magic_test_file=/shlib/libc.so
+ ;;
+
+cygwin*)
+ # func_win32_libid is a shell function defined in ltmain.sh
+ lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+ lt_cv_file_magic_cmd='func_win32_libid'
+ ;;
+
+mingw* | pw32*)
+ # Base MSYS/MinGW do not provide the 'file' command needed by
+ # func_win32_libid shell function, so use a weaker test based on 'objdump',
+ # unless we find 'file', for example because we are cross-compiling.
+ # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.
+ if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then
+ lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+ lt_cv_file_magic_cmd='func_win32_libid'
+ else
+ # Keep this pattern in sync with the one in func_win32_libid.
+ lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
+ lt_cv_file_magic_cmd='$OBJDUMP -f'
+ fi
+ ;;
+
+cegcc*)
+ # use the weaker test based on 'objdump'. See mingw*.
+ lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+ lt_cv_file_magic_cmd='$OBJDUMP -f'
+ ;;
+
+darwin* | rhapsody*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+freebsd* | dragonfly*)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+ case $host_cpu in
+ i*86 )
+ # Not sure whether the presence of OpenBSD here was a mistake.
+ # Let's accept both of them until this is cleared up.
+ lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
+ lt_cv_file_magic_cmd=/usr/bin/file
+ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+ ;;
+ esac
+ else
+ lt_cv_deplibs_check_method=pass_all
+ fi
+ ;;
+
+haiku*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+hpux10.20* | hpux11*)
+ lt_cv_file_magic_cmd=/usr/bin/file
+ case $host_cpu in
+ ia64*)
+ lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
+ lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+ ;;
+ hppa*64*)
+ lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'
+ lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+ ;;
+ *)
+ lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library'
+ lt_cv_file_magic_test_file=/usr/lib/libc.sl
+ ;;
+ esac
+ ;;
+
+interix[3-9]*)
+ # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+ lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
+ ;;
+
+irix5* | irix6* | nonstopux*)
+ case $LD in
+ *-32|*"-32 ") libmagic=32-bit;;
+ *-n32|*"-n32 ") libmagic=N32;;
+ *-64|*"-64 ") libmagic=64-bit;;
+ *) libmagic=never-match;;
+ esac
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+netbsd* | netbsdelf*-gnu)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+ lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+ else
+ lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
+ fi
+ ;;
+
+newos6*)
+ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
+ lt_cv_file_magic_cmd=/usr/bin/file
+ lt_cv_file_magic_test_file=/usr/lib/libnls.so
+ ;;
+
+*nto* | *qnx*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+openbsd*)
+ if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
+ else
+ lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
+ fi
+ ;;
+
+osf3* | osf4* | osf5*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+rdos*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+solaris*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+sysv4 | sysv4.3*)
+ case $host_vendor in
+ motorola)
+ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
+ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+ ;;
+ ncr)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+ sequent)
+ lt_cv_file_magic_cmd='/bin/file'
+ lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
+ ;;
+ sni)
+ lt_cv_file_magic_cmd='/bin/file'
+ lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
+ lt_cv_file_magic_test_file=/lib/libc.so
+ ;;
+ siemens)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+ pc)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+ esac
+ ;;
+
+tpf*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
+$as_echo "$lt_cv_deplibs_check_method" >&6; }
+
+file_magic_glob=
+want_nocaseglob=no
+if test "$build" = "$host"; then
+ case $host_os in
+ mingw* | pw32*)
+ if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
+ want_nocaseglob=yes
+ else
+ file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"`
+ fi
+ ;;
+ esac
+fi
+
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DLLTOOL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$DLLTOOL"; then
+ ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+DLLTOOL=$ac_cv_prog_DLLTOOL
+if test -n "$DLLTOOL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+$as_echo "$DLLTOOL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DLLTOOL"; then
+ ac_ct_DLLTOOL=$DLLTOOL
+ # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_DLLTOOL"; then
+ ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_DLLTOOL="dlltool"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
+if test -n "$ac_ct_DLLTOOL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+$as_echo "$ac_ct_DLLTOOL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_DLLTOOL" = x; then
+ DLLTOOL="false"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ DLLTOOL=$ac_ct_DLLTOOL
+ fi
+else
+ DLLTOOL="$ac_cv_prog_DLLTOOL"
+fi
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
+$as_echo_n "checking how to associate runtime and link libraries... " >&6; }
+if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_sharedlib_from_linklib_cmd='unknown'
+
+case $host_os in
+cygwin* | mingw* | pw32* | cegcc*)
+ # two different shell functions defined in ltmain.sh
+ # decide which to use based on capabilities of $DLLTOOL
+ case `$DLLTOOL --help 2>&1` in
+ *--identify-strict*)
+ lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
+ ;;
+ *)
+ lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
+ ;;
+ esac
+ ;;
+*)
+ # fallback: assume linklib IS sharedlib
+ lt_cv_sharedlib_from_linklib_cmd="$ECHO"
+ ;;
+esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
+$as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
+sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
+test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+ for ac_prog in ar
+ do
+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AR+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$AR"; then
+ ac_cv_prog_AR="$AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+AR=$ac_cv_prog_AR
+if test -n "$AR"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+$as_echo "$AR" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$AR" && break
+ done
+fi
+if test -z "$AR"; then
+ ac_ct_AR=$AR
+ for ac_prog in ar
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_AR+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_AR"; then
+ ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_AR="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_AR=$ac_cv_prog_ac_ct_AR
+if test -n "$ac_ct_AR"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+$as_echo "$ac_ct_AR" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$ac_ct_AR" && break
+done
+
+ if test "x$ac_ct_AR" = x; then
+ AR="false"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ AR=$ac_ct_AR
+ fi
+fi
+
+: ${AR=ar}
+: ${AR_FLAGS=cru}
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
+$as_echo_n "checking for archiver @FILE support... " >&6; }
+if ${lt_cv_ar_at_file+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_ar_at_file=no
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ echo conftest.$ac_objext > conftest.lst
+ lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5'
+ { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+ (eval $lt_ar_try) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }
+ if test "$ac_status" -eq 0; then
+ # Ensure the archiver fails upon bogus file names.
+ rm -f conftest.$ac_objext libconftest.a
+ { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+ (eval $lt_ar_try) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }
+ if test "$ac_status" -ne 0; then
+ lt_cv_ar_at_file=@
+ fi
+ fi
+ rm -f conftest.* libconftest.a
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
+$as_echo "$lt_cv_ar_at_file" >&6; }
+
+if test "x$lt_cv_ar_at_file" = xno; then
+ archiver_list_spec=
+else
+ archiver_list_spec=$lt_cv_ar_at_file
+fi
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$STRIP"; then
+ ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+ ac_ct_STRIP=$STRIP
+ # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_STRIP"; then
+ ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_STRIP="strip"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_STRIP" = x; then
+ STRIP=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ STRIP=$ac_ct_STRIP
+ fi
+else
+ STRIP="$ac_cv_prog_STRIP"
+fi
+
+test -z "$STRIP" && STRIP=:
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_RANLIB+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$RANLIB"; then
+ ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+$as_echo "$RANLIB" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+ ac_ct_RANLIB=$RANLIB
+ # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_RANLIB"; then
+ ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_RANLIB="ranlib"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+$as_echo "$ac_ct_RANLIB" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_RANLIB" = x; then
+ RANLIB=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ RANLIB=$ac_ct_RANLIB
+ fi
+else
+ RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+test -z "$RANLIB" && RANLIB=:
+
+
+
+
+
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+ case $host_os in
+ openbsd*)
+ old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
+ ;;
+ *)
+ old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
+ ;;
+ esac
+ old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
+fi
+
+case $host_os in
+ darwin*)
+ lock_old_archive_extraction=yes ;;
+ *)
+ lock_old_archive_extraction=no ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
+$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; }
+if ${lt_cv_sys_global_symbol_pipe+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix. What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[BCDEGRST]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+ symcode='[BCDT]'
+ ;;
+cygwin* | mingw* | pw32* | cegcc*)
+ symcode='[ABCDGISTW]'
+ ;;
+hpux*)
+ if test "$host_cpu" = ia64; then
+ symcode='[ABCDEGRST]'
+ fi
+ ;;
+irix* | nonstopux*)
+ symcode='[BCDEGRST]'
+ ;;
+osf*)
+ symcode='[BCDEGQRST]'
+ ;;
+solaris*)
+ symcode='[BDRT]'
+ ;;
+sco3.2v5*)
+ symcode='[DT]'
+ ;;
+sysv4.2uw2*)
+ symcode='[DT]'
+ ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+ symcode='[ABDT]'
+ ;;
+sysv4)
+ symcode='[DFNSTU]'
+ ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+ symcode='[ABCDGIRSTW]' ;;
+esac
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (void *) \&\2},/p'"
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"lib\2\", (void *) \&\2},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+ opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+ ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+ # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+ symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+ # Write the raw and C identifiers.
+ if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+ # Fake it for dumpbin and say T for any non-static function
+ # and D for any global variable.
+ # Also find C++ and __fastcall symbols from MSVC++,
+ # which start with @ or ?.
+ lt_cv_sys_global_symbol_pipe="$AWK '"\
+" {last_section=section; section=\$ 3};"\
+" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
+" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+" \$ 0!~/External *\|/{next};"\
+" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
+" {if(hide[section]) next};"\
+" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
+" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
+" s[1]~/^[@?]/{print s[1], s[1]; next};"\
+" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
+" ' prfx=^$ac_symprfx"
+ else
+ lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+ fi
+ lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+
+ # Check to see that the pipe works correctly.
+ pipe_works=no
+
+ rm -f conftest*
+ cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then
+ # Now try to grab the symbols.
+ nlist=conftest.nm
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5
+ (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } && test -s "$nlist"; then
+ # Try sorting and uniquifying the output.
+ if sort "$nlist" | uniq > "$nlist"T; then
+ mv -f "$nlist"T "$nlist"
+ else
+ rm -f "$nlist"T
+ fi
+
+ # Make sure that we snagged all the symbols we need.
+ if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+ if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+ cat <<_LT_EOF > conftest.$ac_ext
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+/* DATA imports from DLLs on WIN32 con't be const, because runtime
+ relocations are performed -- see ld's documentation on pseudo-relocs. */
+# define LT_DLSYM_CONST
+#elif defined(__osf__)
+/* This system does not cope well with relocations in const data. */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+ # Now generate the symbol file.
+ eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+ cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols. */
+LT_DLSYM_CONST struct {
+ const char *name;
+ void *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols[] =
+{
+ { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+ $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+ cat <<\_LT_EOF >> conftest.$ac_ext
+ {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+ return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+ # Now try linking the two files.
+ mv conftest.$ac_objext conftstm.$ac_objext
+ lt_globsym_save_LIBS=$LIBS
+ lt_globsym_save_CFLAGS=$CFLAGS
+ LIBS="conftstm.$ac_objext"
+ CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+ (eval $ac_link) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } && test -s conftest${ac_exeext}; then
+ pipe_works=yes
+ fi
+ LIBS=$lt_globsym_save_LIBS
+ CFLAGS=$lt_globsym_save_CFLAGS
+ else
+ echo "cannot find nm_test_func in $nlist" >&5
+ fi
+ else
+ echo "cannot find nm_test_var in $nlist" >&5
+ fi
+ else
+ echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
+ fi
+ else
+ echo "$progname: failed program was:" >&5
+ cat conftest.$ac_ext >&5
+ fi
+ rm -rf conftest* conftst*
+
+ # Do not use the global_symbol_pipe unless it works.
+ if test "$pipe_works" = yes; then
+ break
+ else
+ lt_cv_sys_global_symbol_pipe=
+ fi
+done
+
+fi
+
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+ lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
+$as_echo "failed" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+$as_echo "ok" >&6; }
+fi
+
+# Response file support.
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+ nm_file_list_spec='@'
+elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then
+ nm_file_list_spec='@'
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
+$as_echo_n "checking for sysroot... " >&6; }
+
+# Check whether --with-sysroot was given.
+if test "${with_sysroot+set}" = set; then :
+ withval=$with_sysroot;
+else
+ with_sysroot=no
+fi
+
+
+lt_sysroot=
+case ${with_sysroot} in #(
+ yes)
+ if test "$GCC" = yes; then
+ lt_sysroot=`$CC --print-sysroot 2>/dev/null`
+ fi
+ ;; #(
+ /*)
+ lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+ ;; #(
+ no|'')
+ ;; #(
+ *)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5
+$as_echo "${with_sysroot}" >&6; }
+ as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
+ ;;
+esac
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
+$as_echo "${lt_sysroot:-no}" >&6; }
+
+
+
+
+
+# Check whether --enable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then :
+ enableval=$enable_libtool_lock;
+fi
+
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+ # Find out which ABI we are using.
+ echo 'int i;' > conftest.$ac_ext
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then
+ case `/usr/bin/file conftest.$ac_objext` in
+ *ELF-32*)
+ HPUX_IA64_MODE="32"
+ ;;
+ *ELF-64*)
+ HPUX_IA64_MODE="64"
+ ;;
+ esac
+ fi
+ rm -rf conftest*
+ ;;
+*-*-irix6*)
+ # Find out which ABI we are using.
+ echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then
+ if test "$lt_cv_prog_gnu_ld" = yes; then
+ case `/usr/bin/file conftest.$ac_objext` in
+ *32-bit*)
+ LD="${LD-ld} -melf32bsmip"
+ ;;
+ *N32*)
+ LD="${LD-ld} -melf32bmipn32"
+ ;;
+ *64-bit*)
+ LD="${LD-ld} -melf64bmip"
+ ;;
+ esac
+ else
+ case `/usr/bin/file conftest.$ac_objext` in
+ *32-bit*)
+ LD="${LD-ld} -32"
+ ;;
+ *N32*)
+ LD="${LD-ld} -n32"
+ ;;
+ *64-bit*)
+ LD="${LD-ld} -64"
+ ;;
+ esac
+ fi
+ fi
+ rm -rf conftest*
+ ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+ # Find out which ABI we are using.
+ echo 'int i;' > conftest.$ac_ext
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then
+ case `/usr/bin/file conftest.o` in
+ *32-bit*)
+ case $host in
+ x86_64-*kfreebsd*-gnu)
+ LD="${LD-ld} -m elf_i386_fbsd"
+ ;;
+ x86_64-*linux*)
+ case `/usr/bin/file conftest.o` in
+ *x86-64*)
+ LD="${LD-ld} -m elf32_x86_64"
+ ;;
+ *)
+ LD="${LD-ld} -m elf_i386"
+ ;;
+ esac
+ ;;
+ powerpc64le-*)
+ LD="${LD-ld} -m elf32lppclinux"
+ ;;
+ powerpc64-*)
+ LD="${LD-ld} -m elf32ppclinux"
+ ;;
+ s390x-*linux*)
+ LD="${LD-ld} -m elf_s390"
+ ;;
+ sparc64-*linux*)
+ LD="${LD-ld} -m elf32_sparc"
+ ;;
+ esac
+ ;;
+ *64-bit*)
+ case $host in
+ x86_64-*kfreebsd*-gnu)
+ LD="${LD-ld} -m elf_x86_64_fbsd"
+ ;;
+ x86_64-*linux*)
+ LD="${LD-ld} -m elf_x86_64"
+ ;;
+ powerpcle-*)
+ LD="${LD-ld} -m elf64lppc"
+ ;;
+ powerpc-*)
+ LD="${LD-ld} -m elf64ppc"
+ ;;
+ s390*-*linux*|s390*-*tpf*)
+ LD="${LD-ld} -m elf64_s390"
+ ;;
+ sparc*-*linux*)
+ LD="${LD-ld} -m elf64_sparc"
+ ;;
+ esac
+ ;;
+ esac
+ fi
+ rm -rf conftest*
+ ;;
+
+*-*-sco3.2v5*)
+ # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+ SAVE_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS -belf"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
+$as_echo_n "checking whether the C compiler needs -belf... " >&6; }
+if ${lt_cv_cc_needs_belf+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ lt_cv_cc_needs_belf=yes
+else
+ lt_cv_cc_needs_belf=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
+$as_echo "$lt_cv_cc_needs_belf" >&6; }
+ if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+ # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+ CFLAGS="$SAVE_CFLAGS"
+ fi
+ ;;
+*-*solaris*)
+ # Find out which ABI we are using.
+ echo 'int i;' > conftest.$ac_ext
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then
+ case `/usr/bin/file conftest.o` in
+ *64-bit*)
+ case $lt_cv_prog_gnu_ld in
+ yes*)
+ case $host in
+ i?86-*-solaris*)
+ LD="${LD-ld} -m elf_x86_64"
+ ;;
+ sparc*-*-solaris*)
+ LD="${LD-ld} -m elf64_sparc"
+ ;;
+ esac
+ # GNU ld 2.21 introduced _sol2 emulations. Use them if available.
+ if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
+ LD="${LD-ld}_sol2"
+ fi
+ ;;
+ *)
+ if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+ LD="${LD-ld} -64"
+ fi
+ ;;
+ esac
+ ;;
+ esac
+ fi
+ rm -rf conftest*
+ ;;
+esac
+
+need_locks="$enable_libtool_lock"
+
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
+set dummy ${ac_tool_prefix}mt; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_MANIFEST_TOOL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$MANIFEST_TOOL"; then
+ ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
+if test -n "$MANIFEST_TOOL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
+$as_echo "$MANIFEST_TOOL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_MANIFEST_TOOL"; then
+ ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
+ # Extract the first word of "mt", so it can be a program name with args.
+set dummy mt; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_MANIFEST_TOOL"; then
+ ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
+if test -n "$ac_ct_MANIFEST_TOOL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
+$as_echo "$ac_ct_MANIFEST_TOOL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_MANIFEST_TOOL" = x; then
+ MANIFEST_TOOL=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
+ fi
+else
+ MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL"
+fi
+
+test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
+$as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
+if ${lt_cv_path_mainfest_tool+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_path_mainfest_tool=no
+ echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
+ $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
+ cat conftest.err >&5
+ if $GREP 'Manifest Tool' conftest.out > /dev/null; then
+ lt_cv_path_mainfest_tool=yes
+ fi
+ rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
+$as_echo "$lt_cv_path_mainfest_tool" >&6; }
+if test "x$lt_cv_path_mainfest_tool" != xyes; then
+ MANIFEST_TOOL=:
+fi
+
+
+
+
+
+
+ case $host_os in
+ rhapsody* | darwin*)
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DSYMUTIL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$DSYMUTIL"; then
+ ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+DSYMUTIL=$ac_cv_prog_DSYMUTIL
+if test -n "$DSYMUTIL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+$as_echo "$DSYMUTIL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DSYMUTIL"; then
+ ac_ct_DSYMUTIL=$DSYMUTIL
+ # Extract the first word of "dsymutil", so it can be a program name with args.
+set dummy dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_DSYMUTIL"; then
+ ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
+if test -n "$ac_ct_DSYMUTIL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
+$as_echo "$ac_ct_DSYMUTIL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_DSYMUTIL" = x; then
+ DSYMUTIL=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ DSYMUTIL=$ac_ct_DSYMUTIL
+ fi
+else
+ DSYMUTIL="$ac_cv_prog_DSYMUTIL"
+fi
+
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
+set dummy ${ac_tool_prefix}nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_NMEDIT+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$NMEDIT"; then
+ ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+NMEDIT=$ac_cv_prog_NMEDIT
+if test -n "$NMEDIT"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
+$as_echo "$NMEDIT" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_NMEDIT"; then
+ ac_ct_NMEDIT=$NMEDIT
+ # Extract the first word of "nmedit", so it can be a program name with args.
+set dummy nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_NMEDIT"; then
+ ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_NMEDIT="nmedit"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
+if test -n "$ac_ct_NMEDIT"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
+$as_echo "$ac_ct_NMEDIT" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_NMEDIT" = x; then
+ NMEDIT=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ NMEDIT=$ac_ct_NMEDIT
+ fi
+else
+ NMEDIT="$ac_cv_prog_NMEDIT"
+fi
+
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
+set dummy ${ac_tool_prefix}lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_LIPO+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$LIPO"; then
+ ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+LIPO=$ac_cv_prog_LIPO
+if test -n "$LIPO"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+$as_echo "$LIPO" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_LIPO"; then
+ ac_ct_LIPO=$LIPO
+ # Extract the first word of "lipo", so it can be a program name with args.
+set dummy lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_LIPO+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_LIPO"; then
+ ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_LIPO="lipo"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
+if test -n "$ac_ct_LIPO"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
+$as_echo "$ac_ct_LIPO" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_LIPO" = x; then
+ LIPO=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ LIPO=$ac_ct_LIPO
+ fi
+else
+ LIPO="$ac_cv_prog_LIPO"
+fi
+
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OTOOL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$OTOOL"; then
+ ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL=$ac_cv_prog_OTOOL
+if test -n "$OTOOL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
+$as_echo "$OTOOL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL"; then
+ ac_ct_OTOOL=$OTOOL
+ # Extract the first word of "otool", so it can be a program name with args.
+set dummy otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OTOOL+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_OTOOL"; then
+ ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_OTOOL="otool"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
+if test -n "$ac_ct_OTOOL"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
+$as_echo "$ac_ct_OTOOL" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_OTOOL" = x; then
+ OTOOL=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ OTOOL=$ac_ct_OTOOL
+ fi
+else
+ OTOOL="$ac_cv_prog_OTOOL"
+fi
+
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OTOOL64+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$OTOOL64"; then
+ ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL64=$ac_cv_prog_OTOOL64
+if test -n "$OTOOL64"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
+$as_echo "$OTOOL64" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL64"; then
+ ac_ct_OTOOL64=$OTOOL64
+ # Extract the first word of "otool64", so it can be a program name with args.
+set dummy otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_OTOOL64"; then
+ ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_OTOOL64="otool64"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
+if test -n "$ac_ct_OTOOL64"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
+$as_echo "$ac_ct_OTOOL64" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_OTOOL64" = x; then
+ OTOOL64=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ OTOOL64=$ac_ct_OTOOL64
+ fi
+else
+ OTOOL64="$ac_cv_prog_OTOOL64"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
+$as_echo_n "checking for -single_module linker flag... " >&6; }
+if ${lt_cv_apple_cc_single_mod+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_apple_cc_single_mod=no
+ if test -z "${LT_MULTI_MODULE}"; then
+ # By default we will add the -single_module flag. You can override
+ # by either setting the environment variable LT_MULTI_MODULE
+ # non-empty at configure time, or by adding -multi_module to the
+ # link flags.
+ rm -rf libconftest.dylib*
+ echo "int foo(void){return 1;}" > conftest.c
+ echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&5
+ $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+ -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+ _lt_result=$?
+ # If there is a non-empty error log, and "single_module"
+ # appears in it, assume the flag caused a linker warning
+ if test -s conftest.err && $GREP single_module conftest.err; then
+ cat conftest.err >&5
+ # Otherwise, if the output was created with a 0 exit code from
+ # the compiler, it worked.
+ elif test -f libconftest.dylib && test $_lt_result -eq 0; then
+ lt_cv_apple_cc_single_mod=yes
+ else
+ cat conftest.err >&5
+ fi
+ rm -rf libconftest.dylib*
+ rm -f conftest.*
+ fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
+$as_echo "$lt_cv_apple_cc_single_mod" >&6; }
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
+$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; }
+if ${lt_cv_ld_exported_symbols_list+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_ld_exported_symbols_list=no
+ save_LDFLAGS=$LDFLAGS
+ echo "_main" > conftest.sym
+ LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ lt_cv_ld_exported_symbols_list=yes
+else
+ lt_cv_ld_exported_symbols_list=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ LDFLAGS="$save_LDFLAGS"
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
+$as_echo "$lt_cv_ld_exported_symbols_list" >&6; }
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
+$as_echo_n "checking for -force_load linker flag... " >&6; }
+if ${lt_cv_ld_force_load+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_ld_force_load=no
+ cat > conftest.c << _LT_EOF
+int forced_loaded() { return 2;}
+_LT_EOF
+ echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
+ $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
+ echo "$AR cru libconftest.a conftest.o" >&5
+ $AR cru libconftest.a conftest.o 2>&5
+ echo "$RANLIB libconftest.a" >&5
+ $RANLIB libconftest.a 2>&5
+ cat > conftest.c << _LT_EOF
+int main() { return 0;}
+_LT_EOF
+ echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
+ $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
+ _lt_result=$?
+ if test -s conftest.err && $GREP force_load conftest.err; then
+ cat conftest.err >&5
+ elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
+ lt_cv_ld_force_load=yes
+ else
+ cat conftest.err >&5
+ fi
+ rm -f conftest.err libconftest.a conftest conftest.c
+ rm -rf conftest.dSYM
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
+$as_echo "$lt_cv_ld_force_load" >&6; }
+ case $host_os in
+ rhapsody* | darwin1.[012])
+ _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
+ darwin1.*)
+ _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+ darwin*) # darwin 5.x on
+ # if running on 10.5 or later, the deployment target defaults
+ # to the OS version, if on x86, and 10.4, the deployment
+ # target defaults to 10.4. Don't you love it?
+ case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+ 10.0,*86*-darwin8*|10.0,*-darwin[91]*)
+ _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+ 10.[012]*)
+ _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+ 10.*)
+ _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+ esac
+ ;;
+ esac
+ if test "$lt_cv_apple_cc_single_mod" = "yes"; then
+ _lt_dar_single_mod='$single_module'
+ fi
+ if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
+ _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
+ else
+ _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
+ fi
+ if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
+ _lt_dsymutil='~$DSYMUTIL $lib || :'
+ else
+ _lt_dsymutil=
+ fi
+ ;;
+ esac
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+ CPP=
+fi
+if test -z "$CPP"; then
+ if ${ac_cv_prog_CPP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ # Double quotes because CPP needs to be expanded
+ for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+ do
+ ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+ # Use a header file that comes with gcc, so configuring glibc
+ # with a fresh cross-compiler works.
+ # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+ # <limits.h> 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 <limits.h>
+#else
+# include <assert.h>
+#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 <ac_nonexistent.h>
+_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 <limits.h> to <assert.h> if __STDC__ is defined, since
+ # <limits.h> 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 <limits.h>
+#else
+# include <assert.h>
+#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 <ac_nonexistent.h>
+_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 <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+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 <string.h>
+
+_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 <stdlib.h>
+
+_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 <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+ (('a' <= (c) && (c) <= 'i') \
+ || ('j' <= (c) && (c) <= 'r') \
+ || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+ int i;
+ for (i = 0; i < 256; i++)
+ if (XOR (islower (i), ISLOWER (i))
+ || toupper (i) != TOUPPER (i))
+ return 2;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+ ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+ conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+ inttypes.h stdint.h unistd.h
+do :
+ as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+ cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+for ac_header in dlfcn.h
+do :
+ ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
+"
+if test "x$ac_cv_header_dlfcn_h" = xyes; then :
+ cat >>confdefs.h <<_ACEOF
+#define HAVE_DLFCN_H 1
+_ACEOF
+
+fi
+
+done
+
+
+
+
+func_stripname_cnf ()
+{
+ case ${2} in
+ .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
+ *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
+ esac
+} # func_stripname_cnf
+
+
+
+
+
+# Set options
+
+
+
+ enable_dlopen=no
+
+
+ enable_win32_dll=no
+
+
+ # Check whether --enable-shared was given.
+if test "${enable_shared+set}" = set; then :
+ enableval=$enable_shared; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_shared=yes ;;
+ no) enable_shared=no ;;
+ *)
+ enable_shared=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for pkg in $enableval; do
+ IFS="$lt_save_ifs"
+ if test "X$pkg" = "X$p"; then
+ enable_shared=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac
+else
+ enable_shared=yes
+fi
+
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-pic was given.
+if test "${with_pic+set}" = set; then :
+ withval=$with_pic; lt_p=${PACKAGE-default}
+ case $withval in
+ yes|no) pic_mode=$withval ;;
+ *)
+ pic_mode=default
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for lt_pkg in $withval; do
+ IFS="$lt_save_ifs"
+ if test "X$lt_pkg" = "X$lt_p"; then
+ pic_mode=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac
+else
+ pic_mode=default
+fi
+
+
+test -z "$pic_mode" && pic_mode=default
+
+
+
+
+
+
+
+ # Check whether --enable-fast-install was given.
+if test "${enable_fast_install+set}" = set; then :
+ enableval=$enable_fast_install; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_fast_install=yes ;;
+ no) enable_fast_install=no ;;
+ *)
+ enable_fast_install=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for pkg in $enableval; do
+ IFS="$lt_save_ifs"
+ if test "X$pkg" = "X$p"; then
+ enable_fast_install=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac
+else
+ enable_fast_install=yes
+fi
+
+
+
+
+
+
+
+
+
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ltmain"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+test -z "$LN_S" && LN_S="ln -s"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "${ZSH_VERSION+set}" ; then
+ setopt NO_GLOB_SUBST
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
+$as_echo_n "checking for objdir... " >&6; }
+if ${lt_cv_objdir+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+ lt_cv_objdir=.libs
+else
+ # MS-DOS does not allow filenames that begin with a dot.
+ lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
+$as_echo "$lt_cv_objdir" >&6; }
+objdir=$lt_cv_objdir
+
+
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define LT_OBJDIR "$lt_cv_objdir/"
+_ACEOF
+
+
+
+
+case $host_os in
+aix3*)
+ # AIX sometimes has problems with the GCC collect2 program. For some
+ # reason, if we set the COLLECT_NAMES environment variable, the problems
+ # vanish in a puff of smoke.
+ if test "X${COLLECT_NAMES+set}" != Xset; then
+ COLLECT_NAMES=
+ export COLLECT_NAMES
+ fi
+ ;;
+esac
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a `.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld="$lt_cv_prog_gnu_ld"
+
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+for cc_temp in $compiler""; do
+ case $cc_temp in
+ compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+ distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+ \-*) ;;
+ *) break;;
+ esac
+done
+cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+ if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
+$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; }
+if ${lt_cv_path_MAGIC_CMD+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ case $MAGIC_CMD in
+[\\/*] | ?:[\\/]*)
+ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+ ;;
+*)
+ lt_save_MAGIC_CMD="$MAGIC_CMD"
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+ ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+ for ac_dir in $ac_dummy; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ if test -f $ac_dir/${ac_tool_prefix}file; then
+ lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
+ if test -n "$file_magic_test_file"; then
+ case $deplibs_check_method in
+ "file_magic "*)
+ file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+ $EGREP "$file_magic_regex" > /dev/null; then
+ :
+ else
+ cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such. This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem. Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+ fi ;;
+ esac
+ fi
+ break
+ fi
+ done
+ IFS="$lt_save_ifs"
+ MAGIC_CMD="$lt_save_MAGIC_CMD"
+ ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+
+
+
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+ if test -n "$ac_tool_prefix"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5
+$as_echo_n "checking for file... " >&6; }
+if ${lt_cv_path_MAGIC_CMD+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ case $MAGIC_CMD in
+[\\/*] | ?:[\\/]*)
+ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+ ;;
+*)
+ lt_save_MAGIC_CMD="$MAGIC_CMD"
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+ ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+ for ac_dir in $ac_dummy; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ if test -f $ac_dir/file; then
+ lt_cv_path_MAGIC_CMD="$ac_dir/file"
+ if test -n "$file_magic_test_file"; then
+ case $deplibs_check_method in
+ "file_magic "*)
+ file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+ $EGREP "$file_magic_regex" > /dev/null; then
+ :
+ else
+ cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such. This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem. Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+ fi ;;
+ esac
+ fi
+ break
+ fi
+ done
+ IFS="$lt_save_ifs"
+ MAGIC_CMD="$lt_save_MAGIC_CMD"
+ ;;
+esac
+fi
+
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ else
+ MAGIC_CMD=:
+ fi
+fi
+
+ fi
+ ;;
+esac
+
+# Use C for the default configuration in the libtool script
+
+lt_save_CC="$CC"
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+objext=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+
+lt_prog_compiler_no_builtin_flag=
+
+if test "$GCC" = yes; then
+ case $cc_basename in
+ nvcc*)
+ lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
+ *)
+ lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
+ esac
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
+if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_rtti_exceptions=no
+ ac_outfile=conftest.$ac_objext
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+ lt_compiler_flag="-fno-rtti -fno-exceptions"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ # The option is referenced via a variable to avoid confusing sed.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+ (eval "$lt_compile" 2>conftest.err)
+ ac_status=$?
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ if (exit $ac_status) && test -s "$ac_outfile"; then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings other than the usual output.
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_rtti_exceptions=yes
+ fi
+ fi
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
+
+if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
+ lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
+else
+ :
+fi
+
+fi
+
+
+
+
+
+
+ lt_prog_compiler_wl=
+lt_prog_compiler_pic=
+lt_prog_compiler_static=
+
+
+ if test "$GCC" = yes; then
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_static='-static'
+
+ case $host_os in
+ aix*)
+ # All AIX code is PIC.
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ lt_prog_compiler_static='-Bstatic'
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ lt_prog_compiler_pic='-fPIC'
+ ;;
+ m68k)
+ # FIXME: we need at least 68020 code to build shared libraries, but
+ # adding the `-m68020' flag to GCC prevents building anything better,
+ # like `-m68040'.
+ lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
+ ;;
+ esac
+ ;;
+
+ beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+ # PIC is the default for these OSes.
+ ;;
+
+ mingw* | cygwin* | pw32* | os2* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ # Although the cygwin gcc ignores -fPIC, still need this for old-style
+ # (--disable-auto-import) libraries
+ lt_prog_compiler_pic='-DDLL_EXPORT'
+ ;;
+
+ darwin* | rhapsody*)
+ # PIC is the default on this platform
+ # Common symbols not allowed in MH_DYLIB files
+ lt_prog_compiler_pic='-fno-common'
+ ;;
+
+ haiku*)
+ # PIC is the default for Haiku.
+ # The "-static" flag exists, but is broken.
+ lt_prog_compiler_static=
+ ;;
+
+ hpux*)
+ # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+ # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag
+ # sets the default TLS model and affects inlining.
+ case $host_cpu in
+ hppa*64*)
+ # +Z the default
+ ;;
+ *)
+ lt_prog_compiler_pic='-fPIC'
+ ;;
+ esac
+ ;;
+
+ interix[3-9]*)
+ # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+ # Instead, we relocate shared libraries at runtime.
+ ;;
+
+ msdosdjgpp*)
+ # Just because we use GCC doesn't mean we suddenly get shared libraries
+ # on systems that don't support them.
+ lt_prog_compiler_can_build_shared=no
+ enable_shared=no
+ ;;
+
+ *nto* | *qnx*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ lt_prog_compiler_pic='-fPIC -shared'
+ ;;
+
+ sysv4*MP*)
+ if test -d /usr/nec; then
+ lt_prog_compiler_pic=-Kconform_pic
+ fi
+ ;;
+
+ *)
+ lt_prog_compiler_pic='-fPIC'
+ ;;
+ esac
+
+ case $cc_basename in
+ nvcc*) # Cuda Compiler Driver 2.2
+ lt_prog_compiler_wl='-Xlinker '
+ if test -n "$lt_prog_compiler_pic"; then
+ lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
+ fi
+ ;;
+ esac
+ else
+ # PORTME Check for flag to pass linker flags through the system compiler.
+ case $host_os in
+ aix*)
+ lt_prog_compiler_wl='-Wl,'
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ lt_prog_compiler_static='-Bstatic'
+ else
+ lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+ fi
+ ;;
+
+ mingw* | cygwin* | pw32* | os2* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ lt_prog_compiler_pic='-DDLL_EXPORT'
+ ;;
+
+ hpux9* | hpux10* | hpux11*)
+ lt_prog_compiler_wl='-Wl,'
+ # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+ # not for PA HP-UX.
+ case $host_cpu in
+ hppa*64*|ia64*)
+ # +Z the default
+ ;;
+ *)
+ lt_prog_compiler_pic='+Z'
+ ;;
+ esac
+ # Is there a better lt_prog_compiler_static that works with the bundled CC?
+ lt_prog_compiler_static='${wl}-a ${wl}archive'
+ ;;
+
+ irix5* | irix6* | nonstopux*)
+ lt_prog_compiler_wl='-Wl,'
+ # PIC (with -KPIC) is the default.
+ lt_prog_compiler_static='-non_shared'
+ ;;
+
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ case $cc_basename in
+ # old Intel for x86_64 which still supported -KPIC.
+ ecc*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-static'
+ ;;
+ # icc used to be incompatible with GCC.
+ # ICC 10 doesn't accept -KPIC any more.
+ icc* | ifort*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-fPIC'
+ lt_prog_compiler_static='-static'
+ ;;
+ # Lahey Fortran 8.1.
+ lf95*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='--shared'
+ lt_prog_compiler_static='--static'
+ ;;
+ nagfor*)
+ # NAG Fortran compiler
+ lt_prog_compiler_wl='-Wl,-Wl,,'
+ lt_prog_compiler_pic='-PIC'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+ pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+ # Portland Group compilers (*not* the Pentium gcc compiler,
+ # which looks to be a dead project)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-fpic'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+ ccc*)
+ lt_prog_compiler_wl='-Wl,'
+ # All Alpha code is PIC.
+ lt_prog_compiler_static='-non_shared'
+ ;;
+ xl* | bgxl* | bgf* | mpixl*)
+ # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-qpic'
+ lt_prog_compiler_static='-qstaticlink'
+ ;;
+ *)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*)
+ # Sun Fortran 8.3 passes all unrecognized flags to the linker
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-Bstatic'
+ lt_prog_compiler_wl=''
+ ;;
+ *Sun\ F* | *Sun*Fortran*)
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-Bstatic'
+ lt_prog_compiler_wl='-Qoption ld '
+ ;;
+ *Sun\ C*)
+ # Sun C 5.9
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-Bstatic'
+ lt_prog_compiler_wl='-Wl,'
+ ;;
+ *Intel*\ [CF]*Compiler*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-fPIC'
+ lt_prog_compiler_static='-static'
+ ;;
+ *Portland\ Group*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-fpic'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+ esac
+ ;;
+ esac
+ ;;
+
+ newsos6)
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+
+ *nto* | *qnx*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ lt_prog_compiler_pic='-fPIC -shared'
+ ;;
+
+ osf3* | osf4* | osf5*)
+ lt_prog_compiler_wl='-Wl,'
+ # All OSF/1 code is PIC.
+ lt_prog_compiler_static='-non_shared'
+ ;;
+
+ rdos*)
+ lt_prog_compiler_static='-non_shared'
+ ;;
+
+ solaris*)
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-Bstatic'
+ case $cc_basename in
+ f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
+ lt_prog_compiler_wl='-Qoption ld ';;
+ *)
+ lt_prog_compiler_wl='-Wl,';;
+ esac
+ ;;
+
+ sunos4*)
+ lt_prog_compiler_wl='-Qoption ld '
+ lt_prog_compiler_pic='-PIC'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+
+ sysv4 | sysv4.2uw2* | sysv4.3*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+
+ sysv4*MP*)
+ if test -d /usr/nec ;then
+ lt_prog_compiler_pic='-Kconform_pic'
+ lt_prog_compiler_static='-Bstatic'
+ fi
+ ;;
+
+ sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-KPIC'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+
+ unicos*)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_can_build_shared=no
+ ;;
+
+ uts4*)
+ lt_prog_compiler_pic='-pic'
+ lt_prog_compiler_static='-Bstatic'
+ ;;
+
+ *)
+ lt_prog_compiler_can_build_shared=no
+ ;;
+ esac
+ fi
+
+case $host_os in
+ # For platforms which do not support PIC, -DPIC is meaningless:
+ *djgpp*)
+ lt_prog_compiler_pic=
+ ;;
+ *)
+ lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
+ ;;
+esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
+if ${lt_cv_prog_compiler_pic+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
+$as_echo "$lt_cv_prog_compiler_pic" >&6; }
+lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
+if ${lt_cv_prog_compiler_pic_works+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_pic_works=no
+ ac_outfile=conftest.$ac_objext
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+ lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ # The option is referenced via a variable to avoid confusing sed.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+ (eval "$lt_compile" 2>conftest.err)
+ ac_status=$?
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ if (exit $ac_status) && test -s "$ac_outfile"; then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings other than the usual output.
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_pic_works=yes
+ fi
+ fi
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
+$as_echo "$lt_cv_prog_compiler_pic_works" >&6; }
+
+if test x"$lt_cv_prog_compiler_pic_works" = xyes; then
+ case $lt_prog_compiler_pic in
+ "" | " "*) ;;
+ *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
+ esac
+else
+ lt_prog_compiler_pic=
+ lt_prog_compiler_can_build_shared=no
+fi
+
+fi
+
+
+
+
+
+
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if ${lt_cv_prog_compiler_static_works+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_static_works=no
+ save_LDFLAGS="$LDFLAGS"
+ LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+ echo "$lt_simple_link_test_code" > conftest.$ac_ext
+ if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+ # The linker can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ if test -s conftest.err; then
+ # Append any errors to the config.log.
+ cat conftest.err 1>&5
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if diff conftest.exp conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_static_works=yes
+ fi
+ else
+ lt_cv_prog_compiler_static_works=yes
+ fi
+ fi
+ $RM -r conftest*
+ LDFLAGS="$save_LDFLAGS"
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
+$as_echo "$lt_cv_prog_compiler_static_works" >&6; }
+
+if test x"$lt_cv_prog_compiler_static_works" = xyes; then
+ :
+else
+ lt_prog_compiler_static=
+fi
+
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_c_o=no
+ $RM -r conftest 2>/dev/null
+ mkdir conftest
+ cd conftest
+ mkdir out
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ lt_compiler_flag="-o out/conftest2.$ac_objext"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+ (eval "$lt_compile" 2>out/conftest.err)
+ ac_status=$?
+ cat out/conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ if (exit $ac_status) && test -s out/conftest2.$ac_objext
+ then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+ if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_c_o=yes
+ fi
+ fi
+ chmod u+w . 2>&5
+ $RM conftest*
+ # SGI C++ compiler will create directory out/ii_files/ for
+ # template instantiation
+ test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+ $RM out/* && rmdir out
+ cd ..
+ $RM -r conftest
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_c_o=no
+ $RM -r conftest 2>/dev/null
+ mkdir conftest
+ cd conftest
+ mkdir out
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ lt_compiler_flag="-o out/conftest2.$ac_objext"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+ (eval "$lt_compile" 2>out/conftest.err)
+ ac_status=$?
+ cat out/conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ if (exit $ac_status) && test -s out/conftest2.$ac_objext
+ then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+ if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_c_o=yes
+ fi
+ fi
+ chmod u+w . 2>&5
+ $RM conftest*
+ # SGI C++ compiler will create directory out/ii_files/ for
+ # template instantiation
+ test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+ $RM out/* && rmdir out
+ cd ..
+ $RM -r conftest
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+hard_links="nottested"
+if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
+ # do not overwrite the value of need_locks provided by the user
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+$as_echo_n "checking if we can lock with hard links... " >&6; }
+ hard_links=yes
+ $RM conftest*
+ ln conftest.a conftest.b 2>/dev/null && hard_links=no
+ touch conftest.a
+ ln conftest.a conftest.b 2>&5 || hard_links=no
+ ln conftest.a conftest.b 2>/dev/null && hard_links=no
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+$as_echo "$hard_links" >&6; }
+ if test "$hard_links" = no; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+ need_locks=warn
+ fi
+else
+ need_locks=no
+fi
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+ runpath_var=
+ allow_undefined_flag=
+ always_export_symbols=no
+ archive_cmds=
+ archive_expsym_cmds=
+ compiler_needs_object=no
+ enable_shared_with_static_runtimes=no
+ export_dynamic_flag_spec=
+ export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+ hardcode_automatic=no
+ hardcode_direct=no
+ hardcode_direct_absolute=no
+ hardcode_libdir_flag_spec=
+ hardcode_libdir_separator=
+ hardcode_minus_L=no
+ hardcode_shlibpath_var=unsupported
+ inherit_rpath=no
+ link_all_deplibs=unknown
+ module_cmds=
+ module_expsym_cmds=
+ old_archive_from_new_cmds=
+ old_archive_from_expsyms_cmds=
+ thread_safe_flag_spec=
+ whole_archive_flag_spec=
+ # include_expsyms should be a list of space-separated symbols to be *always*
+ # included in the symbol list
+ include_expsyms=
+ # exclude_expsyms can be an extended regexp of symbols to exclude
+ # it will be wrapped by ` (' and `)$', so one must not match beginning or
+ # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+ # as well as any symbol that contains `d'.
+ exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
+ # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+ # platforms (ab)use it in PIC code, but their linkers get confused if
+ # the symbol is explicitly referenced. Since portable code cannot
+ # rely on this symbol name, it's probably fine to never include it in
+ # preloaded symbol tables.
+ # Exclude shared library initialization/finalization symbols.
+ extract_expsyms_cmds=
+
+ case $host_os in
+ cygwin* | mingw* | pw32* | cegcc*)
+ # FIXME: the MSVC++ port hasn't been tested in a loooong time
+ # When not using gcc, we currently assume that we are using
+ # Microsoft Visual C++.
+ if test "$GCC" != yes; then
+ with_gnu_ld=no
+ fi
+ ;;
+ interix*)
+ # we just hope/assume this is gcc and not c89 (= MSVC++)
+ with_gnu_ld=yes
+ ;;
+ openbsd*)
+ with_gnu_ld=no
+ ;;
+ linux* | k*bsd*-gnu | gnu*)
+ link_all_deplibs=no
+ ;;
+ esac
+
+ ld_shlibs=yes
+
+ # On some targets, GNU ld is compatible enough with the native linker
+ # that we're better off using the native interface for both.
+ lt_use_gnu_ld_interface=no
+ if test "$with_gnu_ld" = yes; then
+ case $host_os in
+ aix*)
+ # The AIX port of GNU ld has always aspired to compatibility
+ # with the native linker. However, as the warning in the GNU ld
+ # block says, versions before 2.19.5* couldn't really create working
+ # shared libraries, regardless of the interface used.
+ case `$LD -v 2>&1` in
+ *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
+ *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;;
+ *\ \(GNU\ Binutils\)\ [3-9]*) ;;
+ *)
+ lt_use_gnu_ld_interface=yes
+ ;;
+ esac
+ ;;
+ *)
+ lt_use_gnu_ld_interface=yes
+ ;;
+ esac
+ fi
+
+ if test "$lt_use_gnu_ld_interface" = yes; then
+ # If archive_cmds runs LD, not CC, wlarc should be empty
+ wlarc='${wl}'
+
+ # Set some defaults for GNU ld with shared library support. These
+ # are reset later if shared libraries are not supported. Putting them
+ # here allows them to be overridden if necessary.
+ runpath_var=LD_RUN_PATH
+ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+ export_dynamic_flag_spec='${wl}--export-dynamic'
+ # ancient GNU ld didn't support --whole-archive et. al.
+ if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+ whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+ else
+ whole_archive_flag_spec=
+ fi
+ supports_anon_versioning=no
+ case `$LD -v 2>&1` in
+ *GNU\ gold*) supports_anon_versioning=yes ;;
+ *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
+ *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+ *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+ *\ 2.11.*) ;; # other 2.11 versions
+ *) supports_anon_versioning=yes ;;
+ esac
+
+ # See if GNU ld supports shared libraries.
+ case $host_os in
+ aix[3-9]*)
+ # On AIX/PPC, the GNU linker is very broken
+ if test "$host_cpu" != ia64; then
+ ld_shlibs=no
+ cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.19, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support. If you
+*** really care for shared libraries, you may want to install binutils
+*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
+*** You will then need to restart the configuration process.
+
+_LT_EOF
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds=''
+ ;;
+ m68k)
+ archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+ hardcode_libdir_flag_spec='-L$libdir'
+ hardcode_minus_L=yes
+ ;;
+ esac
+ ;;
+
+ beos*)
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ allow_undefined_flag=unsupported
+ # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+ # support --undefined. This deserves some investigation. FIXME
+ archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ else
+ ld_shlibs=no
+ fi
+ ;;
+
+ cygwin* | mingw* | pw32* | cegcc*)
+ # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
+ # as there is no search path for DLLs.
+ hardcode_libdir_flag_spec='-L$libdir'
+ export_dynamic_flag_spec='${wl}--export-all-symbols'
+ allow_undefined_flag=unsupported
+ always_export_symbols=no
+ enable_shared_with_static_runtimes=yes
+ export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
+ exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
+
+ if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ # If the export-symbols file already is a .def file (1st line
+ # is EXPORTS), use it as is; otherwise, prepend...
+ archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ cp $export_symbols $output_objdir/$soname.def;
+ else
+ echo EXPORTS > $output_objdir/$soname.def;
+ cat $export_symbols >> $output_objdir/$soname.def;
+ fi~
+ $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ else
+ ld_shlibs=no
+ fi
+ ;;
+
+ haiku*)
+ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ link_all_deplibs=yes
+ ;;
+
+ interix[3-9]*)
+ hardcode_direct=no
+ hardcode_shlibpath_var=no
+ hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+ export_dynamic_flag_spec='${wl}-E'
+ # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+ # Instead, shared libraries are loaded at an image base (0x10000000 by
+ # default) and relocated if they conflict, which is a slow very memory
+ # consuming and fragmenting process. To avoid this, we pick a random,
+ # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+ # time. Moving up from 0x10000000 also allows more sbrk(2) space.
+ archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ ;;
+
+ gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+ tmp_diet=no
+ if test "$host_os" = linux-dietlibc; then
+ case $cc_basename in
+ diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn)
+ esac
+ fi
+ if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+ && test "$tmp_diet" = no
+ then
+ tmp_addflag=' $pic_flag'
+ tmp_sharedflag='-shared'
+ case $cc_basename,$host_cpu in
+ pgcc*) # Portland Group C compiler
+ whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ tmp_addflag=' $pic_flag'
+ ;;
+ pgf77* | pgf90* | pgf95* | pgfortran*)
+ # Portland Group f77 and f90 compilers
+ whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ tmp_addflag=' $pic_flag -Mnomain' ;;
+ ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64
+ tmp_addflag=' -i_dynamic' ;;
+ efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64
+ tmp_addflag=' -i_dynamic -nofor_main' ;;
+ ifc* | ifort*) # Intel Fortran compiler
+ tmp_addflag=' -nofor_main' ;;
+ lf95*) # Lahey Fortran 8.1
+ whole_archive_flag_spec=
+ tmp_sharedflag='--shared' ;;
+ xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below)
+ tmp_sharedflag='-qmkshrobj'
+ tmp_addflag= ;;
+ nvcc*) # Cuda Compiler Driver 2.2
+ whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ compiler_needs_object=yes
+ ;;
+ esac
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*) # Sun C 5.9
+ whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ compiler_needs_object=yes
+ tmp_sharedflag='-G' ;;
+ *Sun\ F*) # Sun Fortran 8.3
+ tmp_sharedflag='-G' ;;
+ esac
+ archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+ if test "x$supports_anon_versioning" = xyes; then
+ archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+ echo "local: *; };" >> $output_objdir/$libname.ver~
+ $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+ fi
+
+ case $cc_basename in
+ xlf* | bgf* | bgxlf* | mpixlf*)
+ # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+ whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
+ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+ archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
+ if test "x$supports_anon_versioning" = xyes; then
+ archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+ echo "local: *; };" >> $output_objdir/$libname.ver~
+ $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+ fi
+ ;;
+ esac
+ else
+ ld_shlibs=no
+ fi
+ ;;
+
+ netbsd* | netbsdelf*-gnu)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+ wlarc=
+ else
+ archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ fi
+ ;;
+
+ solaris*)
+ if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+ ld_shlibs=no
+ cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems. Therefore, libtool
+*** is disabling shared libraries support. We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer. Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+ elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ else
+ ld_shlibs=no
+ fi
+ ;;
+
+ sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+ case `$LD -v 2>&1` in
+ *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+ ld_shlibs=no
+ cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems. Therefore, libtool
+*** is disabling shared libraries support. We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer. Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+ ;;
+ *)
+ # For security reasons, it is highly recommended that you always
+ # use absolute paths for naming shared libraries, and exclude the
+ # DT_RUNPATH tag from executables and libraries. But doing so
+ # requires that you compile everything twice, which is a pain.
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ else
+ ld_shlibs=no
+ fi
+ ;;
+ esac
+ ;;
+
+ sunos4*)
+ archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+ wlarc=
+ hardcode_direct=yes
+ hardcode_shlibpath_var=no
+ ;;
+
+ *)
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ else
+ ld_shlibs=no
+ fi
+ ;;
+ esac
+
+ if test "$ld_shlibs" = no; then
+ runpath_var=
+ hardcode_libdir_flag_spec=
+ export_dynamic_flag_spec=
+ whole_archive_flag_spec=
+ fi
+ else
+ # PORTME fill in a description of your system's linker (not GNU ld)
+ case $host_os in
+ aix3*)
+ allow_undefined_flag=unsupported
+ always_export_symbols=yes
+ archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+ # Note: this linker hardcodes the directories in LIBPATH if there
+ # are no directories specified by -L.
+ hardcode_minus_L=yes
+ if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+ # Neither direct hardcoding nor static linking is supported with a
+ # broken collect2.
+ hardcode_direct=unsupported
+ fi
+ ;;
+
+ aix[4-9]*)
+ if test "$host_cpu" = ia64; then
+ # On IA64, the linker does run time linking by default, so we don't
+ # have to do anything special.
+ aix_use_runtimelinking=no
+ exp_sym_flag='-Bexport'
+ no_entry_flag=""
+ else
+ # If we're using GNU nm, then we don't want the "-C" option.
+ # -C means demangle to AIX nm, but means don't demangle with GNU nm
+ # Also, AIX nm treats weak defined symbols like other global
+ # defined symbols, whereas GNU nm marks them as "W".
+ if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+ export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ else
+ export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ fi
+ aix_use_runtimelinking=no
+
+ # Test if we are trying to use run time linking or normal
+ # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+ # need to do runtime linking.
+ case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
+ for ld_flag in $LDFLAGS; do
+ if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+ aix_use_runtimelinking=yes
+ break
+ fi
+ done
+ ;;
+ esac
+
+ exp_sym_flag='-bexport'
+ no_entry_flag='-bnoentry'
+ fi
+
+ # When large executables or shared objects are built, AIX ld can
+ # have problems creating the table of contents. If linking a library
+ # or program results in "error TOC overflow" add -mminimal-toc to
+ # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not
+ # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+ archive_cmds=''
+ hardcode_direct=yes
+ hardcode_direct_absolute=yes
+ hardcode_libdir_separator=':'
+ link_all_deplibs=yes
+ file_list_spec='${wl}-f,'
+
+ if test "$GCC" = yes; then
+ case $host_os in aix4.[012]|aix4.[012].*)
+ # We only want to do this on AIX 4.2 and lower, the check
+ # below for broken collect2 doesn't work under 4.3+
+ collect2name=`${CC} -print-prog-name=collect2`
+ if test -f "$collect2name" &&
+ strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+ then
+ # We have reworked collect2
+ :
+ else
+ # We have old collect2
+ hardcode_direct=unsupported
+ # It fails to find uninstalled libraries when the uninstalled
+ # path is not listed in the libpath. Setting hardcode_minus_L
+ # to unsupported forces relinking
+ hardcode_minus_L=yes
+ hardcode_libdir_flag_spec='-L$libdir'
+ hardcode_libdir_separator=
+ fi
+ ;;
+ esac
+ shared_flag='-shared'
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag="$shared_flag "'${wl}-G'
+ fi
+ link_all_deplibs=no
+ else
+ # not using gcc
+ if test "$host_cpu" = ia64; then
+ # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+ # chokes on -Wl,-G. The following line is correct:
+ shared_flag='-G'
+ else
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag='${wl}-G'
+ else
+ shared_flag='${wl}-bM:SRE'
+ fi
+ fi
+ fi
+
+ export_dynamic_flag_spec='${wl}-bexpall'
+ # It seems that -bexpall does not export symbols beginning with
+ # underscore (_), so it is better to generate a list of symbols to export.
+ always_export_symbols=yes
+ if test "$aix_use_runtimelinking" = yes; then
+ # Warning - without using the other runtime loading flags (-brtl),
+ # -berok will link without error, but may produce a broken library.
+ allow_undefined_flag='-berok'
+ # Determine the default libpath from the value encoded in an
+ # empty executable.
+ if test "${lt_cv_aix_libpath+set}" = set; then
+ aix_libpath=$lt_cv_aix_libpath
+else
+ if ${lt_cv_aix_libpath_+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+ lt_aix_libpath_sed='
+ /Import File Strings/,/^$/ {
+ /^0/ {
+ s/^0 *\([^ ]*\) *$/\1/
+ p
+ }
+ }'
+ lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ # Check for a 64-bit object if we didn't find anything.
+ if test -z "$lt_cv_aix_libpath_"; then
+ lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ if test -z "$lt_cv_aix_libpath_"; then
+ lt_cv_aix_libpath_="/usr/lib:/lib"
+ fi
+
+fi
+
+ aix_libpath=$lt_cv_aix_libpath_
+fi
+
+ hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+ archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+ else
+ if test "$host_cpu" = ia64; then
+ hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+ allow_undefined_flag="-z nodefs"
+ archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+ else
+ # Determine the default libpath from the value encoded in an
+ # empty executable.
+ if test "${lt_cv_aix_libpath+set}" = set; then
+ aix_libpath=$lt_cv_aix_libpath
+else
+ if ${lt_cv_aix_libpath_+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+ lt_aix_libpath_sed='
+ /Import File Strings/,/^$/ {
+ /^0/ {
+ s/^0 *\([^ ]*\) *$/\1/
+ p
+ }
+ }'
+ lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ # Check for a 64-bit object if we didn't find anything.
+ if test -z "$lt_cv_aix_libpath_"; then
+ lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ if test -z "$lt_cv_aix_libpath_"; then
+ lt_cv_aix_libpath_="/usr/lib:/lib"
+ fi
+
+fi
+
+ aix_libpath=$lt_cv_aix_libpath_
+fi
+
+ hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+ # Warning - without using the other run time loading flags,
+ # -berok will link without error, but may produce a broken library.
+ no_undefined_flag=' ${wl}-bernotok'
+ allow_undefined_flag=' ${wl}-berok'
+ if test "$with_gnu_ld" = yes; then
+ # We only use this code for GNU lds that support --whole-archive.
+ whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+ else
+ # Exported symbols can be pulled into shared objects from archives
+ whole_archive_flag_spec='$convenience'
+ fi
+ archive_cmds_need_lc=yes
+ # This is similar to how AIX traditionally builds its shared libraries.
+ archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+ fi
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds=''
+ ;;
+ m68k)
+ archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+ hardcode_libdir_flag_spec='-L$libdir'
+ hardcode_minus_L=yes
+ ;;
+ esac
+ ;;
+
+ bsdi[45]*)
+ export_dynamic_flag_spec=-rdynamic
+ ;;
+
+ cygwin* | mingw* | pw32* | cegcc*)
+ # When not using gcc, we currently assume that we are using
+ # Microsoft Visual C++.
+ # hardcode_libdir_flag_spec is actually meaningless, as there is
+ # no search path for DLLs.
+ case $cc_basename in
+ cl*)
+ # Native MSVC
+ hardcode_libdir_flag_spec=' '
+ allow_undefined_flag=unsupported
+ always_export_symbols=yes
+ file_list_spec='@'
+ # Tell ltmain to make .lib files, not .a files.
+ libext=lib
+ # Tell ltmain to make .dll files, not .so files.
+ shrext_cmds=".dll"
+ # FIXME: Setting linknames here is a bad hack.
+ archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
+ archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
+ else
+ sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
+ fi~
+ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+ linknames='
+ # The linker will not automatically build a static lib if we build a DLL.
+ # _LT_TAGVAR(old_archive_from_new_cmds, )='true'
+ enable_shared_with_static_runtimes=yes
+ exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+ export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
+ # Don't use ranlib
+ old_postinstall_cmds='chmod 644 $oldlib'
+ postlink_cmds='lt_outputfile="@OUTPUT@"~
+ lt_tool_outputfile="@TOOL_OUTPUT@"~
+ case $lt_outputfile in
+ *.exe|*.EXE) ;;
+ *)
+ lt_outputfile="$lt_outputfile.exe"
+ lt_tool_outputfile="$lt_tool_outputfile.exe"
+ ;;
+ esac~
+ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
+ $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+ $RM "$lt_outputfile.manifest";
+ fi'
+ ;;
+ *)
+ # Assume MSVC wrapper
+ hardcode_libdir_flag_spec=' '
+ allow_undefined_flag=unsupported
+ # Tell ltmain to make .lib files, not .a files.
+ libext=lib
+ # Tell ltmain to make .dll files, not .so files.
+ shrext_cmds=".dll"
+ # FIXME: Setting linknames here is a bad hack.
+ archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+ # The linker will automatically build a .lib file if we build a DLL.
+ old_archive_from_new_cmds='true'
+ # FIXME: Should let the user specify the lib program.
+ old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
+ enable_shared_with_static_runtimes=yes
+ ;;
+ esac
+ ;;
+
+ darwin* | rhapsody*)
+
+
+ archive_cmds_need_lc=no
+ hardcode_direct=no
+ hardcode_automatic=yes
+ hardcode_shlibpath_var=unsupported
+ if test "$lt_cv_ld_force_load" = "yes"; then
+ whole_archive_flag_spec='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+
+ else
+ whole_archive_flag_spec=''
+ fi
+ link_all_deplibs=yes
+ allow_undefined_flag="$_lt_dar_allow_undefined"
+ case $cc_basename in
+ ifort*) _lt_dar_can_shared=yes ;;
+ *) _lt_dar_can_shared=$GCC ;;
+ esac
+ if test "$_lt_dar_can_shared" = "yes"; then
+ output_verbose_link_cmd=func_echo_all
+ archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
+ module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
+ archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
+ module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
+
+ else
+ ld_shlibs=no
+ fi
+
+ ;;
+
+ dgux*)
+ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_libdir_flag_spec='-L$libdir'
+ hardcode_shlibpath_var=no
+ ;;
+
+ # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+ # support. Future versions do this automatically, but an explicit c++rt0.o
+ # does not break anything, and helps significantly (at the cost of a little
+ # extra space).
+ freebsd2.2*)
+ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+ hardcode_libdir_flag_spec='-R$libdir'
+ hardcode_direct=yes
+ hardcode_shlibpath_var=no
+ ;;
+
+ # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+ freebsd2.*)
+ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_direct=yes
+ hardcode_minus_L=yes
+ hardcode_shlibpath_var=no
+ ;;
+
+ # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+ freebsd* | dragonfly*)
+ archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+ hardcode_libdir_flag_spec='-R$libdir'
+ hardcode_direct=yes
+ hardcode_shlibpath_var=no
+ ;;
+
+ hpux9*)
+ if test "$GCC" = yes; then
+ archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ else
+ archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ fi
+ hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+ hardcode_libdir_separator=:
+ hardcode_direct=yes
+
+ # hardcode_minus_L: Not really in the search PATH,
+ # but as the default location of the library.
+ hardcode_minus_L=yes
+ export_dynamic_flag_spec='${wl}-E'
+ ;;
+
+ hpux10*)
+ if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+ archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+ fi
+ if test "$with_gnu_ld" = no; then
+ hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+ hardcode_libdir_separator=:
+ hardcode_direct=yes
+ hardcode_direct_absolute=yes
+ export_dynamic_flag_spec='${wl}-E'
+ # hardcode_minus_L: Not really in the search PATH,
+ # but as the default location of the library.
+ hardcode_minus_L=yes
+ fi
+ ;;
+
+ hpux11*)
+ if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+ case $host_cpu in
+ hppa*64*)
+ archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ ia64*)
+ archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ *)
+ archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ esac
+ else
+ case $host_cpu in
+ hppa*64*)
+ archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ ia64*)
+ archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ *)
+
+ # Older versions of the 11.00 compiler do not understand -b yet
+ # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
+$as_echo_n "checking if $CC understands -b... " >&6; }
+if ${lt_cv_prog_compiler__b+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler__b=no
+ save_LDFLAGS="$LDFLAGS"
+ LDFLAGS="$LDFLAGS -b"
+ echo "$lt_simple_link_test_code" > conftest.$ac_ext
+ if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+ # The linker can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ if test -s conftest.err; then
+ # Append any errors to the config.log.
+ cat conftest.err 1>&5
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if diff conftest.exp conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler__b=yes
+ fi
+ else
+ lt_cv_prog_compiler__b=yes
+ fi
+ fi
+ $RM -r conftest*
+ LDFLAGS="$save_LDFLAGS"
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
+$as_echo "$lt_cv_prog_compiler__b" >&6; }
+
+if test x"$lt_cv_prog_compiler__b" = xyes; then
+ archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+else
+ archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+fi
+
+ ;;
+ esac
+ fi
+ if test "$with_gnu_ld" = no; then
+ hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+ hardcode_libdir_separator=:
+
+ case $host_cpu in
+ hppa*64*|ia64*)
+ hardcode_direct=no
+ hardcode_shlibpath_var=no
+ ;;
+ *)
+ hardcode_direct=yes
+ hardcode_direct_absolute=yes
+ export_dynamic_flag_spec='${wl}-E'
+
+ # hardcode_minus_L: Not really in the search PATH,
+ # but as the default location of the library.
+ hardcode_minus_L=yes
+ ;;
+ esac
+ fi
+ ;;
+
+ irix5* | irix6* | nonstopux*)
+ if test "$GCC" = yes; then
+ archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ # Try to use the -exported_symbol ld option, if it does not
+ # work, assume that -exports_file does not work either and
+ # implicitly export all symbols.
+ # This should be the same for all languages, so no per-tag cache variable.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
+$as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; }
+if ${lt_cv_irix_exported_symbol+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ save_LDFLAGS="$LDFLAGS"
+ LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+int foo (void) { return 0; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ lt_cv_irix_exported_symbol=yes
+else
+ lt_cv_irix_exported_symbol=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ LDFLAGS="$save_LDFLAGS"
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
+$as_echo "$lt_cv_irix_exported_symbol" >&6; }
+ if test "$lt_cv_irix_exported_symbol" = yes; then
+ archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
+ fi
+ else
+ archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
+ fi
+ archive_cmds_need_lc='no'
+ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+ hardcode_libdir_separator=:
+ inherit_rpath=yes
+ link_all_deplibs=yes
+ ;;
+
+ netbsd* | netbsdelf*-gnu)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out
+ else
+ archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF
+ fi
+ hardcode_libdir_flag_spec='-R$libdir'
+ hardcode_direct=yes
+ hardcode_shlibpath_var=no
+ ;;
+
+ newsos6)
+ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_direct=yes
+ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+ hardcode_libdir_separator=:
+ hardcode_shlibpath_var=no
+ ;;
+
+ *nto* | *qnx*)
+ ;;
+
+ openbsd*)
+ if test -f /usr/libexec/ld.so; then
+ hardcode_direct=yes
+ hardcode_shlibpath_var=no
+ hardcode_direct_absolute=yes
+ if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+ hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+ export_dynamic_flag_spec='${wl}-E'
+ else
+ case $host_os in
+ openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+ archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_libdir_flag_spec='-R$libdir'
+ ;;
+ *)
+ archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+ hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+ ;;
+ esac
+ fi
+ else
+ ld_shlibs=no
+ fi
+ ;;
+
+ os2*)
+ hardcode_libdir_flag_spec='-L$libdir'
+ hardcode_minus_L=yes
+ allow_undefined_flag=unsupported
+ archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+ old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+ ;;
+
+ osf3*)
+ if test "$GCC" = yes; then
+ allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+ archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ else
+ allow_undefined_flag=' -expect_unresolved \*'
+ archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ fi
+ archive_cmds_need_lc='no'
+ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+ hardcode_libdir_separator=:
+ ;;
+
+ osf4* | osf5*) # as osf3* with the addition of -msym flag
+ if test "$GCC" = yes; then
+ allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
+ archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+ else
+ allow_undefined_flag=' -expect_unresolved \*'
+ archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+ $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
+
+ # Both c and cxx compiler support -rpath directly
+ hardcode_libdir_flag_spec='-rpath $libdir'
+ fi
+ archive_cmds_need_lc='no'
+ hardcode_libdir_separator=:
+ ;;
+
+ solaris*)
+ no_undefined_flag=' -z defs'
+ if test "$GCC" = yes; then
+ wlarc='${wl}'
+ archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ else
+ case `$CC -V 2>&1` in
+ *"Compilers 5.0"*)
+ wlarc=''
+ archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+ ;;
+ *)
+ wlarc='${wl}'
+ archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ ;;
+ esac
+ fi
+ hardcode_libdir_flag_spec='-R$libdir'
+ hardcode_shlibpath_var=no
+ case $host_os in
+ solaris2.[0-5] | solaris2.[0-5].*) ;;
+ *)
+ # The compiler driver will combine and reorder linker options,
+ # but understands `-z linker_flag'. GCC discards it without `$wl',
+ # but is careful enough not to reorder.
+ # Supported since Solaris 2.6 (maybe 2.5.1?)
+ if test "$GCC" = yes; then
+ whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+ else
+ whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
+ fi
+ ;;
+ esac
+ link_all_deplibs=yes
+ ;;
+
+ sunos4*)
+ if test "x$host_vendor" = xsequent; then
+ # Use $CC to link under sequent, because it throws in some extra .o
+ # files that make .init and .fini sections work.
+ archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+ fi
+ hardcode_libdir_flag_spec='-L$libdir'
+ hardcode_direct=yes
+ hardcode_minus_L=yes
+ hardcode_shlibpath_var=no
+ ;;
+
+ sysv4)
+ case $host_vendor in
+ sni)
+ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_direct=yes # is this really true???
+ ;;
+ siemens)
+ ## LD is ld it makes a PLAMLIB
+ ## CC just makes a GrossModule.
+ archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+ reload_cmds='$CC -r -o $output$reload_objs'
+ hardcode_direct=no
+ ;;
+ motorola)
+ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+ ;;
+ esac
+ runpath_var='LD_RUN_PATH'
+ hardcode_shlibpath_var=no
+ ;;
+
+ sysv4.3*)
+ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_shlibpath_var=no
+ export_dynamic_flag_spec='-Bexport'
+ ;;
+
+ sysv4*MP*)
+ if test -d /usr/nec; then
+ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_shlibpath_var=no
+ runpath_var=LD_RUN_PATH
+ hardcode_runpath_var=yes
+ ld_shlibs=yes
+ fi
+ ;;
+
+ sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+ no_undefined_flag='${wl}-z,text'
+ archive_cmds_need_lc=no
+ hardcode_shlibpath_var=no
+ runpath_var='LD_RUN_PATH'
+
+ if test "$GCC" = yes; then
+ archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ fi
+ ;;
+
+ sysv5* | sco3.2v5* | sco5v6*)
+ # Note: We can NOT use -z defs as we might desire, because we do not
+ # link with -lc, and that would cause any symbols used from libc to
+ # always be unresolved, which means just about no library would
+ # ever link correctly. If we're not using GNU ld we use -z text
+ # though, which does catch some bad symbols but isn't as heavy-handed
+ # as -z defs.
+ no_undefined_flag='${wl}-z,text'
+ allow_undefined_flag='${wl}-z,nodefs'
+ archive_cmds_need_lc=no
+ hardcode_shlibpath_var=no
+ hardcode_libdir_flag_spec='${wl}-R,$libdir'
+ hardcode_libdir_separator=':'
+ link_all_deplibs=yes
+ export_dynamic_flag_spec='${wl}-Bexport'
+ runpath_var='LD_RUN_PATH'
+
+ if test "$GCC" = yes; then
+ archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ fi
+ ;;
+
+ uts4*)
+ archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ hardcode_libdir_flag_spec='-L$libdir'
+ hardcode_shlibpath_var=no
+ ;;
+
+ *)
+ ld_shlibs=no
+ ;;
+ esac
+
+ if test x$host_vendor = xsni; then
+ case $host in
+ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+ export_dynamic_flag_spec='${wl}-Blargedynsym'
+ ;;
+ esac
+ fi
+ fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
+$as_echo "$ld_shlibs" >&6; }
+test "$ld_shlibs" = no && can_build_shared=no
+
+with_gnu_ld=$with_gnu_ld
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc" in
+x|xyes)
+ # Assume -lc should be added
+ archive_cmds_need_lc=yes
+
+ if test "$enable_shared" = yes && test "$GCC" = yes; then
+ case $archive_cmds in
+ *'~'*)
+ # FIXME: we may have to deal with multi-command sequences.
+ ;;
+ '$CC '*)
+ # Test whether the compiler implicitly links with -lc since on some
+ # systems, -lgcc has to come before -lc. If gcc already passes -lc
+ # to ld, don't add -lc before -lgcc.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
+if ${lt_cv_archive_cmds_need_lc+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ $RM conftest*
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } 2>conftest.err; then
+ soname=conftest
+ lib=conftest
+ libobjs=conftest.$ac_objext
+ deplibs=
+ wl=$lt_prog_compiler_wl
+ pic_flag=$lt_prog_compiler_pic
+ compiler_flags=-v
+ linker_flags=-v
+ verstring=
+ output_objdir=.
+ libname=conftest
+ lt_save_allow_undefined_flag=$allow_undefined_flag
+ allow_undefined_flag=
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+ (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }
+ then
+ lt_cv_archive_cmds_need_lc=no
+ else
+ lt_cv_archive_cmds_need_lc=yes
+ fi
+ allow_undefined_flag=$lt_save_allow_undefined_flag
+ else
+ cat conftest.err 1>&5
+ fi
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
+$as_echo "$lt_cv_archive_cmds_need_lc" >&6; }
+ archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
+ ;;
+ esac
+ fi
+ ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+$as_echo_n "checking dynamic linker characteristics... " >&6; }
+
+if test "$GCC" = yes; then
+ case $host_os in
+ darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
+ *) lt_awk_arg="/^libraries:/" ;;
+ esac
+ case $host_os in
+ mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;;
+ *) lt_sed_strip_eq="s,=/,/,g" ;;
+ esac
+ lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
+ case $lt_search_path_spec in
+ *\;*)
+ # if the path contains ";" then we assume it to be the separator
+ # otherwise default to the standard path separator (i.e. ":") - it is
+ # assumed that no part of a normal pathname contains ";" but that should
+ # okay in the real world where ";" in dirpaths is itself problematic.
+ lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
+ ;;
+ *)
+ lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
+ ;;
+ esac
+ # Ok, now we have the path, separated by spaces, we can step through it
+ # and add multilib dir if necessary.
+ lt_tmp_lt_search_path_spec=
+ lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+ for lt_sys_path in $lt_search_path_spec; do
+ if test -d "$lt_sys_path/$lt_multi_os_dir"; then
+ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
+ else
+ test -d "$lt_sys_path" && \
+ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+ fi
+ done
+ lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
+BEGIN {RS=" "; FS="/|\n";} {
+ lt_foo="";
+ lt_count=0;
+ for (lt_i = NF; lt_i > 0; lt_i--) {
+ if ($lt_i != "" && $lt_i != ".") {
+ if ($lt_i == "..") {
+ lt_count++;
+ } else {
+ if (lt_count == 0) {
+ lt_foo="/" $lt_i lt_foo;
+ } else {
+ lt_count--;
+ }
+ }
+ }
+ }
+ if (lt_foo != "") { lt_freq[lt_foo]++; }
+ if (lt_freq[lt_foo] == 1) { print lt_foo; }
+}'`
+ # AWK program above erroneously prepends '/' to C:/dos/paths
+ # for these hosts.
+ case $host_os in
+ mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
+ $SED 's,/\([A-Za-z]:\),\1,g'` ;;
+ esac
+ sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
+else
+ sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+ shlibpath_var=LIBPATH
+
+ # AIX 3 has no versioning support, so we append a major version to the name.
+ soname_spec='${libname}${release}${shared_ext}$major'
+ ;;
+
+aix[4-9]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ hardcode_into_libs=yes
+ if test "$host_cpu" = ia64; then
+ # AIX 5 supports IA64
+ library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ else
+ # With GCC up to 2.95.x, collect2 would create an import file
+ # for dependence libraries. The import file would start with
+ # the line `#! .'. This would cause the generated library to
+ # depend on `.', always an invalid library. This was fixed in
+ # development snapshots of GCC prior to 3.0.
+ case $host_os in
+ aix4 | aix4.[01] | aix4.[01].*)
+ if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+ echo ' yes '
+ echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+ :
+ else
+ can_build_shared=no
+ fi
+ ;;
+ esac
+ # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+ # soname into executable. Probably we can add versioning support to
+ # collect2, so additional links can be useful in future.
+ if test "$aix_use_runtimelinking" = yes; then
+ # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+ # instead of lib<name>.a to let people know that these are not
+ # typical AIX shared libraries.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ else
+ # We preserve .a as extension for shared libraries through AIX4.2
+ # and later when we are not doing run time linking.
+ library_names_spec='${libname}${release}.a $libname.a'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ fi
+ shlibpath_var=LIBPATH
+ fi
+ ;;
+
+amigaos*)
+ case $host_cpu in
+ powerpc)
+ # Since July 2007 AmigaOS4 officially supports .so libraries.
+ # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ ;;
+ m68k)
+ library_names_spec='$libname.ixlibrary $libname.a'
+ # Create ${libname}_ixlibrary.a entries in /sys/libs.
+ finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+ ;;
+ esac
+ ;;
+
+beos*)
+ library_names_spec='${libname}${shared_ext}'
+ dynamic_linker="$host_os ld.so"
+ shlibpath_var=LIBRARY_PATH
+ ;;
+
+bsdi[45]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+ sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+ # the default ld.so.conf also contains /usr/contrib/lib and
+ # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+ # libtool to hard-code these into programs
+ ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+ version_type=windows
+ shrext_cmds=".dll"
+ need_version=no
+ need_lib_prefix=no
+
+ case $GCC,$cc_basename in
+ yes,*)
+ # gcc
+ library_names_spec='$libname.dll.a'
+ # DLL is installed to $(libdir)/../bin by postinstall_cmds
+ postinstall_cmds='base_file=`basename \${file}`~
+ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+ dldir=$destdir/`dirname \$dlpath`~
+ test -d \$dldir || mkdir -p \$dldir~
+ $install_prog $dir/$dlname \$dldir/$dlname~
+ chmod a+x \$dldir/$dlname~
+ if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+ eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+ fi'
+ postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+ dlpath=$dir/\$dldll~
+ $RM \$dlpath'
+ shlibpath_overrides_runpath=yes
+
+ case $host_os in
+ cygwin*)
+ # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+ soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+
+ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
+ ;;
+ mingw* | cegcc*)
+ # MinGW DLLs use traditional 'lib' prefix
+ soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+ ;;
+ pw32*)
+ # pw32 DLLs use 'pw' prefix rather than 'lib'
+ library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+ ;;
+ esac
+ dynamic_linker='Win32 ld.exe'
+ ;;
+
+ *,cl*)
+ # Native MSVC
+ libname_spec='$name'
+ soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+ library_names_spec='${libname}.dll.lib'
+
+ case $build_os in
+ mingw*)
+ sys_lib_search_path_spec=
+ lt_save_ifs=$IFS
+ IFS=';'
+ for lt_path in $LIB
+ do
+ IFS=$lt_save_ifs
+ # Let DOS variable expansion print the short 8.3 style file name.
+ lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+ sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+ done
+ IFS=$lt_save_ifs
+ # Convert to MSYS style.
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
+ ;;
+ cygwin*)
+ # Convert to unix form, then to dos form, then back to unix form
+ # but this time dos style (no spaces!) so that the unix form looks
+ # like /cygdrive/c/PROGRA~1:/cygdr...
+ sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+ sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+ sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+ ;;
+ *)
+ sys_lib_search_path_spec="$LIB"
+ if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
+ # It is most probably a Windows format PATH.
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+ else
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+ fi
+ # FIXME: find the short name or the path components, as spaces are
+ # common. (e.g. "Program Files" -> "PROGRA~1")
+ ;;
+ esac
+
+ # DLL is installed to $(libdir)/../bin by postinstall_cmds
+ postinstall_cmds='base_file=`basename \${file}`~
+ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+ dldir=$destdir/`dirname \$dlpath`~
+ test -d \$dldir || mkdir -p \$dldir~
+ $install_prog $dir/$dlname \$dldir/$dlname'
+ postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+ dlpath=$dir/\$dldll~
+ $RM \$dlpath'
+ shlibpath_overrides_runpath=yes
+ dynamic_linker='Win32 link.exe'
+ ;;
+
+ *)
+ # Assume MSVC wrapper
+ library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+ dynamic_linker='Win32 ld.exe'
+ ;;
+ esac
+ # FIXME: first we should search . and the directory the executable is in
+ shlibpath_var=PATH
+ ;;
+
+darwin* | rhapsody*)
+ dynamic_linker="$host_os dyld"
+ version_type=darwin
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+ soname_spec='${libname}${release}${major}$shared_ext'
+ shlibpath_overrides_runpath=yes
+ shlibpath_var=DYLD_LIBRARY_PATH
+ shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
+ sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+ ;;
+
+dgux*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ ;;
+
+freebsd* | dragonfly*)
+ # DragonFly does not have aout. When/if they implement a new
+ # versioning mechanism, adjust this.
+ if test -x /usr/bin/objformat; then
+ objformat=`/usr/bin/objformat`
+ else
+ case $host_os in
+ freebsd[23].*) objformat=aout ;;
+ *) objformat=elf ;;
+ esac
+ fi
+ version_type=freebsd-$objformat
+ case $version_type in
+ freebsd-elf*)
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+ need_version=no
+ need_lib_prefix=no
+ ;;
+ freebsd-*)
+ library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+ need_version=yes
+ ;;
+ esac
+ shlibpath_var=LD_LIBRARY_PATH
+ case $host_os in
+ freebsd2.*)
+ shlibpath_overrides_runpath=yes
+ ;;
+ freebsd3.[01]* | freebsdelf3.[01]*)
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+ freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+ freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+ *) # from 4.6 on, and DragonFly
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+ esac
+ ;;
+
+haiku*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ dynamic_linker="$host_os runtime_loader"
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+ hardcode_into_libs=yes
+ ;;
+
+hpux9* | hpux10* | hpux11*)
+ # Give a soname corresponding to the major version so that dld.sl refuses to
+ # link against other versions.
+ version_type=sunos
+ need_lib_prefix=no
+ need_version=no
+ case $host_cpu in
+ ia64*)
+ shrext_cmds='.so'
+ hardcode_into_libs=yes
+ dynamic_linker="$host_os dld.so"
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ if test "X$HPUX_IA64_MODE" = X32; then
+ sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+ else
+ sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+ fi
+ sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+ ;;
+ hppa*64*)
+ shrext_cmds='.sl'
+ hardcode_into_libs=yes
+ dynamic_linker="$host_os dld.sl"
+ shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+ shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+ sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+ ;;
+ *)
+ shrext_cmds='.sl'
+ dynamic_linker="$host_os dld.sl"
+ shlibpath_var=SHLIB_PATH
+ shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ ;;
+ esac
+ # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+ postinstall_cmds='chmod 555 $lib'
+ # or fails outright, so override atomically:
+ install_override_mode=555
+ ;;
+
+interix[3-9]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
+irix5* | irix6* | nonstopux*)
+ case $host_os in
+ nonstopux*) version_type=nonstopux ;;
+ *)
+ if test "$lt_cv_prog_gnu_ld" = yes; then
+ version_type=linux # correct to gnu/linux during the next big refactor
+ else
+ version_type=irix
+ fi ;;
+ esac
+ need_lib_prefix=no
+ need_version=no
+ soname_spec='${libname}${release}${shared_ext}$major'
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+ case $host_os in
+ irix5* | nonstopux*)
+ libsuff= shlibsuff=
+ ;;
+ *)
+ case $LD in # libtool.m4 will add one of these switches to LD
+ *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+ libsuff= shlibsuff= libmagic=32-bit;;
+ *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+ libsuff=32 shlibsuff=N32 libmagic=N32;;
+ *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+ libsuff=64 shlibsuff=64 libmagic=64-bit;;
+ *) libsuff= shlibsuff= libmagic=never-match;;
+ esac
+ ;;
+ esac
+ shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+ shlibpath_overrides_runpath=no
+ sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+ sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+ hardcode_into_libs=yes
+ ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+ dynamic_linker=no
+ ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+
+ # Some binutils ld are patched to set DT_RUNPATH
+ if ${lt_cv_shlibpath_overrides_runpath+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_shlibpath_overrides_runpath=no
+ save_LDFLAGS=$LDFLAGS
+ save_libdir=$libdir
+ eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
+ LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
+ lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ LDFLAGS=$save_LDFLAGS
+ libdir=$save_libdir
+
+fi
+
+ shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+ # This implies no fast_install, which is unacceptable.
+ # Some rework will be needed to allow for fast_install
+ # before this can be enabled.
+ hardcode_into_libs=yes
+
+ # Append ld.so.conf contents to the search path
+ if test -f /etc/ld.so.conf; then
+ lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+ sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+ fi
+
+ # We used to test for /lib/ld.so.1 and disable shared libraries on
+ # powerpc, because MkLinux only supported shared libraries with the
+ # GNU dynamic linker. Since this was broken with cross compilers,
+ # most powerpc-linux boxes support dynamic linking these days and
+ # people can always --disable-shared, the test was removed, and we
+ # assume the GNU/Linux dynamic linker is in use.
+ dynamic_linker='GNU/Linux ld.so'
+ ;;
+
+netbsdelf*-gnu)
+ version_type=linux
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ dynamic_linker='NetBSD ld.elf_so'
+ ;;
+
+netbsd*)
+ version_type=sunos
+ need_lib_prefix=no
+ need_version=no
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+ dynamic_linker='NetBSD (a.out) ld.so'
+ else
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ dynamic_linker='NetBSD ld.elf_so'
+ fi
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+
+newsos6)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ ;;
+
+*nto* | *qnx*)
+ version_type=qnx
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ dynamic_linker='ldqnx.so'
+ ;;
+
+openbsd*)
+ version_type=sunos
+ sys_lib_dlsearch_path_spec="/usr/lib"
+ need_lib_prefix=no
+ # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+ case $host_os in
+ openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+ *) need_version=no ;;
+ esac
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ case $host_os in
+ openbsd2.[89] | openbsd2.[89].*)
+ shlibpath_overrides_runpath=no
+ ;;
+ *)
+ shlibpath_overrides_runpath=yes
+ ;;
+ esac
+ else
+ shlibpath_overrides_runpath=yes
+ fi
+ ;;
+
+os2*)
+ libname_spec='$name'
+ shrext_cmds=".dll"
+ need_lib_prefix=no
+ library_names_spec='$libname${shared_ext} $libname.a'
+ dynamic_linker='OS/2 ld.exe'
+ shlibpath_var=LIBPATH
+ ;;
+
+osf3* | osf4* | osf5*)
+ version_type=osf
+ need_lib_prefix=no
+ need_version=no
+ soname_spec='${libname}${release}${shared_ext}$major'
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+ sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+ ;;
+
+rdos*)
+ dynamic_linker=no
+ ;;
+
+solaris*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ # ldd complains unless libraries are executable
+ postinstall_cmds='chmod +x $lib'
+ ;;
+
+sunos4*)
+ version_type=sunos
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ if test "$with_gnu_ld" = yes; then
+ need_lib_prefix=no
+ fi
+ need_version=yes
+ ;;
+
+sysv4 | sysv4.3*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ case $host_vendor in
+ sni)
+ shlibpath_overrides_runpath=no
+ need_lib_prefix=no
+ runpath_var=LD_RUN_PATH
+ ;;
+ siemens)
+ need_lib_prefix=no
+ ;;
+ motorola)
+ need_lib_prefix=no
+ need_version=no
+ shlibpath_overrides_runpath=no
+ sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+ ;;
+ esac
+ ;;
+
+sysv4*MP*)
+ if test -d /usr/nec ;then
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+ soname_spec='$libname${shared_ext}.$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ fi
+ ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+ version_type=freebsd-elf
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ if test "$with_gnu_ld" = yes; then
+ sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+ else
+ sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+ case $host_os in
+ sco3.2v5*)
+ sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+ ;;
+ esac
+ fi
+ sys_lib_dlsearch_path_spec='/usr/lib'
+ ;;
+
+tpf*)
+ # TPF is a cross-target only. Preferred cross-host = GNU/Linux.
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
+uts4*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ ;;
+
+*)
+ dynamic_linker=no
+ ;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+$as_echo "$dynamic_linker" >&6; }
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+ variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
+ sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+fi
+if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
+ sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action=
+if test -n "$hardcode_libdir_flag_spec" ||
+ test -n "$runpath_var" ||
+ test "X$hardcode_automatic" = "Xyes" ; then
+
+ # We can hardcode non-existent directories.
+ if test "$hardcode_direct" != no &&
+ # If the only mechanism to avoid hardcoding is shlibpath_var, we
+ # have to relink, otherwise we might link with an installed library
+ # when we should be linking with a yet-to-be-installed one
+ ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no &&
+ test "$hardcode_minus_L" != no; then
+ # Linking always hardcodes the temporary library directory.
+ hardcode_action=relink
+ else
+ # We can link without hardcoding, and we can hardcode nonexisting dirs.
+ hardcode_action=immediate
+ fi
+else
+ # We cannot hardcode anything, or else we can only hardcode existing
+ # directories.
+ hardcode_action=unsupported
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
+$as_echo "$hardcode_action" >&6; }
+
+if test "$hardcode_action" = relink ||
+ test "$inherit_rpath" = yes; then
+ # Fast installation is not supported
+ enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+ test "$enable_shared" = no; then
+ # Fast installation is not necessary
+ enable_fast_install=needless
+fi
+
+
+
+
+
+
+ if test "x$enable_dlopen" != xyes; then
+ enable_dlopen=unknown
+ enable_dlopen_self=unknown
+ enable_dlopen_self_static=unknown
+else
+ lt_cv_dlopen=no
+ lt_cv_dlopen_libs=
+
+ case $host_os in
+ beos*)
+ lt_cv_dlopen="load_add_on"
+ lt_cv_dlopen_libs=
+ lt_cv_dlopen_self=yes
+ ;;
+
+ mingw* | pw32* | cegcc*)
+ lt_cv_dlopen="LoadLibrary"
+ lt_cv_dlopen_libs=
+ ;;
+
+ cygwin*)
+ lt_cv_dlopen="dlopen"
+ lt_cv_dlopen_libs=
+ ;;
+
+ darwin*)
+ # if libdl is installed we need to link against it
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ ac_cv_lib_dl_dlopen=yes
+else
+ ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+ lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+else
+
+ lt_cv_dlopen="dyld"
+ lt_cv_dlopen_libs=
+ lt_cv_dlopen_self=yes
+
+fi
+
+ ;;
+
+ *)
+ ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
+if test "x$ac_cv_func_shl_load" = xyes; then :
+ lt_cv_dlopen="shl_load"
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+$as_echo_n "checking for shl_load in -ldld... " >&6; }
+if ${ac_cv_lib_dld_shl_load+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shl_load ();
+int
+main ()
+{
+return shl_load ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ ac_cv_lib_dld_shl_load=yes
+else
+ ac_cv_lib_dld_shl_load=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
+if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
+ lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"
+else
+ ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
+if test "x$ac_cv_func_dlopen" = xyes; then :
+ lt_cv_dlopen="dlopen"
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ ac_cv_lib_dl_dlopen=yes
+else
+ ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+ lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
+$as_echo_n "checking for dlopen in -lsvld... " >&6; }
+if ${ac_cv_lib_svld_dlopen+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsvld $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ ac_cv_lib_svld_dlopen=yes
+else
+ ac_cv_lib_svld_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
+$as_echo "$ac_cv_lib_svld_dlopen" >&6; }
+if test "x$ac_cv_lib_svld_dlopen" = xyes; then :
+ lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
+$as_echo_n "checking for dld_link in -ldld... " >&6; }
+if ${ac_cv_lib_dld_dld_link+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dld_link ();
+int
+main ()
+{
+return dld_link ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ ac_cv_lib_dld_dld_link=yes
+else
+ ac_cv_lib_dld_dld_link=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
+$as_echo "$ac_cv_lib_dld_dld_link" >&6; }
+if test "x$ac_cv_lib_dld_dld_link" = xyes; then :
+ lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+ ;;
+ esac
+
+ if test "x$lt_cv_dlopen" != xno; then
+ enable_dlopen=yes
+ else
+ enable_dlopen=no
+ fi
+
+ case $lt_cv_dlopen in
+ dlopen)
+ save_CPPFLAGS="$CPPFLAGS"
+ test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+ save_LDFLAGS="$LDFLAGS"
+ wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+ save_LIBS="$LIBS"
+ LIBS="$lt_cv_dlopen_libs $LIBS"
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
+$as_echo_n "checking whether a program can dlopen itself... " >&6; }
+if ${lt_cv_dlopen_self+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test "$cross_compiling" = yes; then :
+ lt_cv_dlopen_self=cross
+else
+ lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+ lt_status=$lt_dlunknown
+ cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+# define LT_DLGLOBAL RTLD_GLOBAL
+#else
+# ifdef DL_GLOBAL
+# define LT_DLGLOBAL DL_GLOBAL
+# else
+# define LT_DLGLOBAL 0
+# endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+ find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+# ifdef RTLD_LAZY
+# define LT_DLLAZY_OR_NOW RTLD_LAZY
+# else
+# ifdef DL_LAZY
+# define LT_DLLAZY_OR_NOW DL_LAZY
+# else
+# ifdef RTLD_NOW
+# define LT_DLLAZY_OR_NOW RTLD_NOW
+# else
+# ifdef DL_NOW
+# define LT_DLLAZY_OR_NOW DL_NOW
+# else
+# define LT_DLLAZY_OR_NOW 0
+# endif
+# endif
+# endif
+# endif
+#endif
+
+/* When -fvisbility=hidden is used, assume the code has been annotated
+ correspondingly for the symbols needed. */
+#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+ void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+ int status = $lt_dlunknown;
+
+ if (self)
+ {
+ if (dlsym (self,"fnord")) status = $lt_dlno_uscore;
+ else
+ {
+ if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+ else puts (dlerror ());
+ }
+ /* dlclose (self); */
+ }
+ else
+ puts (dlerror ());
+
+ return status;
+}
+_LT_EOF
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+ (eval $ac_link) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
+ (./conftest; exit; ) >&5 2>/dev/null
+ lt_status=$?
+ case x$lt_status in
+ x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
+ x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
+ x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
+ esac
+ else :
+ # compilation failed
+ lt_cv_dlopen_self=no
+ fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
+$as_echo "$lt_cv_dlopen_self" >&6; }
+
+ if test "x$lt_cv_dlopen_self" = xyes; then
+ wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
+$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; }
+if ${lt_cv_dlopen_self_static+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test "$cross_compiling" = yes; then :
+ lt_cv_dlopen_self_static=cross
+else
+ lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+ lt_status=$lt_dlunknown
+ cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+# define LT_DLGLOBAL RTLD_GLOBAL
+#else
+# ifdef DL_GLOBAL
+# define LT_DLGLOBAL DL_GLOBAL
+# else
+# define LT_DLGLOBAL 0
+# endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+ find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+# ifdef RTLD_LAZY
+# define LT_DLLAZY_OR_NOW RTLD_LAZY
+# else
+# ifdef DL_LAZY
+# define LT_DLLAZY_OR_NOW DL_LAZY
+# else
+# ifdef RTLD_NOW
+# define LT_DLLAZY_OR_NOW RTLD_NOW
+# else
+# ifdef DL_NOW
+# define LT_DLLAZY_OR_NOW DL_NOW
+# else
+# define LT_DLLAZY_OR_NOW 0
+# endif
+# endif
+# endif
+# endif
+#endif
+
+/* When -fvisbility=hidden is used, assume the code has been annotated
+ correspondingly for the symbols needed. */
+#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+ void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+ int status = $lt_dlunknown;
+
+ if (self)
+ {
+ if (dlsym (self,"fnord")) status = $lt_dlno_uscore;
+ else
+ {
+ if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+ else puts (dlerror ());
+ }
+ /* dlclose (self); */
+ }
+ else
+ puts (dlerror ());
+
+ return status;
+}
+_LT_EOF
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+ (eval $ac_link) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
+ (./conftest; exit; ) >&5 2>/dev/null
+ lt_status=$?
+ case x$lt_status in
+ x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
+ x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
+ x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
+ esac
+ else :
+ # compilation failed
+ lt_cv_dlopen_self_static=no
+ fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
+$as_echo "$lt_cv_dlopen_self_static" >&6; }
+ fi
+
+ CPPFLAGS="$save_CPPFLAGS"
+ LDFLAGS="$save_LDFLAGS"
+ LIBS="$save_LIBS"
+ ;;
+ esac
+
+ case $lt_cv_dlopen_self in
+ yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+ *) enable_dlopen_self=unknown ;;
+ esac
+
+ case $lt_cv_dlopen_self_static in
+ yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+ *) enable_dlopen_self_static=unknown ;;
+ esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+striplib=
+old_striplib=
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
+$as_echo_n "checking whether stripping libraries is possible... " >&6; }
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+ test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+ test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+ case $host_os in
+ darwin*)
+ if test -n "$STRIP" ; then
+ striplib="$STRIP -x"
+ old_striplib="$STRIP -S"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ fi
+ ;;
+ *)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ ;;
+ esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+ # Report which library types will actually be built
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
+$as_echo_n "checking if libtool supports shared libraries... " >&6; }
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
+$as_echo "$can_build_shared" >&6; }
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
+$as_echo_n "checking whether to build shared libraries... " >&6; }
+ test "$can_build_shared" = "no" && enable_shared=no
+
+ # On AIX, shared libraries and static libraries use the same namespace, and
+ # are all built from PIC.
+ case $host_os in
+ aix3*)
+ test "$enable_shared" = yes && enable_static=no
+ if test -n "$RANLIB"; then
+ archive_cmds="$archive_cmds~\$RANLIB \$lib"
+ postinstall_cmds='$RANLIB $lib'
+ fi
+ ;;
+
+ aix[4-9]*)
+ if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+ test "$enable_shared" = yes && enable_static=no
+ fi
+ ;;
+ esac
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
+$as_echo "$enable_shared" >&6; }
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
+$as_echo_n "checking whether to build static libraries... " >&6; }
+ # Make sure either enable_shared or enable_static is yes.
+ test "$enable_shared" = yes || enable_static=yes
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
+$as_echo "$enable_static" >&6; }
+
+
+
+
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC="$lt_save_CC"
+
+ if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
+ ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
+ (test "X$CXX" != "Xg++"))) ; then
+ ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
+$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
+if test -z "$CXXCPP"; then
+ if ${ac_cv_prog_CXXCPP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ # Double quotes because CXXCPP needs to be expanded
+ for CXXCPP in "$CXX -E" "/lib/cpp"
+ do
+ ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+ # Use a header file that comes with gcc, so configuring glibc
+ # with a fresh cross-compiler works.
+ # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+ # <limits.h> 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 <limits.h>
+#else
+# include <assert.h>
+#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 <ac_nonexistent.h>
+_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 <limits.h> to <assert.h> if __STDC__ is defined, since
+ # <limits.h> 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 <limits.h>
+#else
+# include <assert.h>
+#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 <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+ # Broken: success on invalid input.
+continue
+else
+ # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+ { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+else
+ _lt_caught_CXX_error=yes
+fi
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+archive_cmds_need_lc_CXX=no
+allow_undefined_flag_CXX=
+always_export_symbols_CXX=no
+archive_expsym_cmds_CXX=
+compiler_needs_object_CXX=no
+export_dynamic_flag_spec_CXX=
+hardcode_direct_CXX=no
+hardcode_direct_absolute_CXX=no
+hardcode_libdir_flag_spec_CXX=
+hardcode_libdir_separator_CXX=
+hardcode_minus_L_CXX=no
+hardcode_shlibpath_var_CXX=unsupported
+hardcode_automatic_CXX=no
+inherit_rpath_CXX=no
+module_cmds_CXX=
+module_expsym_cmds_CXX=
+link_all_deplibs_CXX=unknown
+old_archive_cmds_CXX=$old_archive_cmds
+reload_flag_CXX=$reload_flag
+reload_cmds_CXX=$reload_cmds
+no_undefined_flag_CXX=
+whole_archive_flag_spec_CXX=
+enable_shared_with_static_runtimes_CXX=no
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+objext_CXX=$objext
+
+# No sense in running all these tests if we already determined that
+# the CXX compiler isn't working. Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test "$_lt_caught_CXX_error" != yes; then
+ # Code to be used in simple compile tests
+ lt_simple_compile_test_code="int some_variable = 0;"
+
+ # Code to be used in simple link tests
+ lt_simple_link_test_code='int main(int, char *[]) { return(0); }'
+
+ # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+ # save warnings/boilerplate of simple test code
+ ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+ ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+ # Allow CC to be a program name with arguments.
+ lt_save_CC=$CC
+ lt_save_CFLAGS=$CFLAGS
+ lt_save_LD=$LD
+ lt_save_GCC=$GCC
+ GCC=$GXX
+ lt_save_with_gnu_ld=$with_gnu_ld
+ lt_save_path_LD=$lt_cv_path_LD
+ if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+ lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+ else
+ $as_unset lt_cv_prog_gnu_ld
+ fi
+ if test -n "${lt_cv_path_LDCXX+set}"; then
+ lt_cv_path_LD=$lt_cv_path_LDCXX
+ else
+ $as_unset lt_cv_path_LD
+ fi
+ test -z "${LDCXX+set}" || LD=$LDCXX
+ CC=${CXX-"c++"}
+ CFLAGS=$CXXFLAGS
+ compiler=$CC
+ compiler_CXX=$CC
+ for cc_temp in $compiler""; do
+ case $cc_temp in
+ compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+ distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+ \-*) ;;
+ *) break;;
+ esac
+done
+cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+
+
+ if test -n "$compiler"; then
+ # We don't want -fno-exception when compiling C++ code, so set the
+ # no_builtin_flag separately
+ if test "$GXX" = yes; then
+ lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'
+ else
+ lt_prog_compiler_no_builtin_flag_CXX=
+ fi
+
+ if test "$GXX" = yes; then
+ # Set up default GNU C++ configuration
+
+
+
+# Check whether --with-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then :
+ withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
+else
+ with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test "$GCC" = yes; then
+ # Check if gcc -print-prog-name=ld gives a path.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+$as_echo_n "checking for ld used by $CC... " >&6; }
+ case $host in
+ *-*-mingw*)
+ # gcc leaves a trailing carriage return which upsets mingw
+ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+ *)
+ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+ esac
+ case $ac_prog in
+ # Accept absolute paths.
+ [\\/]* | ?:[\\/]*)
+ re_direlt='/[^/][^/]*/\.\./'
+ # Canonicalize the pathname of ld
+ ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+ while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+ ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+ done
+ test -z "$LD" && LD="$ac_prog"
+ ;;
+ "")
+ # If it fails, then pretend we aren't using GCC.
+ ac_prog=ld
+ ;;
+ *)
+ # If it is relative, then search for the first ld in PATH.
+ with_gnu_ld=unknown
+ ;;
+ esac
+elif test "$with_gnu_ld" = yes; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+$as_echo_n "checking for GNU ld... " >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+$as_echo_n "checking for non-GNU ld... " >&6; }
+fi
+if ${lt_cv_path_LD+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -z "$LD"; then
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+ for ac_dir in $PATH; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+ lt_cv_path_LD="$ac_dir/$ac_prog"
+ # Check to see if the program is GNU ld. I'd rather use --version,
+ # but apparently some variants of GNU ld only accept -v.
+ # Break only if it was the GNU/non-GNU ld that we prefer.
+ case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+ *GNU* | *'with BFD'*)
+ test "$with_gnu_ld" != no && break
+ ;;
+ *)
+ test "$with_gnu_ld" != yes && break
+ ;;
+ esac
+ fi
+ done
+ IFS="$lt_save_ifs"
+else
+ lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi
+fi
+
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&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 </dev/null` in
+*GNU* | *'with BFD'*)
+ lt_cv_prog_gnu_ld=yes
+ ;;
+*)
+ lt_cv_prog_gnu_ld=no
+ ;;
+esac
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+$as_echo "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+ # Check if GNU C++ uses GNU ld as the underlying linker, since the
+ # archiving commands below assume that GNU ld is being used.
+ if test "$with_gnu_ld" = yes; then
+ archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+ export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+
+ # If archive_cmds runs LD, not CC, wlarc should be empty
+ # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+ # investigate it a little bit more. (MM)
+ wlarc='${wl}'
+
+ # ancient GNU ld didn't support --whole-archive et. al.
+ if eval "`$CC -print-prog-name=ld` --help 2>&1" |
+ $GREP 'no-whole-archive' > /dev/null; then
+ whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+ else
+ whole_archive_flag_spec_CXX=
+ fi
+ else
+ with_gnu_ld=no
+ wlarc=
+
+ # A generic and very simple default shared library creation
+ # command for GNU C++ for the case where it uses the native
+ # linker, instead of GNU ld. If possible, this setting should
+ # overridden to take advantage of the native linker features on
+ # the platform it is being used on.
+ archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+ fi
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+
+ else
+ GXX=no
+ with_gnu_ld=no
+ wlarc=
+ fi
+
+ # PORTME: fill in a description of your system's C++ link characteristics
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+ ld_shlibs_CXX=yes
+ case $host_os in
+ aix3*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ aix[4-9]*)
+ if test "$host_cpu" = ia64; then
+ # On IA64, the linker does run time linking by default, so we don't
+ # have to do anything special.
+ aix_use_runtimelinking=no
+ exp_sym_flag='-Bexport'
+ no_entry_flag=""
+ else
+ aix_use_runtimelinking=no
+
+ # Test if we are trying to use run time linking or normal
+ # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+ # need to do runtime linking.
+ case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
+ for ld_flag in $LDFLAGS; do
+ case $ld_flag in
+ *-brtl*)
+ aix_use_runtimelinking=yes
+ break
+ ;;
+ esac
+ done
+ ;;
+ esac
+
+ exp_sym_flag='-bexport'
+ no_entry_flag='-bnoentry'
+ fi
+
+ # When large executables or shared objects are built, AIX ld can
+ # have problems creating the table of contents. If linking a library
+ # or program results in "error TOC overflow" add -mminimal-toc to
+ # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not
+ # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+ archive_cmds_CXX=''
+ hardcode_direct_CXX=yes
+ hardcode_direct_absolute_CXX=yes
+ hardcode_libdir_separator_CXX=':'
+ link_all_deplibs_CXX=yes
+ file_list_spec_CXX='${wl}-f,'
+
+ if test "$GXX" = yes; then
+ case $host_os in aix4.[012]|aix4.[012].*)
+ # We only want to do this on AIX 4.2 and lower, the check
+ # below for broken collect2 doesn't work under 4.3+
+ collect2name=`${CC} -print-prog-name=collect2`
+ if test -f "$collect2name" &&
+ strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+ then
+ # We have reworked collect2
+ :
+ else
+ # We have old collect2
+ hardcode_direct_CXX=unsupported
+ # It fails to find uninstalled libraries when the uninstalled
+ # path is not listed in the libpath. Setting hardcode_minus_L
+ # to unsupported forces relinking
+ hardcode_minus_L_CXX=yes
+ hardcode_libdir_flag_spec_CXX='-L$libdir'
+ hardcode_libdir_separator_CXX=
+ fi
+ esac
+ shared_flag='-shared'
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag="$shared_flag "'${wl}-G'
+ fi
+ else
+ # not using gcc
+ if test "$host_cpu" = ia64; then
+ # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+ # chokes on -Wl,-G. The following line is correct:
+ shared_flag='-G'
+ else
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag='${wl}-G'
+ else
+ shared_flag='${wl}-bM:SRE'
+ fi
+ fi
+ fi
+
+ export_dynamic_flag_spec_CXX='${wl}-bexpall'
+ # It seems that -bexpall does not export symbols beginning with
+ # underscore (_), so it is better to generate a list of symbols to
+ # export.
+ always_export_symbols_CXX=yes
+ if test "$aix_use_runtimelinking" = yes; then
+ # Warning - without using the other runtime loading flags (-brtl),
+ # -berok will link without error, but may produce a broken library.
+ allow_undefined_flag_CXX='-berok'
+ # Determine the default libpath from the value encoded in an empty
+ # executable.
+ if test "${lt_cv_aix_libpath+set}" = set; then
+ aix_libpath=$lt_cv_aix_libpath
+else
+ if ${lt_cv_aix_libpath__CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+
+ lt_aix_libpath_sed='
+ /Import File Strings/,/^$/ {
+ /^0/ {
+ s/^0 *\([^ ]*\) *$/\1/
+ p
+ }
+ }'
+ lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ # Check for a 64-bit object if we didn't find anything.
+ if test -z "$lt_cv_aix_libpath__CXX"; then
+ lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ if test -z "$lt_cv_aix_libpath__CXX"; then
+ lt_cv_aix_libpath__CXX="/usr/lib:/lib"
+ fi
+
+fi
+
+ aix_libpath=$lt_cv_aix_libpath__CXX
+fi
+
+ hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"
+
+ archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+ else
+ if test "$host_cpu" = ia64; then
+ hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib'
+ allow_undefined_flag_CXX="-z nodefs"
+ archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+ else
+ # Determine the default libpath from the value encoded in an
+ # empty executable.
+ if test "${lt_cv_aix_libpath+set}" = set; then
+ aix_libpath=$lt_cv_aix_libpath
+else
+ if ${lt_cv_aix_libpath__CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+
+ lt_aix_libpath_sed='
+ /Import File Strings/,/^$/ {
+ /^0/ {
+ s/^0 *\([^ ]*\) *$/\1/
+ p
+ }
+ }'
+ lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ # Check for a 64-bit object if we didn't find anything.
+ if test -z "$lt_cv_aix_libpath__CXX"; then
+ lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ if test -z "$lt_cv_aix_libpath__CXX"; then
+ lt_cv_aix_libpath__CXX="/usr/lib:/lib"
+ fi
+
+fi
+
+ aix_libpath=$lt_cv_aix_libpath__CXX
+fi
+
+ hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath"
+ # Warning - without using the other run time loading flags,
+ # -berok will link without error, but may produce a broken library.
+ no_undefined_flag_CXX=' ${wl}-bernotok'
+ allow_undefined_flag_CXX=' ${wl}-berok'
+ if test "$with_gnu_ld" = yes; then
+ # We only use this code for GNU lds that support --whole-archive.
+ whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+ else
+ # Exported symbols can be pulled into shared objects from archives
+ whole_archive_flag_spec_CXX='$convenience'
+ fi
+ archive_cmds_need_lc_CXX=yes
+ # This is similar to how AIX traditionally builds its shared
+ # libraries.
+ archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+ fi
+ fi
+ ;;
+
+ beos*)
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ allow_undefined_flag_CXX=unsupported
+ # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+ # support --undefined. This deserves some investigation. FIXME
+ archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ else
+ ld_shlibs_CXX=no
+ fi
+ ;;
+
+ chorus*)
+ case $cc_basename in
+ *)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ esac
+ ;;
+
+ cygwin* | mingw* | pw32* | cegcc*)
+ case $GXX,$cc_basename in
+ ,cl* | no,cl*)
+ # Native MSVC
+ # hardcode_libdir_flag_spec is actually meaningless, as there is
+ # no search path for DLLs.
+ hardcode_libdir_flag_spec_CXX=' '
+ allow_undefined_flag_CXX=unsupported
+ always_export_symbols_CXX=yes
+ file_list_spec_CXX='@'
+ # Tell ltmain to make .lib files, not .a files.
+ libext=lib
+ # Tell ltmain to make .dll files, not .so files.
+ shrext_cmds=".dll"
+ # FIXME: Setting linknames here is a bad hack.
+ archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
+ archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
+ else
+ $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
+ fi~
+ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+ linknames='
+ # The linker will not automatically build a static lib if we build a DLL.
+ # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true'
+ enable_shared_with_static_runtimes_CXX=yes
+ # Don't use ranlib
+ old_postinstall_cmds_CXX='chmod 644 $oldlib'
+ postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~
+ lt_tool_outputfile="@TOOL_OUTPUT@"~
+ case $lt_outputfile in
+ *.exe|*.EXE) ;;
+ *)
+ lt_outputfile="$lt_outputfile.exe"
+ lt_tool_outputfile="$lt_tool_outputfile.exe"
+ ;;
+ esac~
+ func_to_tool_file "$lt_outputfile"~
+ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
+ $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+ $RM "$lt_outputfile.manifest";
+ fi'
+ ;;
+ *)
+ # g++
+ # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,
+ # as there is no search path for DLLs.
+ hardcode_libdir_flag_spec_CXX='-L$libdir'
+ export_dynamic_flag_spec_CXX='${wl}--export-all-symbols'
+ allow_undefined_flag_CXX=unsupported
+ always_export_symbols_CXX=no
+ enable_shared_with_static_runtimes_CXX=yes
+
+ if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+ archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ # If the export-symbols file already is a .def file (1st line
+ # is EXPORTS), use it as is; otherwise, prepend...
+ archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ cp $export_symbols $output_objdir/$soname.def;
+ else
+ echo EXPORTS > $output_objdir/$soname.def;
+ cat $export_symbols >> $output_objdir/$soname.def;
+ fi~
+ $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ else
+ ld_shlibs_CXX=no
+ fi
+ ;;
+ esac
+ ;;
+ darwin* | rhapsody*)
+
+
+ archive_cmds_need_lc_CXX=no
+ hardcode_direct_CXX=no
+ hardcode_automatic_CXX=yes
+ hardcode_shlibpath_var_CXX=unsupported
+ if test "$lt_cv_ld_force_load" = "yes"; then
+ whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+
+ else
+ whole_archive_flag_spec_CXX=''
+ fi
+ link_all_deplibs_CXX=yes
+ allow_undefined_flag_CXX="$_lt_dar_allow_undefined"
+ case $cc_basename in
+ ifort*) _lt_dar_can_shared=yes ;;
+ *) _lt_dar_can_shared=$GCC ;;
+ esac
+ if test "$_lt_dar_can_shared" = "yes"; then
+ output_verbose_link_cmd=func_echo_all
+ archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
+ module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
+ archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
+ module_expsym_cmds_CXX="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
+ if test "$lt_cv_apple_cc_single_mod" != "yes"; then
+ archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
+ archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
+ fi
+
+ else
+ ld_shlibs_CXX=no
+ fi
+
+ ;;
+
+ dgux*)
+ case $cc_basename in
+ ec++*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ ghcx*)
+ # Green Hills C++ Compiler
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ esac
+ ;;
+
+ freebsd2.*)
+ # C++ shared libraries reported to be fairly broken before
+ # switch to ELF
+ ld_shlibs_CXX=no
+ ;;
+
+ freebsd-elf*)
+ archive_cmds_need_lc_CXX=no
+ ;;
+
+ freebsd* | dragonfly*)
+ # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+ # conventions
+ ld_shlibs_CXX=yes
+ ;;
+
+ haiku*)
+ archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ link_all_deplibs_CXX=yes
+ ;;
+
+ hpux9*)
+ hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
+ hardcode_libdir_separator_CXX=:
+ export_dynamic_flag_spec_CXX='${wl}-E'
+ hardcode_direct_CXX=yes
+ hardcode_minus_L_CXX=yes # Not in the search PATH,
+ # but as the default
+ # location of the library.
+
+ case $cc_basename in
+ CC*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ aCC*)
+ archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+ ;;
+ *)
+ if test "$GXX" = yes; then
+ archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ else
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ fi
+ ;;
+ esac
+ ;;
+
+ hpux10*|hpux11*)
+ if test $with_gnu_ld = no; then
+ hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir'
+ hardcode_libdir_separator_CXX=:
+
+ case $host_cpu in
+ hppa*64*|ia64*)
+ ;;
+ *)
+ export_dynamic_flag_spec_CXX='${wl}-E'
+ ;;
+ esac
+ fi
+ case $host_cpu in
+ hppa*64*|ia64*)
+ hardcode_direct_CXX=no
+ hardcode_shlibpath_var_CXX=no
+ ;;
+ *)
+ hardcode_direct_CXX=yes
+ hardcode_direct_absolute_CXX=yes
+ hardcode_minus_L_CXX=yes # Not in the search PATH,
+ # but as the default
+ # location of the library.
+ ;;
+ esac
+
+ case $cc_basename in
+ CC*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ aCC*)
+ case $host_cpu in
+ hppa*64*)
+ archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ ia64*)
+ archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ *)
+ archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ esac
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+ ;;
+ *)
+ if test "$GXX" = yes; then
+ if test $with_gnu_ld = no; then
+ case $host_cpu in
+ hppa*64*)
+ archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ ia64*)
+ archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ *)
+ archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ esac
+ fi
+ else
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ fi
+ ;;
+ esac
+ ;;
+
+ interix[3-9]*)
+ hardcode_direct_CXX=no
+ hardcode_shlibpath_var_CXX=no
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+ export_dynamic_flag_spec_CXX='${wl}-E'
+ # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+ # Instead, shared libraries are loaded at an image base (0x10000000 by
+ # default) and relocated if they conflict, which is a slow very memory
+ # consuming and fragmenting process. To avoid this, we pick a random,
+ # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+ # time. Moving up from 0x10000000 also allows more sbrk(2) space.
+ archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ ;;
+ irix5* | irix6*)
+ case $cc_basename in
+ CC*)
+ # SGI C++
+ archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+
+ # Archives containing C++ object files must be created using
+ # "CC -ar", where "CC" is the IRIX C++ compiler. This is
+ # necessary to make sure instantiated templates are included
+ # in the archive.
+ old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'
+ ;;
+ *)
+ if test "$GXX" = yes; then
+ if test "$with_gnu_ld" = no; then
+ archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ else
+ archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib'
+ fi
+ fi
+ link_all_deplibs_CXX=yes
+ ;;
+ esac
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+ hardcode_libdir_separator_CXX=:
+ inherit_rpath_CXX=yes
+ ;;
+
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ case $cc_basename in
+ KCC*)
+ # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+ # KCC will only create a shared library if the output file
+ # ends with ".so" (or ".sl" for HP-UX), so rename the library
+ # to its proper name (with version) after linking.
+ archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+ archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+ export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+
+ # Archives containing C++ object files must be created using
+ # "CC -Bstatic", where "CC" is the KAI C++ compiler.
+ old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'
+ ;;
+ icpc* | ecpc* )
+ # Intel C++
+ with_gnu_ld=yes
+ # version 8.0 and above of icpc choke on multiply defined symbols
+ # if we add $predep_objects and $postdep_objects, however 7.1 and
+ # earlier do not add the objects themselves.
+ case `$CC -V 2>&1` in
+ *"Version 7."*)
+ archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ ;;
+ *) # Version 8.0 or newer
+ tmp_idyn=
+ case $host_cpu in
+ ia64*) tmp_idyn=' -i_dynamic';;
+ esac
+ archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ ;;
+ esac
+ archive_cmds_need_lc_CXX=no
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+ export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+ whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+ ;;
+ pgCC* | pgcpp*)
+ # Portland Group C++ compiler
+ case `$CC -V` in
+ *pgCC\ [1-5].* | *pgcpp\ [1-5].*)
+ prelink_cmds_CXX='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+ compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ old_archive_cmds_CXX='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+ $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ $RANLIB $oldlib'
+ archive_cmds_CXX='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ archive_expsym_cmds_CXX='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ ;;
+ *) # Version 6 and above use weak symbols
+ archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ ;;
+ esac
+
+ hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir'
+ export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+ whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ ;;
+ cxx*)
+ # Compaq C++
+ archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+
+ runpath_var=LD_RUN_PATH
+ hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+ hardcode_libdir_separator_CXX=:
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
+ ;;
+ xl* | mpixl* | bgxl*)
+ # IBM XL 8.0 on PPC, with GNU ld
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+ export_dynamic_flag_spec_CXX='${wl}--export-dynamic'
+ archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ if test "x$supports_anon_versioning" = xyes; then
+ archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~
+ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+ echo "local: *; };" >> $output_objdir/$libname.ver~
+ $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+ fi
+ ;;
+ *)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*)
+ # Sun C++ 5.9
+ no_undefined_flag_CXX=' -zdefs'
+ archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ archive_expsym_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
+ hardcode_libdir_flag_spec_CXX='-R$libdir'
+ whole_archive_flag_spec_CXX='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ compiler_needs_object_CXX=yes
+
+ # Not sure whether something based on
+ # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
+ # would be better.
+ output_verbose_link_cmd='func_echo_all'
+
+ # Archives containing C++ object files must be created using
+ # "CC -xar", where "CC" is the Sun C++ compiler. This is
+ # necessary to make sure instantiated templates are included
+ # in the archive.
+ old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
+ ;;
+ esac
+ ;;
+ esac
+ ;;
+
+ lynxos*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+
+ m88k*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+
+ mvs*)
+ case $cc_basename in
+ cxx*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ esac
+ ;;
+
+ netbsd*)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ archive_cmds_CXX='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+ wlarc=
+ hardcode_libdir_flag_spec_CXX='-R$libdir'
+ hardcode_direct_CXX=yes
+ hardcode_shlibpath_var_CXX=no
+ fi
+ # Workaround some broken pre-1.5 toolchains
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+ ;;
+
+ *nto* | *qnx*)
+ ld_shlibs_CXX=yes
+ ;;
+
+ openbsd2*)
+ # C++ shared libraries are fairly broken
+ ld_shlibs_CXX=no
+ ;;
+
+ openbsd*)
+ if test -f /usr/libexec/ld.so; then
+ hardcode_direct_CXX=yes
+ hardcode_shlibpath_var_CXX=no
+ hardcode_direct_absolute_CXX=yes
+ archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+ if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
+ export_dynamic_flag_spec_CXX='${wl}-E'
+ whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+ fi
+ output_verbose_link_cmd=func_echo_all
+ else
+ ld_shlibs_CXX=no
+ fi
+ ;;
+
+ osf3* | osf4* | osf5*)
+ case $cc_basename in
+ KCC*)
+ # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+ # KCC will only create a shared library if the output file
+ # ends with ".so" (or ".sl" for HP-UX), so rename the library
+ # to its proper name (with version) after linking.
+ archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir'
+ hardcode_libdir_separator_CXX=:
+
+ # Archives containing C++ object files must be created using
+ # the KAI C++ compiler.
+ case $host in
+ osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;;
+ *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;;
+ esac
+ ;;
+ RCC*)
+ # Rational C++ 2.4.1
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ cxx*)
+ case $host in
+ osf3*)
+ allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
+ archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+ ;;
+ *)
+ allow_undefined_flag_CXX=' -expect_unresolved \*'
+ archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+ echo "-hidden">> $lib.exp~
+ $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~
+ $RM $lib.exp'
+ hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+ ;;
+ esac
+
+ hardcode_libdir_separator_CXX=:
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+ ;;
+ *)
+ if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+ allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*'
+ case $host in
+ osf3*)
+ archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ ;;
+ *)
+ archive_cmds_CXX='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ ;;
+ esac
+
+ hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir'
+ hardcode_libdir_separator_CXX=:
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+
+ else
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ fi
+ ;;
+ esac
+ ;;
+
+ psos*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+
+ sunos4*)
+ case $cc_basename in
+ CC*)
+ # Sun C++ 4.x
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ lcc*)
+ # Lucid
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ esac
+ ;;
+
+ solaris*)
+ case $cc_basename in
+ CC* | sunCC*)
+ # Sun C++ 4.2, 5.x and Centerline C++
+ archive_cmds_need_lc_CXX=yes
+ no_undefined_flag_CXX=' -zdefs'
+ archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+ hardcode_libdir_flag_spec_CXX='-R$libdir'
+ hardcode_shlibpath_var_CXX=no
+ case $host_os in
+ solaris2.[0-5] | solaris2.[0-5].*) ;;
+ *)
+ # The compiler driver will combine and reorder linker options,
+ # but understands `-z linker_flag'.
+ # Supported since Solaris 2.6 (maybe 2.5.1?)
+ whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract'
+ ;;
+ esac
+ link_all_deplibs_CXX=yes
+
+ output_verbose_link_cmd='func_echo_all'
+
+ # Archives containing C++ object files must be created using
+ # "CC -xar", where "CC" is the Sun C++ compiler. This is
+ # necessary to make sure instantiated templates are included
+ # in the archive.
+ old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
+ ;;
+ gcx*)
+ # Green Hills C++ Compiler
+ archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+
+ # The C++ compiler must be used to create the archive.
+ old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+ ;;
+ *)
+ # GNU C++ compiler with Solaris linker
+ if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+ no_undefined_flag_CXX=' ${wl}-z ${wl}defs'
+ if $CC --version | $GREP -v '^2\.7' > /dev/null; then
+ archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+ archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+ else
+ # g++ 2.7 appears to require `-G' NOT `-shared' on this
+ # platform.
+ archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+ archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+ fi
+
+ hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir'
+ case $host_os in
+ solaris2.[0-5] | solaris2.[0-5].*) ;;
+ *)
+ whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+ ;;
+ esac
+ fi
+ ;;
+ esac
+ ;;
+
+ sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+ no_undefined_flag_CXX='${wl}-z,text'
+ archive_cmds_need_lc_CXX=no
+ hardcode_shlibpath_var_CXX=no
+ runpath_var='LD_RUN_PATH'
+
+ case $cc_basename in
+ CC*)
+ archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ *)
+ archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ esac
+ ;;
+
+ sysv5* | sco3.2v5* | sco5v6*)
+ # Note: We can NOT use -z defs as we might desire, because we do not
+ # link with -lc, and that would cause any symbols used from libc to
+ # always be unresolved, which means just about no library would
+ # ever link correctly. If we're not using GNU ld we use -z text
+ # though, which does catch some bad symbols but isn't as heavy-handed
+ # as -z defs.
+ no_undefined_flag_CXX='${wl}-z,text'
+ allow_undefined_flag_CXX='${wl}-z,nodefs'
+ archive_cmds_need_lc_CXX=no
+ hardcode_shlibpath_var_CXX=no
+ hardcode_libdir_flag_spec_CXX='${wl}-R,$libdir'
+ hardcode_libdir_separator_CXX=':'
+ link_all_deplibs_CXX=yes
+ export_dynamic_flag_spec_CXX='${wl}-Bexport'
+ runpath_var='LD_RUN_PATH'
+
+ case $cc_basename in
+ CC*)
+ archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~
+ '"$old_archive_cmds_CXX"
+ reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~
+ '"$reload_cmds_CXX"
+ ;;
+ *)
+ archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ esac
+ ;;
+
+ tandem*)
+ case $cc_basename in
+ NCC*)
+ # NonStop-UX NCC 3.20
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ esac
+ ;;
+
+ vxworks*)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+
+ *)
+ # FIXME: insert proper C++ library support
+ ld_shlibs_CXX=no
+ ;;
+ esac
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
+$as_echo "$ld_shlibs_CXX" >&6; }
+ test "$ld_shlibs_CXX" = no && can_build_shared=no
+
+ GCC_CXX="$GXX"
+ LD_CXX="$LD"
+
+ ## CAVEAT EMPTOR:
+ ## There is no encapsulation within the following macros, do not change
+ ## the running order or otherwise move them around unless you know exactly
+ ## what you are doing...
+ # Dependencies to place before and after the object being linked:
+predep_objects_CXX=
+postdep_objects_CXX=
+predeps_CXX=
+postdeps_CXX=
+compiler_lib_search_path_CXX=
+
+cat > conftest.$ac_ext <<_LT_EOF
+class Foo
+{
+public:
+ Foo (void) { a = 0; }
+private:
+ int a;
+};
+_LT_EOF
+
+
+_lt_libdeps_save_CFLAGS=$CFLAGS
+case "$CC $CFLAGS " in #(
+*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
+*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
+*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
+esac
+
+if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }; then
+ # Parse the compiler output and extract the necessary
+ # objects, libraries and library flags.
+
+ # Sentinel used to keep track of whether or not we are before
+ # the conftest object file.
+ pre_test_object_deps_done=no
+
+ for p in `eval "$output_verbose_link_cmd"`; do
+ case ${prev}${p} in
+
+ -L* | -R* | -l*)
+ # Some compilers place space between "-{L,R}" and the path.
+ # Remove the space.
+ if test $p = "-L" ||
+ test $p = "-R"; then
+ prev=$p
+ continue
+ fi
+
+ # Expand the sysroot to ease extracting the directories later.
+ if test -z "$prev"; then
+ case $p in
+ -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
+ -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
+ -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
+ esac
+ fi
+ case $p in
+ =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
+ esac
+ if test "$pre_test_object_deps_done" = no; then
+ case ${prev} in
+ -L | -R)
+ # Internal compiler library paths should come after those
+ # provided the user. The postdeps already come after the
+ # user supplied libs so there is no need to process them.
+ if test -z "$compiler_lib_search_path_CXX"; then
+ compiler_lib_search_path_CXX="${prev}${p}"
+ else
+ compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}"
+ fi
+ ;;
+ # The "-l" case would never come before the object being
+ # linked, so don't bother handling this case.
+ esac
+ else
+ if test -z "$postdeps_CXX"; then
+ postdeps_CXX="${prev}${p}"
+ else
+ postdeps_CXX="${postdeps_CXX} ${prev}${p}"
+ fi
+ fi
+ prev=
+ ;;
+
+ *.lto.$objext) ;; # Ignore GCC LTO objects
+ *.$objext)
+ # This assumes that the test object file only shows up
+ # once in the compiler output.
+ if test "$p" = "conftest.$objext"; then
+ pre_test_object_deps_done=yes
+ continue
+ fi
+
+ if test "$pre_test_object_deps_done" = no; then
+ if test -z "$predep_objects_CXX"; then
+ predep_objects_CXX="$p"
+ else
+ predep_objects_CXX="$predep_objects_CXX $p"
+ fi
+ else
+ if test -z "$postdep_objects_CXX"; then
+ postdep_objects_CXX="$p"
+ else
+ postdep_objects_CXX="$postdep_objects_CXX $p"
+ fi
+ fi
+ ;;
+
+ *) ;; # Ignore the rest.
+
+ esac
+ done
+
+ # Clean up.
+ rm -f a.out a.exe
+else
+ echo "libtool.m4: error: problem compiling CXX test program"
+fi
+
+$RM -f confest.$objext
+CFLAGS=$_lt_libdeps_save_CFLAGS
+
+# PORTME: override above test on systems where it is broken
+case $host_os in
+interix[3-9]*)
+ # Interix 3.5 installs completely hosed .la files for C++, so rather than
+ # hack all around it, let's just trust "g++" to DTRT.
+ predep_objects_CXX=
+ postdep_objects_CXX=
+ postdeps_CXX=
+ ;;
+
+linux*)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*)
+ # Sun C++ 5.9
+
+ # The more standards-conforming stlport4 library is
+ # incompatible with the Cstd library. Avoid specifying
+ # it if it's in CXXFLAGS. Ignore libCrun as
+ # -library=stlport4 depends on it.
+ case " $CXX $CXXFLAGS " in
+ *" -library=stlport4 "*)
+ solaris_use_stlport4=yes
+ ;;
+ esac
+
+ if test "$solaris_use_stlport4" != yes; then
+ postdeps_CXX='-library=Cstd -library=Crun'
+ fi
+ ;;
+ esac
+ ;;
+
+solaris*)
+ case $cc_basename in
+ CC* | sunCC*)
+ # The more standards-conforming stlport4 library is
+ # incompatible with the Cstd library. Avoid specifying
+ # it if it's in CXXFLAGS. Ignore libCrun as
+ # -library=stlport4 depends on it.
+ case " $CXX $CXXFLAGS " in
+ *" -library=stlport4 "*)
+ solaris_use_stlport4=yes
+ ;;
+ esac
+
+ # Adding this requires a known-good setup of shared libraries for
+ # Sun compiler versions before 5.6, else PIC objects from an old
+ # archive will be linked into the output, leading to subtle bugs.
+ if test "$solaris_use_stlport4" != yes; then
+ postdeps_CXX='-library=Cstd -library=Crun'
+ fi
+ ;;
+ esac
+ ;;
+esac
+
+
+case " $postdeps_CXX " in
+*" -lc "*) archive_cmds_need_lc_CXX=no ;;
+esac
+ compiler_lib_search_dirs_CXX=
+if test -n "${compiler_lib_search_path_CXX}"; then
+ compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lt_prog_compiler_wl_CXX=
+lt_prog_compiler_pic_CXX=
+lt_prog_compiler_static_CXX=
+
+
+ # C++ specific cases for pic, static, wl, etc.
+ if test "$GXX" = yes; then
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_static_CXX='-static'
+
+ case $host_os in
+ aix*)
+ # All AIX code is PIC.
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ lt_prog_compiler_static_CXX='-Bstatic'
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ lt_prog_compiler_pic_CXX='-fPIC'
+ ;;
+ m68k)
+ # FIXME: we need at least 68020 code to build shared libraries, but
+ # adding the `-m68020' flag to GCC prevents building anything better,
+ # like `-m68040'.
+ lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'
+ ;;
+ esac
+ ;;
+
+ beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+ # PIC is the default for these OSes.
+ ;;
+ mingw* | cygwin* | os2* | pw32* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ # Although the cygwin gcc ignores -fPIC, still need this for old-style
+ # (--disable-auto-import) libraries
+ lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+ ;;
+ darwin* | rhapsody*)
+ # PIC is the default on this platform
+ # Common symbols not allowed in MH_DYLIB files
+ lt_prog_compiler_pic_CXX='-fno-common'
+ ;;
+ *djgpp*)
+ # DJGPP does not support shared libraries at all
+ lt_prog_compiler_pic_CXX=
+ ;;
+ haiku*)
+ # PIC is the default for Haiku.
+ # The "-static" flag exists, but is broken.
+ lt_prog_compiler_static_CXX=
+ ;;
+ interix[3-9]*)
+ # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+ # Instead, we relocate shared libraries at runtime.
+ ;;
+ sysv4*MP*)
+ if test -d /usr/nec; then
+ lt_prog_compiler_pic_CXX=-Kconform_pic
+ fi
+ ;;
+ hpux*)
+ # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+ # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag
+ # sets the default TLS model and affects inlining.
+ case $host_cpu in
+ hppa*64*)
+ ;;
+ *)
+ lt_prog_compiler_pic_CXX='-fPIC'
+ ;;
+ esac
+ ;;
+ *qnx* | *nto*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ lt_prog_compiler_pic_CXX='-fPIC -shared'
+ ;;
+ *)
+ lt_prog_compiler_pic_CXX='-fPIC'
+ ;;
+ esac
+ else
+ case $host_os in
+ aix[4-9]*)
+ # All AIX code is PIC.
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ lt_prog_compiler_static_CXX='-Bstatic'
+ else
+ lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp'
+ fi
+ ;;
+ chorus*)
+ case $cc_basename in
+ cxch68*)
+ # Green Hills C++ Compiler
+ # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+ ;;
+ esac
+ ;;
+ mingw* | cygwin* | os2* | pw32* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+ ;;
+ dgux*)
+ case $cc_basename in
+ ec++*)
+ lt_prog_compiler_pic_CXX='-KPIC'
+ ;;
+ ghcx*)
+ # Green Hills C++ Compiler
+ lt_prog_compiler_pic_CXX='-pic'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ freebsd* | dragonfly*)
+ # FreeBSD uses GNU C++
+ ;;
+ hpux9* | hpux10* | hpux11*)
+ case $cc_basename in
+ CC*)
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
+ if test "$host_cpu" != ia64; then
+ lt_prog_compiler_pic_CXX='+Z'
+ fi
+ ;;
+ aCC*)
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_static_CXX='${wl}-a ${wl}archive'
+ case $host_cpu in
+ hppa*64*|ia64*)
+ # +Z the default
+ ;;
+ *)
+ lt_prog_compiler_pic_CXX='+Z'
+ ;;
+ esac
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ interix*)
+ # This is c89, which is MS Visual C++ (no shared libs)
+ # Anyone wants to do a port?
+ ;;
+ irix5* | irix6* | nonstopux*)
+ case $cc_basename in
+ CC*)
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_static_CXX='-non_shared'
+ # CC pic flag -KPIC is the default.
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ case $cc_basename in
+ KCC*)
+ # KAI C++ Compiler
+ lt_prog_compiler_wl_CXX='--backend -Wl,'
+ lt_prog_compiler_pic_CXX='-fPIC'
+ ;;
+ ecpc* )
+ # old Intel C++ for x86_64 which still supported -KPIC.
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_pic_CXX='-KPIC'
+ lt_prog_compiler_static_CXX='-static'
+ ;;
+ icpc* )
+ # Intel C++, used to be incompatible with GCC.
+ # ICC 10 doesn't accept -KPIC any more.
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_pic_CXX='-fPIC'
+ lt_prog_compiler_static_CXX='-static'
+ ;;
+ pgCC* | pgcpp*)
+ # Portland Group C++ compiler
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_pic_CXX='-fpic'
+ lt_prog_compiler_static_CXX='-Bstatic'
+ ;;
+ cxx*)
+ # Compaq C++
+ # Make sure the PIC flag is empty. It appears that all Alpha
+ # Linux and Compaq Tru64 Unix objects are PIC.
+ lt_prog_compiler_pic_CXX=
+ lt_prog_compiler_static_CXX='-non_shared'
+ ;;
+ xlc* | xlC* | bgxl[cC]* | mpixl[cC]*)
+ # IBM XL 8.0, 9.0 on PPC and BlueGene
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_pic_CXX='-qpic'
+ lt_prog_compiler_static_CXX='-qstaticlink'
+ ;;
+ *)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*)
+ # Sun C++ 5.9
+ lt_prog_compiler_pic_CXX='-KPIC'
+ lt_prog_compiler_static_CXX='-Bstatic'
+ lt_prog_compiler_wl_CXX='-Qoption ld '
+ ;;
+ esac
+ ;;
+ esac
+ ;;
+ lynxos*)
+ ;;
+ m88k*)
+ ;;
+ mvs*)
+ case $cc_basename in
+ cxx*)
+ lt_prog_compiler_pic_CXX='-W c,exportall'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ netbsd* | netbsdelf*-gnu)
+ ;;
+ *qnx* | *nto*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ lt_prog_compiler_pic_CXX='-fPIC -shared'
+ ;;
+ osf3* | osf4* | osf5*)
+ case $cc_basename in
+ KCC*)
+ lt_prog_compiler_wl_CXX='--backend -Wl,'
+ ;;
+ RCC*)
+ # Rational C++ 2.4.1
+ lt_prog_compiler_pic_CXX='-pic'
+ ;;
+ cxx*)
+ # Digital/Compaq C++
+ lt_prog_compiler_wl_CXX='-Wl,'
+ # Make sure the PIC flag is empty. It appears that all Alpha
+ # Linux and Compaq Tru64 Unix objects are PIC.
+ lt_prog_compiler_pic_CXX=
+ lt_prog_compiler_static_CXX='-non_shared'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ psos*)
+ ;;
+ solaris*)
+ case $cc_basename in
+ CC* | sunCC*)
+ # Sun C++ 4.2, 5.x and Centerline C++
+ lt_prog_compiler_pic_CXX='-KPIC'
+ lt_prog_compiler_static_CXX='-Bstatic'
+ lt_prog_compiler_wl_CXX='-Qoption ld '
+ ;;
+ gcx*)
+ # Green Hills C++ Compiler
+ lt_prog_compiler_pic_CXX='-PIC'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ sunos4*)
+ case $cc_basename in
+ CC*)
+ # Sun C++ 4.x
+ lt_prog_compiler_pic_CXX='-pic'
+ lt_prog_compiler_static_CXX='-Bstatic'
+ ;;
+ lcc*)
+ # Lucid
+ lt_prog_compiler_pic_CXX='-pic'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+ case $cc_basename in
+ CC*)
+ lt_prog_compiler_wl_CXX='-Wl,'
+ lt_prog_compiler_pic_CXX='-KPIC'
+ lt_prog_compiler_static_CXX='-Bstatic'
+ ;;
+ esac
+ ;;
+ tandem*)
+ case $cc_basename in
+ NCC*)
+ # NonStop-UX NCC 3.20
+ lt_prog_compiler_pic_CXX='-KPIC'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ vxworks*)
+ ;;
+ *)
+ lt_prog_compiler_can_build_shared_CXX=no
+ ;;
+ esac
+ fi
+
+case $host_os in
+ # For platforms which do not support PIC, -DPIC is meaningless:
+ *djgpp*)
+ lt_prog_compiler_pic_CXX=
+ ;;
+ *)
+ lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC"
+ ;;
+esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
+if ${lt_cv_prog_compiler_pic_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_pic_CXX" >&6; }
+lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic_CXX"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5
+$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; }
+if ${lt_cv_prog_compiler_pic_works_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_pic_works_CXX=no
+ ac_outfile=conftest.$ac_objext
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+ lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ # The option is referenced via a variable to avoid confusing sed.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+ (eval "$lt_compile" 2>conftest.err)
+ ac_status=$?
+ cat conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ if (exit $ac_status) && test -s "$ac_outfile"; then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings other than the usual output.
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_pic_works_CXX=yes
+ fi
+ fi
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; }
+
+if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then
+ case $lt_prog_compiler_pic_CXX in
+ "" | " "*) ;;
+ *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;
+ esac
+else
+ lt_prog_compiler_pic_CXX=
+ lt_prog_compiler_can_build_shared_CXX=no
+fi
+
+fi
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if ${lt_cv_prog_compiler_static_works_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_static_works_CXX=no
+ save_LDFLAGS="$LDFLAGS"
+ LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+ echo "$lt_simple_link_test_code" > conftest.$ac_ext
+ if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+ # The linker can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ if test -s conftest.err; then
+ # Append any errors to the config.log.
+ cat conftest.err 1>&5
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if diff conftest.exp conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_static_works_CXX=yes
+ fi
+ else
+ lt_cv_prog_compiler_static_works_CXX=yes
+ fi
+ fi
+ $RM -r conftest*
+ LDFLAGS="$save_LDFLAGS"
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; }
+
+if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then
+ :
+else
+ lt_prog_compiler_static_CXX=
+fi
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_c_o_CXX=no
+ $RM -r conftest 2>/dev/null
+ mkdir conftest
+ cd conftest
+ mkdir out
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ lt_compiler_flag="-o out/conftest2.$ac_objext"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+ (eval "$lt_compile" 2>out/conftest.err)
+ ac_status=$?
+ cat out/conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ if (exit $ac_status) && test -s out/conftest2.$ac_objext
+ then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+ if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_c_o_CXX=yes
+ fi
+ fi
+ chmod u+w . 2>&5
+ $RM conftest*
+ # SGI C++ compiler will create directory out/ii_files/ for
+ # template instantiation
+ test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+ $RM out/* && rmdir out
+ cd ..
+ $RM -r conftest
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; }
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_prog_compiler_c_o_CXX=no
+ $RM -r conftest 2>/dev/null
+ mkdir conftest
+ cd conftest
+ mkdir out
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ lt_compiler_flag="-o out/conftest2.$ac_objext"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+ (eval "$lt_compile" 2>out/conftest.err)
+ ac_status=$?
+ cat out/conftest.err >&5
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ if (exit $ac_status) && test -s out/conftest2.$ac_objext
+ then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+ if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ lt_cv_prog_compiler_c_o_CXX=yes
+ fi
+ fi
+ chmod u+w . 2>&5
+ $RM conftest*
+ # SGI C++ compiler will create directory out/ii_files/ for
+ # template instantiation
+ test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+ $RM out/* && rmdir out
+ cd ..
+ $RM -r conftest
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; }
+
+
+
+
+hard_links="nottested"
+if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then
+ # do not overwrite the value of need_locks provided by the user
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+$as_echo_n "checking if we can lock with hard links... " >&6; }
+ hard_links=yes
+ $RM conftest*
+ ln conftest.a conftest.b 2>/dev/null && hard_links=no
+ touch conftest.a
+ ln conftest.a conftest.b 2>&5 || hard_links=no
+ ln conftest.a conftest.b 2>/dev/null && hard_links=no
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+$as_echo "$hard_links" >&6; }
+ if test "$hard_links" = no; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
+ need_locks=warn
+ fi
+else
+ need_locks=no
+fi
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+ export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+ exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'
+ case $host_os in
+ aix[4-9]*)
+ # If we're using GNU nm, then we don't want the "-C" option.
+ # -C means demangle to AIX nm, but means don't demangle with GNU nm
+ # Also, AIX nm treats weak defined symbols like other global defined
+ # symbols, whereas GNU nm marks them as "W".
+ if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+ export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ else
+ export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ fi
+ ;;
+ pw32*)
+ export_symbols_cmds_CXX="$ltdll_cmds"
+ ;;
+ cygwin* | mingw* | cegcc*)
+ case $cc_basename in
+ cl*)
+ exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+ ;;
+ *)
+ export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols'
+ exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'
+ ;;
+ esac
+ ;;
+ linux* | k*bsd*-gnu | gnu*)
+ link_all_deplibs_CXX=no
+ ;;
+ *)
+ export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+ ;;
+ esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
+$as_echo "$ld_shlibs_CXX" >&6; }
+test "$ld_shlibs_CXX" = no && can_build_shared=no
+
+with_gnu_ld_CXX=$with_gnu_ld
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc_CXX" in
+x|xyes)
+ # Assume -lc should be added
+ archive_cmds_need_lc_CXX=yes
+
+ if test "$enable_shared" = yes && test "$GCC" = yes; then
+ case $archive_cmds_CXX in
+ *'~'*)
+ # FIXME: we may have to deal with multi-command sequences.
+ ;;
+ '$CC '*)
+ # Test whether the compiler implicitly links with -lc since on some
+ # systems, -lgcc has to come before -lc. If gcc already passes -lc
+ # to ld, don't add -lc before -lgcc.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
+if ${lt_cv_archive_cmds_need_lc_CXX+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ $RM conftest*
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; } 2>conftest.err; then
+ soname=conftest
+ lib=conftest
+ libobjs=conftest.$ac_objext
+ deplibs=
+ wl=$lt_prog_compiler_wl_CXX
+ pic_flag=$lt_prog_compiler_pic_CXX
+ compiler_flags=-v
+ linker_flags=-v
+ verstring=
+ output_objdir=.
+ libname=conftest
+ lt_save_allow_undefined_flag=$allow_undefined_flag_CXX
+ allow_undefined_flag_CXX=
+ if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+ (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+ ac_status=$?
+ $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ test $ac_status = 0; }
+ then
+ lt_cv_archive_cmds_need_lc_CXX=no
+ else
+ lt_cv_archive_cmds_need_lc_CXX=yes
+ fi
+ allow_undefined_flag_CXX=$lt_save_allow_undefined_flag
+ else
+ cat conftest.err 1>&5
+ fi
+ $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5
+$as_echo "$lt_cv_archive_cmds_need_lc_CXX" >&6; }
+ archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX
+ ;;
+ esac
+ fi
+ ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+$as_echo_n "checking dynamic linker characteristics... " >&6; }
+
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+ shlibpath_var=LIBPATH
+
+ # AIX 3 has no versioning support, so we append a major version to the name.
+ soname_spec='${libname}${release}${shared_ext}$major'
+ ;;
+
+aix[4-9]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ hardcode_into_libs=yes
+ if test "$host_cpu" = ia64; then
+ # AIX 5 supports IA64
+ library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ else
+ # With GCC up to 2.95.x, collect2 would create an import file
+ # for dependence libraries. The import file would start with
+ # the line `#! .'. This would cause the generated library to
+ # depend on `.', always an invalid library. This was fixed in
+ # development snapshots of GCC prior to 3.0.
+ case $host_os in
+ aix4 | aix4.[01] | aix4.[01].*)
+ if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+ echo ' yes '
+ echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+ :
+ else
+ can_build_shared=no
+ fi
+ ;;
+ esac
+ # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+ # soname into executable. Probably we can add versioning support to
+ # collect2, so additional links can be useful in future.
+ if test "$aix_use_runtimelinking" = yes; then
+ # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+ # instead of lib<name>.a to let people know that these are not
+ # typical AIX shared libraries.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ else
+ # We preserve .a as extension for shared libraries through AIX4.2
+ # and later when we are not doing run time linking.
+ library_names_spec='${libname}${release}.a $libname.a'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ fi
+ shlibpath_var=LIBPATH
+ fi
+ ;;
+
+amigaos*)
+ case $host_cpu in
+ powerpc)
+ # Since July 2007 AmigaOS4 officially supports .so libraries.
+ # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ ;;
+ m68k)
+ library_names_spec='$libname.ixlibrary $libname.a'
+ # Create ${libname}_ixlibrary.a entries in /sys/libs.
+ finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+ ;;
+ esac
+ ;;
+
+beos*)
+ library_names_spec='${libname}${shared_ext}'
+ dynamic_linker="$host_os ld.so"
+ shlibpath_var=LIBRARY_PATH
+ ;;
+
+bsdi[45]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+ sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+ # the default ld.so.conf also contains /usr/contrib/lib and
+ # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+ # libtool to hard-code these into programs
+ ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+ version_type=windows
+ shrext_cmds=".dll"
+ need_version=no
+ need_lib_prefix=no
+
+ case $GCC,$cc_basename in
+ yes,*)
+ # gcc
+ library_names_spec='$libname.dll.a'
+ # DLL is installed to $(libdir)/../bin by postinstall_cmds
+ postinstall_cmds='base_file=`basename \${file}`~
+ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+ dldir=$destdir/`dirname \$dlpath`~
+ test -d \$dldir || mkdir -p \$dldir~
+ $install_prog $dir/$dlname \$dldir/$dlname~
+ chmod a+x \$dldir/$dlname~
+ if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+ eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+ fi'
+ postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+ dlpath=$dir/\$dldll~
+ $RM \$dlpath'
+ shlibpath_overrides_runpath=yes
+
+ case $host_os in
+ cygwin*)
+ # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+ soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+
+ ;;
+ mingw* | cegcc*)
+ # MinGW DLLs use traditional 'lib' prefix
+ soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+ ;;
+ pw32*)
+ # pw32 DLLs use 'pw' prefix rather than 'lib'
+ library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+ ;;
+ esac
+ dynamic_linker='Win32 ld.exe'
+ ;;
+
+ *,cl*)
+ # Native MSVC
+ libname_spec='$name'
+ soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+ library_names_spec='${libname}.dll.lib'
+
+ case $build_os in
+ mingw*)
+ sys_lib_search_path_spec=
+ lt_save_ifs=$IFS
+ IFS=';'
+ for lt_path in $LIB
+ do
+ IFS=$lt_save_ifs
+ # Let DOS variable expansion print the short 8.3 style file name.
+ lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+ sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+ done
+ IFS=$lt_save_ifs
+ # Convert to MSYS style.
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'`
+ ;;
+ cygwin*)
+ # Convert to unix form, then to dos form, then back to unix form
+ # but this time dos style (no spaces!) so that the unix form looks
+ # like /cygdrive/c/PROGRA~1:/cygdr...
+ sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+ sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+ sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+ ;;
+ *)
+ sys_lib_search_path_spec="$LIB"
+ if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
+ # It is most probably a Windows format PATH.
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+ else
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+ fi
+ # FIXME: find the short name or the path components, as spaces are
+ # common. (e.g. "Program Files" -> "PROGRA~1")
+ ;;
+ esac
+
+ # DLL is installed to $(libdir)/../bin by postinstall_cmds
+ postinstall_cmds='base_file=`basename \${file}`~
+ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+ dldir=$destdir/`dirname \$dlpath`~
+ test -d \$dldir || mkdir -p \$dldir~
+ $install_prog $dir/$dlname \$dldir/$dlname'
+ postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+ dlpath=$dir/\$dldll~
+ $RM \$dlpath'
+ shlibpath_overrides_runpath=yes
+ dynamic_linker='Win32 link.exe'
+ ;;
+
+ *)
+ # Assume MSVC wrapper
+ library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
+ dynamic_linker='Win32 ld.exe'
+ ;;
+ esac
+ # FIXME: first we should search . and the directory the executable is in
+ shlibpath_var=PATH
+ ;;
+
+darwin* | rhapsody*)
+ dynamic_linker="$host_os dyld"
+ version_type=darwin
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+ soname_spec='${libname}${release}${major}$shared_ext'
+ shlibpath_overrides_runpath=yes
+ shlibpath_var=DYLD_LIBRARY_PATH
+ shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+ sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+ ;;
+
+dgux*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ ;;
+
+freebsd* | dragonfly*)
+ # DragonFly does not have aout. When/if they implement a new
+ # versioning mechanism, adjust this.
+ if test -x /usr/bin/objformat; then
+ objformat=`/usr/bin/objformat`
+ else
+ case $host_os in
+ freebsd[23].*) objformat=aout ;;
+ *) objformat=elf ;;
+ esac
+ fi
+ version_type=freebsd-$objformat
+ case $version_type in
+ freebsd-elf*)
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+ need_version=no
+ need_lib_prefix=no
+ ;;
+ freebsd-*)
+ library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+ need_version=yes
+ ;;
+ esac
+ shlibpath_var=LD_LIBRARY_PATH
+ case $host_os in
+ freebsd2.*)
+ shlibpath_overrides_runpath=yes
+ ;;
+ freebsd3.[01]* | freebsdelf3.[01]*)
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+ freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
+ freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+ *) # from 4.6 on, and DragonFly
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+ esac
+ ;;
+
+haiku*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ dynamic_linker="$host_os runtime_loader"
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+ hardcode_into_libs=yes
+ ;;
+
+hpux9* | hpux10* | hpux11*)
+ # Give a soname corresponding to the major version so that dld.sl refuses to
+ # link against other versions.
+ version_type=sunos
+ need_lib_prefix=no
+ need_version=no
+ case $host_cpu in
+ ia64*)
+ shrext_cmds='.so'
+ hardcode_into_libs=yes
+ dynamic_linker="$host_os dld.so"
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ if test "X$HPUX_IA64_MODE" = X32; then
+ sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+ else
+ sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+ fi
+ sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+ ;;
+ hppa*64*)
+ shrext_cmds='.sl'
+ hardcode_into_libs=yes
+ dynamic_linker="$host_os dld.sl"
+ shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+ shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+ sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+ ;;
+ *)
+ shrext_cmds='.sl'
+ dynamic_linker="$host_os dld.sl"
+ shlibpath_var=SHLIB_PATH
+ shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ ;;
+ esac
+ # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+ postinstall_cmds='chmod 555 $lib'
+ # or fails outright, so override atomically:
+ install_override_mode=555
+ ;;
+
+interix[3-9]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
+irix5* | irix6* | nonstopux*)
+ case $host_os in
+ nonstopux*) version_type=nonstopux ;;
+ *)
+ if test "$lt_cv_prog_gnu_ld" = yes; then
+ version_type=linux # correct to gnu/linux during the next big refactor
+ else
+ version_type=irix
+ fi ;;
+ esac
+ need_lib_prefix=no
+ need_version=no
+ soname_spec='${libname}${release}${shared_ext}$major'
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+ case $host_os in
+ irix5* | nonstopux*)
+ libsuff= shlibsuff=
+ ;;
+ *)
+ case $LD in # libtool.m4 will add one of these switches to LD
+ *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+ libsuff= shlibsuff= libmagic=32-bit;;
+ *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+ libsuff=32 shlibsuff=N32 libmagic=N32;;
+ *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+ libsuff=64 shlibsuff=64 libmagic=64-bit;;
+ *) libsuff= shlibsuff= libmagic=never-match;;
+ esac
+ ;;
+ esac
+ shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+ shlibpath_overrides_runpath=no
+ sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+ sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+ hardcode_into_libs=yes
+ ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+ dynamic_linker=no
+ ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+
+ # Some binutils ld are patched to set DT_RUNPATH
+ if ${lt_cv_shlibpath_overrides_runpath+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ lt_cv_shlibpath_overrides_runpath=no
+ save_LDFLAGS=$LDFLAGS
+ save_libdir=$libdir
+ eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \
+ LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\""
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+ if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
+ lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+ LDFLAGS=$save_LDFLAGS
+ libdir=$save_libdir
+
+fi
+
+ shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+ # This implies no fast_install, which is unacceptable.
+ # Some rework will be needed to allow for fast_install
+ # before this can be enabled.
+ hardcode_into_libs=yes
+
+ # Append ld.so.conf contents to the search path
+ if test -f /etc/ld.so.conf; then
+ lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+ sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+ fi
+
+ # We used to test for /lib/ld.so.1 and disable shared libraries on
+ # powerpc, because MkLinux only supported shared libraries with the
+ # GNU dynamic linker. Since this was broken with cross compilers,
+ # most powerpc-linux boxes support dynamic linking these days and
+ # people can always --disable-shared, the test was removed, and we
+ # assume the GNU/Linux dynamic linker is in use.
+ dynamic_linker='GNU/Linux ld.so'
+ ;;
+
+netbsdelf*-gnu)
+ version_type=linux
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ dynamic_linker='NetBSD ld.elf_so'
+ ;;
+
+netbsd*)
+ version_type=sunos
+ need_lib_prefix=no
+ need_version=no
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+ dynamic_linker='NetBSD (a.out) ld.so'
+ else
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ dynamic_linker='NetBSD ld.elf_so'
+ fi
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+
+newsos6)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ ;;
+
+*nto* | *qnx*)
+ version_type=qnx
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ dynamic_linker='ldqnx.so'
+ ;;
+
+openbsd*)
+ version_type=sunos
+ sys_lib_dlsearch_path_spec="/usr/lib"
+ need_lib_prefix=no
+ # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+ case $host_os in
+ openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+ *) need_version=no ;;
+ esac
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ case $host_os in
+ openbsd2.[89] | openbsd2.[89].*)
+ shlibpath_overrides_runpath=no
+ ;;
+ *)
+ shlibpath_overrides_runpath=yes
+ ;;
+ esac
+ else
+ shlibpath_overrides_runpath=yes
+ fi
+ ;;
+
+os2*)
+ libname_spec='$name'
+ shrext_cmds=".dll"
+ need_lib_prefix=no
+ library_names_spec='$libname${shared_ext} $libname.a'
+ dynamic_linker='OS/2 ld.exe'
+ shlibpath_var=LIBPATH
+ ;;
+
+osf3* | osf4* | osf5*)
+ version_type=osf
+ need_lib_prefix=no
+ need_version=no
+ soname_spec='${libname}${release}${shared_ext}$major'
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+ sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+ ;;
+
+rdos*)
+ dynamic_linker=no
+ ;;
+
+solaris*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ # ldd complains unless libraries are executable
+ postinstall_cmds='chmod +x $lib'
+ ;;
+
+sunos4*)
+ version_type=sunos
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ if test "$with_gnu_ld" = yes; then
+ need_lib_prefix=no
+ fi
+ need_version=yes
+ ;;
+
+sysv4 | sysv4.3*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ case $host_vendor in
+ sni)
+ shlibpath_overrides_runpath=no
+ need_lib_prefix=no
+ runpath_var=LD_RUN_PATH
+ ;;
+ siemens)
+ need_lib_prefix=no
+ ;;
+ motorola)
+ need_lib_prefix=no
+ need_version=no
+ shlibpath_overrides_runpath=no
+ sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+ ;;
+ esac
+ ;;
+
+sysv4*MP*)
+ if test -d /usr/nec ;then
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+ soname_spec='$libname${shared_ext}.$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ fi
+ ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+ version_type=freebsd-elf
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ if test "$with_gnu_ld" = yes; then
+ sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+ else
+ sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+ case $host_os in
+ sco3.2v5*)
+ sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+ ;;
+ esac
+ fi
+ sys_lib_dlsearch_path_spec='/usr/lib'
+ ;;
+
+tpf*)
+ # TPF is a cross-target only. Preferred cross-host = GNU/Linux.
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
+uts4*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ ;;
+
+*)
+ dynamic_linker=no
+ ;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+$as_echo "$dynamic_linker" >&6; }
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+ variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
+ sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+fi
+if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
+ sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action_CXX=
+if test -n "$hardcode_libdir_flag_spec_CXX" ||
+ test -n "$runpath_var_CXX" ||
+ test "X$hardcode_automatic_CXX" = "Xyes" ; then
+
+ # We can hardcode non-existent directories.
+ if test "$hardcode_direct_CXX" != no &&
+ # If the only mechanism to avoid hardcoding is shlibpath_var, we
+ # have to relink, otherwise we might link with an installed library
+ # when we should be linking with a yet-to-be-installed one
+ ## test "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" != no &&
+ test "$hardcode_minus_L_CXX" != no; then
+ # Linking always hardcodes the temporary library directory.
+ hardcode_action_CXX=relink
+ else
+ # We can link without hardcoding, and we can hardcode nonexisting dirs.
+ hardcode_action_CXX=immediate
+ fi
+else
+ # We cannot hardcode anything, or else we can only hardcode existing
+ # directories.
+ hardcode_action_CXX=unsupported
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5
+$as_echo "$hardcode_action_CXX" >&6; }
+
+if test "$hardcode_action_CXX" = relink ||
+ test "$inherit_rpath_CXX" = yes; then
+ # Fast installation is not supported
+ enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+ test "$enable_shared" = no; then
+ # Fast installation is not necessary
+ enable_fast_install=needless
+fi
+
+
+
+
+
+
+
+ fi # test -n "$compiler"
+
+ CC=$lt_save_CC
+ CFLAGS=$lt_save_CFLAGS
+ LDCXX=$LD
+ LD=$lt_save_LD
+ GCC=$lt_save_GCC
+ with_gnu_ld=$lt_save_with_gnu_ld
+ lt_cv_path_LDCXX=$lt_cv_path_LD
+ lt_cv_path_LD=$lt_save_path_LD
+ lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+ lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+fi # test "$_lt_caught_CXX_error" != yes
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ac_config_commands="$ac_config_commands libtool"
+
+
+
+
+# Only expand once:
+
+
+
+ac_config_headers="$ac_config_headers config.h src/include/fst/config.h"
+
+
+ac_config_files="$ac_config_files Makefile src/Makefile src/include/Makefile src/lib/Makefile src/bin/Makefile src/test/Makefile src/extensions/Makefile src/extensions/compact/Makefile src/extensions/compress/Makefile src/extensions/const/Makefile src/extensions/far/Makefile src/extensions/linear/Makefile src/extensions/lookahead/Makefile src/extensions/mpdt/Makefile src/extensions/ngram/Makefile src/extensions/pdt/Makefile src/extensions/python/Makefile src/extensions/special/Makefile src/script/Makefile"
+
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+
+# Check whether --enable-compact-fsts was given.
+if test "${enable_compact_fsts+set}" = set; then :
+ enableval=$enable_compact_fsts;
+else
+ enable_compact_fsts=no
+fi
+
+ if test "x$enable_compact_fsts" != xno; then
+ HAVE_COMPACT_TRUE=
+ HAVE_COMPACT_FALSE='#'
+else
+ HAVE_COMPACT_TRUE='#'
+ HAVE_COMPACT_FALSE=
+fi
+
+
+# Check whether --enable-compress was given.
+if test "${enable_compress+set}" = set; then :
+ enableval=$enable_compress;
+else
+ enable_compress=no
+fi
+
+ if test "x$enable_compress" != xno; then
+ HAVE_COMPRESS_TRUE=
+ HAVE_COMPRESS_FALSE='#'
+else
+ HAVE_COMPRESS_TRUE='#'
+ HAVE_COMPRESS_FALSE=
+fi
+
+
+# Check whether --enable-const-fsts was given.
+if test "${enable_const_fsts+set}" = set; then :
+ enableval=$enable_const_fsts;
+else
+ enable_const_fsts=no
+fi
+
+ if test "x$enable_const_fsts" != xno; then
+ HAVE_CONST_TRUE=
+ HAVE_CONST_FALSE='#'
+else
+ HAVE_CONST_TRUE='#'
+ HAVE_CONST_FALSE=
+fi
+
+
+# Check whether --enable-far was given.
+if test "${enable_far+set}" = set; then :
+ enableval=$enable_far;
+else
+ enable_far=no
+fi
+
+ if test "x$enable_far" != xno; then
+ HAVE_FAR_TRUE=
+ HAVE_FAR_FALSE='#'
+else
+ HAVE_FAR_TRUE='#'
+ HAVE_FAR_FALSE=
+fi
+
+
+# Check whether --enable-linear-fsts was given.
+if test "${enable_linear_fsts+set}" = set; then :
+ enableval=$enable_linear_fsts;
+else
+ enable_linear_fsts=no
+fi
+
+ if test "x$enable_linear_fsts" != xno; then
+ HAVE_LINEAR_TRUE=
+ HAVE_LINEAR_FALSE='#'
+else
+ HAVE_LINEAR_TRUE='#'
+ HAVE_LINEAR_FALSE=
+fi
+
+
+# Check whether --enable-lookahead-fsts was given.
+if test "${enable_lookahead_fsts+set}" = set; then :
+ enableval=$enable_lookahead_fsts;
+else
+ enable_lookahead_fsts=no
+fi
+
+ if test "x$enable_lookahead_fsts" != xno; then
+ HAVE_LOOKAHEAD_TRUE=
+ HAVE_LOOKAHEAD_FALSE='#'
+else
+ HAVE_LOOKAHEAD_TRUE='#'
+ HAVE_LOOKAHEAD_FALSE=
+fi
+
+
+# Check whether --enable-mpdt was given.
+if test "${enable_mpdt+set}" = set; then :
+ enableval=$enable_mpdt;
+else
+ enable_mpdt=no
+fi
+
+ if test "x$enable_mpdt" != xno; then
+ HAVE_MPDT_TRUE=
+ HAVE_MPDT_FALSE='#'
+else
+ HAVE_MPDT_TRUE='#'
+ HAVE_MPDT_FALSE=
+fi
+
+
+# Check whether --enable-ngram-fsts was given.
+if test "${enable_ngram_fsts+set}" = set; then :
+ enableval=$enable_ngram_fsts;
+else
+ enable_ngram_fsts=no
+fi
+
+ if test "x$enable_ngram_fsts" != xno; then
+ HAVE_NGRAM_TRUE=
+ HAVE_NGRAM_FALSE='#'
+else
+ HAVE_NGRAM_TRUE='#'
+ HAVE_NGRAM_FALSE=
+fi
+
+
+# Check whether --enable-pdt was given.
+if test "${enable_pdt+set}" = set; then :
+ enableval=$enable_pdt;
+else
+ enable_pdt=no
+fi
+
+ if test "x$enable_pdt" != xno; then
+ HAVE_PDT_TRUE=
+ HAVE_PDT_FALSE='#'
+else
+ HAVE_PDT_TRUE='#'
+ HAVE_PDT_FALSE=
+fi
+
+
+# Check whether --enable-python was given.
+if test "${enable_python+set}" = set; then :
+ enableval=$enable_python;
+else
+ enable_python=no
+fi
+
+ if test "x$enable_python" != xno; then
+ HAVE_PYTHON_TRUE=
+ HAVE_PYTHON_FALSE='#'
+else
+ HAVE_PYTHON_TRUE='#'
+ HAVE_PYTHON_FALSE=
+fi
+
+if test "x$enable_python" != xno; then
+
+
+
+
+
+
+ if test -n "$PYTHON"; then
+ # If the user set $PYTHON, use it and don't search something else.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 2.7" >&5
+$as_echo_n "checking whether $PYTHON version is >= 2.7... " >&6; }
+ prog="import sys
+# split strings by '.' and convert to numeric. Append some zeros
+# because we need at least 4 digits for the hex conversion.
+# map returns an iterator in Python 3.0 and a list in 2.x
+minver = list(map(int, '2.7'.split('.'))) + [0, 0, 0]
+minverhex = 0
+# xrange is not present in Python 3.0 and range returns an iterator
+for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[i]
+sys.exit(sys.hexversion < minverhex)"
+ if { echo "$as_me:$LINENO: $PYTHON -c "$prog"" >&5
+ ($PYTHON -c "$prog") >&5 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; then :
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ as_fn_error $? "Python interpreter is too old" "$LINENO" 5
+fi
+ am_display_PYTHON=$PYTHON
+ else
+ # Otherwise, try each interpreter until we find one that satisfies
+ # VERSION.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 2.7" >&5
+$as_echo_n "checking for a Python interpreter with version >= 2.7... " >&6; }
+if ${am_cv_pathless_PYTHON+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+
+ for am_cv_pathless_PYTHON in python python2 python3 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 none; do
+ test "$am_cv_pathless_PYTHON" = none && break
+ prog="import sys
+# split strings by '.' and convert to numeric. Append some zeros
+# because we need at least 4 digits for the hex conversion.
+# map returns an iterator in Python 3.0 and a list in 2.x
+minver = list(map(int, '2.7'.split('.'))) + [0, 0, 0]
+minverhex = 0
+# xrange is not present in Python 3.0 and range returns an iterator
+for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[i]
+sys.exit(sys.hexversion < minverhex)"
+ if { echo "$as_me:$LINENO: $am_cv_pathless_PYTHON -c "$prog"" >&5
+ ($am_cv_pathless_PYTHON -c "$prog") >&5 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; then :
+ break
+fi
+ done
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5
+$as_echo "$am_cv_pathless_PYTHON" >&6; }
+ # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON.
+ if test "$am_cv_pathless_PYTHON" = none; then
+ PYTHON=:
+ else
+ # Extract the first word of "$am_cv_pathless_PYTHON", so it can be a program name with args.
+set dummy $am_cv_pathless_PYTHON; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_PYTHON+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ case $PYTHON in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+ ;;
+esac
+fi
+PYTHON=$ac_cv_path_PYTHON
+if test -n "$PYTHON"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5
+$as_echo "$PYTHON" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ fi
+ am_display_PYTHON=$am_cv_pathless_PYTHON
+ fi
+
+
+ if test "$PYTHON" = :; then
+ as_fn_error $? "no suitable Python interpreter found" "$LINENO" 5
+ else
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5
+$as_echo_n "checking for $am_display_PYTHON version... " >&6; }
+if ${am_cv_python_version+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[:3])"`
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5
+$as_echo "$am_cv_python_version" >&6; }
+ PYTHON_VERSION=$am_cv_python_version
+
+
+
+ PYTHON_PREFIX='${prefix}'
+
+ PYTHON_EXEC_PREFIX='${exec_prefix}'
+
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5
+$as_echo_n "checking for $am_display_PYTHON platform... " >&6; }
+if ${am_cv_python_platform+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5
+$as_echo "$am_cv_python_platform" >&6; }
+ PYTHON_PLATFORM=$am_cv_python_platform
+
+
+ # Just factor out some code duplication.
+ am_python_setup_sysconfig="\
+import sys
+# Prefer sysconfig over distutils.sysconfig, for better compatibility
+# with python 3.x. See automake bug#10227.
+try:
+ import sysconfig
+except ImportError:
+ can_use_sysconfig = 0
+else:
+ can_use_sysconfig = 1
+# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs:
+# <https://github.com/pypa/virtualenv/issues/118>
+try:
+ from platform import python_implementation
+ if python_implementation() == 'CPython' and sys.version[:3] == '2.7':
+ can_use_sysconfig = 0
+except ImportError:
+ pass"
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory" >&5
+$as_echo_n "checking for $am_display_PYTHON script directory... " >&6; }
+if ${am_cv_python_pythondir+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test "x$prefix" = xNONE
+ then
+ am_py_prefix=$ac_default_prefix
+ else
+ am_py_prefix=$prefix
+ fi
+ am_cv_python_pythondir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+ sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'})
+else:
+ from distutils import sysconfig
+ sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+ case $am_cv_python_pythondir in
+ $am_py_prefix*)
+ am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'`
+ am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"`
+ ;;
+ *)
+ case $am_py_prefix in
+ /usr|/System*) ;;
+ *)
+ am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages
+ ;;
+ esac
+ ;;
+ esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5
+$as_echo "$am_cv_python_pythondir" >&6; }
+ pythondir=$am_cv_python_pythondir
+
+
+
+ pkgpythondir=\${pythondir}/$PACKAGE
+
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory" >&5
+$as_echo_n "checking for $am_display_PYTHON extension module directory... " >&6; }
+if ${am_cv_python_pyexecdir+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test "x$exec_prefix" = xNONE
+ then
+ am_py_exec_prefix=$am_py_prefix
+ else
+ am_py_exec_prefix=$exec_prefix
+ fi
+ am_cv_python_pyexecdir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+ sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'})
+else:
+ from distutils import sysconfig
+ sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+ case $am_cv_python_pyexecdir in
+ $am_py_exec_prefix*)
+ am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'`
+ am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"`
+ ;;
+ *)
+ case $am_py_exec_prefix in
+ /usr|/System*) ;;
+ *)
+ am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages
+ ;;
+ esac
+ ;;
+ esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5
+$as_echo "$am_cv_python_pyexecdir" >&6; }
+ pyexecdir=$am_cv_python_pyexecdir
+
+
+
+ pkgpyexecdir=\${pyexecdir}/$PACKAGE
+
+
+
+ fi
+
+
+
+ #
+ # Allow the use of a (user set) custom python version
+ #
+
+
+ # Extract the first word of "python[$PYTHON_VERSION]", so it can be a program name with args.
+set dummy python$PYTHON_VERSION; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_PYTHON+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ case $PYTHON in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+ ;;
+esac
+fi
+PYTHON=$ac_cv_path_PYTHON
+if test -n "$PYTHON"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5
+$as_echo "$PYTHON" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ if test -z "$PYTHON"; then
+ as_fn_error $? "Cannot find python$PYTHON_VERSION in your system path" "$LINENO" 5
+ PYTHON_VERSION=""
+ fi
+
+ #
+ # Check for a version of Python >= 2.1.0
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a version of Python >= '2.1.0'" >&5
+$as_echo_n "checking for a version of Python >= '2.1.0'... " >&6; }
+ ac_supports_python_ver=`$PYTHON -c "import sys, string; \
+ ver = string.split(sys.version)[0]; \
+ print ver >= '2.1.0'"`
+ if test "$ac_supports_python_ver" != "True"; then
+ if test -z "$PYTHON_NOVERSIONCHECK"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "
+This version of the AC_PYTHON_DEVEL macro
+doesn't work properly with versions of Python before
+2.1.0. You may need to re-run configure, setting the
+variables PYTHON_CPPFLAGS, PYTHON_LDFLAGS, PYTHON_SITE_PKG,
+PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand.
+Moreover, to disable this check, set PYTHON_NOVERSIONCHECK
+to something else than an empty string.
+
+See \`config.log' for more details" "$LINENO" 5; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: skip at user request" >&5
+$as_echo "skip at user request" >&6; }
+ fi
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+ fi
+
+ #
+ # if the macro parameter ``version'' is set, honour it
+ #
+ if test -n ">= '2.7'"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a version of Python >= '2.7'" >&5
+$as_echo_n "checking for a version of Python >= '2.7'... " >&6; }
+ ac_supports_python_ver=`$PYTHON -c "import sys, string; \
+ ver = string.split(sys.version)[0]; \
+ print ver >= '2.7'"`
+ if test "$ac_supports_python_ver" = "True"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ as_fn_error $? "this package requires Python >= '2.7'.
+If you have it installed, but it isn't the default Python
+interpreter in your system path, please pass the PYTHON_VERSION
+variable to configure. See \`\`configure --help'' for reference.
+" "$LINENO" 5
+ PYTHON_VERSION=""
+ fi
+ fi
+
+ #
+ # Check if you have distutils, else fail
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the distutils Python package" >&5
+$as_echo_n "checking for the distutils Python package... " >&6; }
+ ac_distutils_result=`$PYTHON -c "import distutils" 2>&1`
+ if test -z "$ac_distutils_result"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ as_fn_error $? "cannot import Python module \"distutils\".
+Please check your Python installation. The error was:
+$ac_distutils_result" "$LINENO" 5
+ PYTHON_VERSION=""
+ fi
+
+ #
+ # Check for Python include path
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python include path" >&5
+$as_echo_n "checking for Python include path... " >&6; }
+ if test -z "$PYTHON_CPPFLAGS"; then
+ python_path=`$PYTHON -c "import distutils.sysconfig; \
+ print distutils.sysconfig.get_python_inc();"`
+ if test -n "${python_path}"; then
+ python_path="-I$python_path"
+ fi
+ PYTHON_CPPFLAGS=$python_path
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_CPPFLAGS" >&5
+$as_echo "$PYTHON_CPPFLAGS" >&6; }
+
+
+ #
+ # Check for Python library path
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python library path" >&5
+$as_echo_n "checking for Python library path... " >&6; }
+ if test -z "$PYTHON_LDFLAGS"; then
+ # (makes two attempts to ensure we've got a version number
+ # from the interpreter)
+ py_version=`$PYTHON -c "from distutils.sysconfig import *; \
+ from string import join; \
+ print join(get_config_vars('VERSION'))"`
+ if test "$py_version" == "None"; then
+ if test -n "$PYTHON_VERSION"; then
+ py_version=$PYTHON_VERSION
+ else
+ py_version=`$PYTHON -c "import sys; \
+ print sys.version[:3]"`
+ fi
+ fi
+
+ PYTHON_LDFLAGS=`$PYTHON -c "from distutils.sysconfig import *; \
+ from string import join; \
+ print '-L' + get_python_lib(0,1), \
+ '-lpython';"`$py_version
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_LDFLAGS" >&5
+$as_echo "$PYTHON_LDFLAGS" >&6; }
+
+
+ #
+ # Check for site packages
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Python site-packages path" >&5
+$as_echo_n "checking for Python site-packages path... " >&6; }
+ if test -z "$PYTHON_SITE_PKG"; then
+ PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \
+ print distutils.sysconfig.get_python_lib(0,0);"`
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_SITE_PKG" >&5
+$as_echo "$PYTHON_SITE_PKG" >&6; }
+
+
+ #
+ # libraries which must be linked in when embedding
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking python extra libraries" >&5
+$as_echo_n "checking python extra libraries... " >&6; }
+ if test -z "$PYTHON_EXTRA_LIBS"; then
+ PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \
+ conf = distutils.sysconfig.get_config_var; \
+ print conf('LOCALMODLIBS'), conf('LIBS')"`
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_EXTRA_LIBS" >&5
+$as_echo "$PYTHON_EXTRA_LIBS" >&6; }
+
+
+ #
+ # linking flags needed when embedding
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking python extra linking flags" >&5
+$as_echo_n "checking python extra linking flags... " >&6; }
+ if test -z "$PYTHON_EXTRA_LDFLAGS"; then
+ PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \
+ conf = distutils.sysconfig.get_config_var; \
+ print conf('LINKFORSHARED')"`
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON_EXTRA_LDFLAGS" >&5
+$as_echo "$PYTHON_EXTRA_LDFLAGS" >&6; }
+
+
+ #
+ # final check to see if everything compiles alright
+ #
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking consistency of all components of python development environment" >&5
+$as_echo_n "checking consistency of all components of python development environment... " >&6; }
+ ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ # save current global flags
+ LIBS="$ac_save_LIBS $PYTHON_LDFLAGS"
+ CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ #include <Python.h>
+
+int
+main ()
+{
+
+ Py_Initialize();
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ pythonexists=yes
+else
+ pythonexists=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $pythonexists" >&5
+$as_echo "$pythonexists" >&6; }
+
+ if test ! "$pythonexists" = "yes"; then
+ as_fn_error $? "
+ Could not link test program to Python. Maybe the main Python library has been
+ installed in some non-standard library path. If so, pass it to configure,
+ via the LDFLAGS environment variable.
+ Example: ./configure LDFLAGS=\"-L/usr/non-standard-path/python/lib\"
+ ============================================================================
+ ERROR!
+ You probably have to install the development version of the Python package
+ for your distribution. The exact name of this package varies among them.
+ ============================================================================
+ " "$LINENO" 5
+ PYTHON_VERSION=""
+ fi
+ ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+ # turn back to default flags
+ CPPFLAGS="$ac_save_CPPFLAGS"
+ LIBS="$ac_save_LIBS"
+
+ #
+ # all done!
+ #
+
+fi
+
+# Check whether --enable-special was given.
+if test "${enable_special+set}" = set; then :
+ enableval=$enable_special;
+else
+ enable_special=no
+fi
+
+ if test "x$enable_special" != xno; then
+ HAVE_SPECIAL_TRUE=
+ HAVE_SPECIAL_FALSE='#'
+else
+ HAVE_SPECIAL_TRUE='#'
+ HAVE_SPECIAL_FALSE=
+fi
+
+
+# --enable-bin enables script and bin "extensions".
+# Check whether --enable-bin was given.
+if test "${enable_bin+set}" = set; then :
+ enableval=$enable_bin;
+else
+ enable_bin=yes
+fi
+
+ if test "x$enable_bin" != xno; then
+ HAVE_BIN_TRUE=
+ HAVE_BIN_FALSE='#'
+else
+ HAVE_BIN_TRUE='#'
+ HAVE_BIN_FALSE=
+fi
+
+ if test "x$enable_bin" != xno; then
+ HAVE_SCRIPT_TRUE=
+ HAVE_SCRIPT_FALSE='#'
+else
+ HAVE_SCRIPT_TRUE='#'
+ HAVE_SCRIPT_FALSE=
+fi
+
+
+# --enable-grm enables dependencies of OpenGrm: far, mpdt, and pdt.
+# Check whether --enable-grm was given.
+if test "${enable_grm+set}" = set; then :
+ enableval=$enable_grm;
+else
+ enable_grm=no
+fi
+
+ if test "x$enable_grm" != xno; then
+ HAVE_GRM_TRUE=
+ HAVE_GRM_FALSE='#'
+else
+ HAVE_GRM_TRUE='#'
+ HAVE_GRM_FALSE=
+fi
+
+
+
+# Check whether --with-libfstdir was given.
+if test "${with_libfstdir+set}" = set; then :
+ withval=$with_libfstdir;
+else
+ with_libfstdir=${libdir}/fst
+fi
+
+
+libfstdir=$with_libfstdir
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+ ac_cv_lib_dl_dlopen=yes
+else
+ ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+ DL_LIBS=-ldl
+fi
+
+
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems. If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+ for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+ eval ac_val=\$$ac_var
+ case $ac_val in #(
+ *${as_nl}*)
+ case $ac_var in #(
+ *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+ esac
+ case $ac_var in #(
+ _ | IFS | as_nl) ;; #(
+ BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+ *) { eval $ac_var=; unset $ac_var;} ;;
+ esac ;;
+ esac
+ done
+
+ (set) 2>&1 |
+ case $as_nl`(ac_space=' '; set) 2>&1` in #(
+ *${as_nl}ac_space=\ *)
+ # `set' does not quote correctly, so add quotes: double-quote
+ # substitution turns \\\\ into \\, and sed turns \\ into \.
+ sed -n \
+ "s/'/'\\\\''/g;
+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+ ;; #(
+ *)
+ # `set' quotes correctly as required by POSIX, so do not add quotes.
+ sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+ ;;
+ esac |
+ sort
+) |
+ sed '
+ /^ac_cv_env_/b end
+ t clear
+ :clear
+ s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+ t end
+ s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+ :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+ if test -w "$cache_file"; then
+ if test "x$cache_file" != "x/dev/null"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+ if test ! -f "$cache_file" || test -h "$cache_file"; then
+ cat confcache >"$cache_file"
+ else
+ case $cache_file in #(
+ */* | ?:*)
+ mv -f confcache "$cache_file"$$ &&
+ mv -f "$cache_file"$$ "$cache_file" ;; #(
+ *)
+ mv -f confcache "$cache_file" ;;
+ esac
+ fi
+ fi
+ else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+ fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+ # 1. Remove the extension, and $U if already installed.
+ ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+ ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+ # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR
+ # will be set to the directory where LIBOBJS objects are built.
+ as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+ as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+$as_echo_n "checking that generated files are newer than configure... " >&6; }
+ if test -n "$am_sleep_pid"; then
+ # Hide warnings about reused PIDs.
+ wait $am_sleep_pid 2>/dev/null
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
+$as_echo "done" >&6; }
+ if test -n "$EXEEXT"; then
+ am__EXEEXT_TRUE=
+ am__EXEEXT_FALSE='#'
+else
+ am__EXEEXT_TRUE='#'
+ am__EXEEXT_FALSE=
+fi
+
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+ as_fn_error $? "conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+ as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
+ as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_COMPACT_TRUE}" && test -z "${HAVE_COMPACT_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_COMPACT\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_COMPRESS_TRUE}" && test -z "${HAVE_COMPRESS_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_COMPRESS\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_CONST_TRUE}" && test -z "${HAVE_CONST_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_CONST\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_FAR_TRUE}" && test -z "${HAVE_FAR_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_FAR\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_LINEAR_TRUE}" && test -z "${HAVE_LINEAR_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_LINEAR\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_LOOKAHEAD_TRUE}" && test -z "${HAVE_LOOKAHEAD_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_LOOKAHEAD\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_MPDT_TRUE}" && test -z "${HAVE_MPDT_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_MPDT\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_NGRAM_TRUE}" && test -z "${HAVE_NGRAM_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_NGRAM\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_PDT_TRUE}" && test -z "${HAVE_PDT_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_PDT\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_PYTHON_TRUE}" && test -z "${HAVE_PYTHON_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_PYTHON\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_SPECIAL_TRUE}" && test -z "${HAVE_SPECIAL_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_SPECIAL\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_BIN_TRUE}" && test -z "${HAVE_BIN_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_BIN\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_SCRIPT_TRUE}" && test -z "${HAVE_SCRIPT_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_SCRIPT\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_GRM_TRUE}" && test -z "${HAVE_GRM_FALSE}"; then
+ as_fn_error $? "conditional \"HAVE_GRM\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+ emulate sh
+ NULLCMD=:
+ # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+ # is contrary to our usage. Disable this feature.
+ alias -g '${1+"$@"}'='"$@"'
+ setopt NO_GLOB_SUBST
+else
+ case `(set -o) 2>/dev/null` in #(
+ *posix*) :
+ set -o posix ;; #(
+ *) :
+ ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+ as_echo='print -r --'
+ as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+ as_echo='printf %s\n'
+ as_echo_n='printf %s'
+else
+ if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+ as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+ as_echo_n='/usr/ucb/echo -n'
+ else
+ as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+ as_echo_n_body='eval
+ arg=$1;
+ case $arg in #(
+ *"$as_nl"*)
+ expr "X$arg" : "X\\(.*\\)$as_nl";
+ arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+ esac;
+ expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+ '
+ export as_echo_n_body
+ as_echo_n='sh -c $as_echo_n_body as_echo'
+ fi
+ export as_echo_body
+ as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+ PATH_SEPARATOR=:
+ (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+ (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+ PATH_SEPARATOR=';'
+ }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order. Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" "" $as_nl"
+
+# Find who we are. Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+ *[\\/]* ) as_myself=$0 ;;
+ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+ done
+IFS=$as_save_IFS
+
+ ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+ as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+ $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+ exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there. '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR [LINENO LOG_FD]
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+ as_status=$1; test $as_status -eq 0 && as_status=1
+ if test "$4"; then
+ as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+ $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+ fi
+ $as_echo "$as_me: error: $2" >&2
+ as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+ return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+ set +e
+ as_fn_set_status $1
+ exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+ { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+ eval 'as_fn_append ()
+ {
+ eval $1+=\$2
+ }'
+else
+ as_fn_append ()
+ {
+ eval $1=\$$1\$2
+ }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+ eval 'as_fn_arith ()
+ {
+ as_val=$(( $* ))
+ }'
+else
+ as_fn_arith ()
+ {
+ as_val=`expr "$@" || test $? -eq 1`
+ }
+fi # as_fn_arith
+
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+ test "X`expr 00001 : '.*\(...\)'`" = X001; then
+ as_expr=expr
+else
+ as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+ as_basename=basename
+else
+ as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+ as_dirname=dirname
+else
+ as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+ X"$0" : 'X\(//\)$' \| \
+ X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+ sed '/^.*\/\([^/][^/]*\)\/*$/{
+ s//\1/
+ q
+ }
+ /^X\/\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\/\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+ case `echo 'xy\c'` in
+ *c*) ECHO_T=' ';; # ECHO_T is single tab character.
+ xy) ECHO_C='\c';;
+ *) echo `echo ksh88 bug on AIX 6.1` > /dev/null
+ ECHO_T=' ';;
+ esac;;
+*)
+ ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+ rm -f conf$$.dir/conf$$.file
+else
+ rm -f conf$$.dir
+ mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+ if ln -s conf$$.file conf$$ 2>/dev/null; then
+ as_ln_s='ln -s'
+ # ... but there are two gotchas:
+ # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+ # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+ # In both cases, we have to default to `cp -pR'.
+ ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+ as_ln_s='cp -pR'
+ elif ln conf$$.file conf$$ 2>/dev/null; then
+ as_ln_s=ln
+ else
+ as_ln_s='cp -pR'
+ fi
+else
+ as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+ case $as_dir in #(
+ -*) as_dir=./$as_dir;;
+ esac
+ test -d "$as_dir" || eval $as_mkdir_p || {
+ as_dirs=
+ while :; do
+ case $as_dir in #(
+ *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+ *) as_qdir=$as_dir;;
+ esac
+ as_dirs="'$as_qdir' $as_dirs"
+ as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$as_dir" : 'X\(//\)[^/]' \| \
+ X"$as_dir" : 'X\(//\)$' \| \
+ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+ test -d "$as_dir" && break
+ done
+ test -z "$as_dirs" || eval "mkdir $as_dirs"
+ } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+ as_mkdir_p='mkdir -p "$as_dir"'
+else
+ test -d ./-p && rmdir ./-p
+ as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+ test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by OpenFst $as_me 1.6.0, 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 <help@www.openfst.org>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
+ac_cs_version="\\
+OpenFst config.status 1.6.0
+configured by $0, generated by GNU Autoconf 2.69,
+ with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+MKDIR_P='$MKDIR_P'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+ case $1 in
+ --*=?*)
+ ac_option=`expr "X$1" : 'X\([^=]*\)='`
+ ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+ ac_shift=:
+ ;;
+ --*=)
+ ac_option=`expr "X$1" : 'X\([^=]*\)='`
+ ac_optarg=
+ ac_shift=:
+ ;;
+ *)
+ ac_option=$1
+ ac_optarg=$2
+ ac_shift=shift
+ ;;
+ esac
+
+ case $ac_option in
+ # Handling of the options.
+ -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+ ac_cs_recheck=: ;;
+ --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+ $as_echo "$ac_cs_version"; exit ;;
+ --config | --confi | --conf | --con | --co | --c )
+ $as_echo "$ac_cs_config"; exit ;;
+ --debug | --debu | --deb | --de | --d | -d )
+ debug=: ;;
+ --file | --fil | --fi | --f )
+ $ac_shift
+ case $ac_optarg in
+ *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ '') as_fn_error $? "missing file argument" ;;
+ esac
+ as_fn_append CONFIG_FILES " '$ac_optarg'"
+ ac_need_defaults=false;;
+ --header | --heade | --head | --hea )
+ $ac_shift
+ case $ac_optarg in
+ *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ esac
+ as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+ ac_need_defaults=false;;
+ --he | --h)
+ # Conflict between --help and --header
+ as_fn_error $? "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+ --help | --hel | -h )
+ $as_echo "$ac_cs_usage"; exit ;;
+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+ | -silent | --silent | --silen | --sile | --sil | --si | --s)
+ ac_cs_silent=: ;;
+
+ # This is an error.
+ -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+ *) as_fn_append ac_config_targets " $1"
+ ac_need_defaults=false ;;
+
+ esac
+ shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+ exec 6>/dev/null
+ ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+ set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+ shift
+ \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+ CONFIG_SHELL='$SHELL'
+ export CONFIG_SHELL
+ exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+ echo
+ sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+ $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+#
+# INIT-COMMANDS
+#
+AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
+macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
+macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
+enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
+pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
+enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
+SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
+ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
+PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
+host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`'
+host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`'
+host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`'
+build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`'
+build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`'
+build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`'
+SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`'
+Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`'
+GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`'
+EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`'
+FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`'
+LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`'
+NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`'
+LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`'
+max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`'
+ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`'
+exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`'
+lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`'
+lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`'
+lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
+reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
+reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
+OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
+deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
+file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
+file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`'
+want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`'
+DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`'
+sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`'
+AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
+AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
+archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`'
+STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
+RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`'
+old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`'
+lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`'
+CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`'
+CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`'
+compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
+GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
+nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
+lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
+objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
+MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`'
+need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`'
+MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`'
+DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`'
+NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`'
+LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`'
+OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`'
+OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`'
+libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`'
+shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`'
+extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`'
+hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`'
+inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`'
+always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`'
+include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`'
+prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`'
+postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`'
+file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`'
+variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`'
+need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`'
+need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`'
+version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`'
+runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`'
+libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`'
+library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`'
+soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`'
+install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`'
+postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
+finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
+hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
+sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
+sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
+hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
+enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`'
+old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`'
+striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`'
+predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`'
+postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`'
+predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`'
+postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`'
+LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`'
+reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`'
+reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`'
+GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`'
+inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`'
+always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`'
+predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`'
+postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`'
+
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+ eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+
+# Quote evaled strings.
+for var in SHELL \
+ECHO \
+PATH_SEPARATOR \
+SED \
+GREP \
+EGREP \
+FGREP \
+LD \
+NM \
+LN_S \
+lt_SP2NL \
+lt_NL2SP \
+reload_flag \
+OBJDUMP \
+deplibs_check_method \
+file_magic_cmd \
+file_magic_glob \
+want_nocaseglob \
+DLLTOOL \
+sharedlib_from_linklib_cmd \
+AR \
+AR_FLAGS \
+archiver_list_spec \
+STRIP \
+RANLIB \
+CC \
+CFLAGS \
+compiler \
+lt_cv_sys_global_symbol_pipe \
+lt_cv_sys_global_symbol_to_cdecl \
+lt_cv_sys_global_symbol_to_c_name_address \
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
+nm_file_list_spec \
+lt_prog_compiler_no_builtin_flag \
+lt_prog_compiler_pic \
+lt_prog_compiler_wl \
+lt_prog_compiler_static \
+lt_cv_prog_compiler_c_o \
+need_locks \
+MANIFEST_TOOL \
+DSYMUTIL \
+NMEDIT \
+LIPO \
+OTOOL \
+OTOOL64 \
+shrext_cmds \
+export_dynamic_flag_spec \
+whole_archive_flag_spec \
+compiler_needs_object \
+with_gnu_ld \
+allow_undefined_flag \
+no_undefined_flag \
+hardcode_libdir_flag_spec \
+hardcode_libdir_separator \
+exclude_expsyms \
+include_expsyms \
+file_list_spec \
+variables_saved_for_relink \
+libname_spec \
+library_names_spec \
+soname_spec \
+install_override_mode \
+finish_eval \
+old_striplib \
+striplib \
+compiler_lib_search_dirs \
+predep_objects \
+postdep_objects \
+predeps \
+postdeps \
+compiler_lib_search_path \
+LD_CXX \
+reload_flag_CXX \
+compiler_CXX \
+lt_prog_compiler_no_builtin_flag_CXX \
+lt_prog_compiler_pic_CXX \
+lt_prog_compiler_wl_CXX \
+lt_prog_compiler_static_CXX \
+lt_cv_prog_compiler_c_o_CXX \
+export_dynamic_flag_spec_CXX \
+whole_archive_flag_spec_CXX \
+compiler_needs_object_CXX \
+with_gnu_ld_CXX \
+allow_undefined_flag_CXX \
+no_undefined_flag_CXX \
+hardcode_libdir_flag_spec_CXX \
+hardcode_libdir_separator_CXX \
+exclude_expsyms_CXX \
+include_expsyms_CXX \
+file_list_spec_CXX \
+compiler_lib_search_dirs_CXX \
+predep_objects_CXX \
+postdep_objects_CXX \
+predeps_CXX \
+postdeps_CXX \
+compiler_lib_search_path_CXX; do
+ case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+ *[\\\\\\\`\\"\\\$]*)
+ eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
+ ;;
+ *)
+ eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+ ;;
+ esac
+done
+
+# Double-quote double-evaled strings.
+for var in reload_cmds \
+old_postinstall_cmds \
+old_postuninstall_cmds \
+old_archive_cmds \
+extract_expsyms_cmds \
+old_archive_from_new_cmds \
+old_archive_from_expsyms_cmds \
+archive_cmds \
+archive_expsym_cmds \
+module_cmds \
+module_expsym_cmds \
+export_symbols_cmds \
+prelink_cmds \
+postlink_cmds \
+postinstall_cmds \
+postuninstall_cmds \
+finish_cmds \
+sys_lib_search_path_spec \
+sys_lib_dlsearch_path_spec \
+reload_cmds_CXX \
+old_archive_cmds_CXX \
+old_archive_from_new_cmds_CXX \
+old_archive_from_expsyms_cmds_CXX \
+archive_cmds_CXX \
+archive_expsym_cmds_CXX \
+module_cmds_CXX \
+module_expsym_cmds_CXX \
+export_symbols_cmds_CXX \
+prelink_cmds_CXX \
+postlink_cmds_CXX; do
+ case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+ *[\\\\\\\`\\"\\\$]*)
+ eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
+ ;;
+ *)
+ eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+ ;;
+ esac
+done
+
+ac_aux_dir='$ac_aux_dir'
+xsi_shell='$xsi_shell'
+lt_shell_append='$lt_shell_append'
+
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}" ; then
+ setopt NO_GLOB_SUBST
+fi
+
+
+ PACKAGE='$PACKAGE'
+ VERSION='$VERSION'
+ TIMESTAMP='$TIMESTAMP'
+ RM='$RM'
+ ofile='$ofile'
+
+
+
+
+
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+ case $ac_config_target in
+ "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+ "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
+ "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
+ "src/include/fst/config.h") CONFIG_HEADERS="$CONFIG_HEADERS src/include/fst/config.h" ;;
+ "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+ "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;;
+ "src/include/Makefile") CONFIG_FILES="$CONFIG_FILES src/include/Makefile" ;;
+ "src/lib/Makefile") CONFIG_FILES="$CONFIG_FILES src/lib/Makefile" ;;
+ "src/bin/Makefile") CONFIG_FILES="$CONFIG_FILES src/bin/Makefile" ;;
+ "src/test/Makefile") CONFIG_FILES="$CONFIG_FILES src/test/Makefile" ;;
+ "src/extensions/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/Makefile" ;;
+ "src/extensions/compact/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/compact/Makefile" ;;
+ "src/extensions/compress/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/compress/Makefile" ;;
+ "src/extensions/const/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/const/Makefile" ;;
+ "src/extensions/far/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/far/Makefile" ;;
+ "src/extensions/linear/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/linear/Makefile" ;;
+ "src/extensions/lookahead/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/lookahead/Makefile" ;;
+ "src/extensions/mpdt/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/mpdt/Makefile" ;;
+ "src/extensions/ngram/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/ngram/Makefile" ;;
+ "src/extensions/pdt/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/pdt/Makefile" ;;
+ "src/extensions/python/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/python/Makefile" ;;
+ "src/extensions/special/Makefile") CONFIG_FILES="$CONFIG_FILES src/extensions/special/Makefile" ;;
+ "src/script/Makefile") CONFIG_FILES="$CONFIG_FILES src/script/Makefile" ;;
+
+ *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+ esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used. Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+ test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+ test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+ test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
+fi
+
+# Have a temporary directory for convenience. Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+ tmp= ac_tmp=
+ trap 'exit_status=$?
+ : "${ac_tmp:=$tmp}"
+ { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+ trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+ tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+ test -d "$tmp"
+} ||
+{
+ tmp=./conf$$-$RANDOM
+ (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+ eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/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
+' <conf$$subs.awk | sed '
+/^[^""]/{
+ N
+ s/\n//
+}
+' >>$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 = "\a"
+
+}
+{
+ 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
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ for (key in D) D_is_set[key] = 1
+ FS = "\a"
+}
+/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
+ line = \$ 0
+ split(line, arg, " ")
+ if (arg[1] == "#") {
+ defundef = arg[2]
+ mac1 = arg[3]
+ } else {
+ defundef = substr(arg[1], 2)
+ mac1 = arg[2]
+ }
+ split(mac1, mac2, "(") #)
+ macro = mac2[1]
+ prefix = substr(line, 1, index(line, defundef) - 1)
+ if (D_is_set[macro]) {
+ # Preserve the white space surrounding the "#".
+ print prefix "define", macro P[macro] D[macro]
+ next
+ } else {
+ # Replace #undef with comments. This is necessary, for example,
+ # in the case of _POSIX_SOURCE, which is predefined and required
+ # on some systems where configure will not decide to define it.
+ if (defundef == "undef") {
+ print "/*", prefix defundef, macro, "*/"
+ next
+ }
+ }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS"
+shift
+for ac_tag
+do
+ case $ac_tag in
+ :[FHLC]) ac_mode=$ac_tag; continue;;
+ esac
+ case $ac_mode$ac_tag in
+ :[FHL]*:*);;
+ :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+ :[FH]-) ac_tag=-:-;;
+ :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+ esac
+ ac_save_IFS=$IFS
+ IFS=:
+ set x $ac_tag
+ IFS=$ac_save_IFS
+ shift
+ ac_file=$1
+ shift
+
+ case $ac_mode in
+ :L) ac_source=$1;;
+ :[FH])
+ ac_file_inputs=
+ for ac_f
+ do
+ case $ac_f in
+ -) ac_f="$ac_tmp/stdin";;
+ *) # Look for the file first in the build tree, then in the source tree
+ # (if the path is not absolute). The absolute path cannot be DOS-style,
+ # because $ac_f cannot contain `:'.
+ test -f "$ac_f" ||
+ case $ac_f in
+ [\\/$]*) false;;
+ *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+ esac ||
+ as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+ esac
+ case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+ as_fn_append ac_file_inputs " '$ac_f'"
+ done
+
+ # Let's still pretend it is `configure' which instantiates (i.e., don't
+ # use $as_me), people would be surprised to read:
+ # /* config.h. Generated by config.status. */
+ configure_input='Generated from '`
+ $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+ `' by configure.'
+ if test x"$ac_file" != x-; then
+ configure_input="$ac_file. $configure_input"
+ { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+ fi
+ # Neutralize special characters interpreted by sed in replacement strings.
+ case $configure_input in #(
+ *\&* | *\|* | *\\* )
+ ac_sed_conf_input=`$as_echo "$configure_input" |
+ sed 's/[\\\\&|]/\\\\&/g'`;; #(
+ *) ac_sed_conf_input=$configure_input;;
+ esac
+
+ case $ac_tag in
+ *:-:* | *:-) cat >"$ac_tmp/stdin" \
+ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+ esac
+ ;;
+ esac
+
+ ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$ac_file" : 'X\(//\)[^/]' \| \
+ X"$ac_file" : 'X\(//\)$' \| \
+ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+ as_dir="$ac_dir"; as_fn_mkdir_p
+ ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+ ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
+ # A ".." for each directory in $ac_dir_suffix.
+ ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+ case $ac_top_builddir_sub in
+ "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+ *) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+ esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+ .) # We are building in place.
+ ac_srcdir=.
+ ac_top_srcdir=$ac_top_builddir_sub
+ ac_abs_top_srcdir=$ac_pwd ;;
+ [\\/]* | ?:[\\/]* ) # Absolute name.
+ ac_srcdir=$srcdir$ac_dir_suffix;
+ ac_top_srcdir=$srcdir
+ ac_abs_top_srcdir=$srcdir ;;
+ *) # Relative name.
+ ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+ ac_top_srcdir=$ac_top_build_prefix$srcdir
+ ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+ case $ac_mode in
+ :F)
+ #
+ # CONFIG_FILE
+ #
+
+ case $INSTALL in
+ [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+ *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+ esac
+ ac_MKDIR_P=$MKDIR_P
+ case $MKDIR_P in
+ [\\/$]* | ?:[\\/]* ) ;;
+ */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
+ esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+ p
+ q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ ac_datarootdir_hack='
+ s&@datadir@&$datadir&g
+ s&@docdir@&$docdir&g
+ s&@infodir@&$infodir&g
+ s&@localedir@&$localedir&g
+ s&@mandir@&$mandir&g
+ s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+s&@MKDIR_P@&$ac_MKDIR_P&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+ { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+ { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \
+ "$ac_tmp/out"`; test -z "$ac_out"; } &&
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined. Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined. Please make sure it is defined" >&2;}
+
+ rm -f "$ac_tmp/stdin"
+ case $ac_file in
+ -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+ *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+ esac \
+ || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+ :H)
+ #
+ # CONFIG_HEADER
+ #
+ if test x"$ac_file" != x-; then
+ {
+ $as_echo "/* $configure_input */" \
+ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+ } >"$ac_tmp/config.h" \
+ || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+$as_echo "$as_me: $ac_file is unchanged" >&6;}
+ else
+ rm -f "$ac_file"
+ mv "$ac_tmp/config.h" "$ac_file" \
+ || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ fi
+ else
+ $as_echo "/* $configure_input */" \
+ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+ || as_fn_error $? "could not create -" "$LINENO" 5
+ fi
+# Compute "$ac_file"'s index in $config_headers.
+_am_arg="$ac_file"
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+ case $_am_header in
+ $_am_arg | $_am_arg:* )
+ break ;;
+ * )
+ _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+ esac
+done
+echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
+$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$_am_arg" : 'X\(//\)[^/]' \| \
+ X"$_am_arg" : 'X\(//\)$' \| \
+ X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$_am_arg" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`/stamp-h$_am_stamp_count
+ ;;
+
+ :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+$as_echo "$as_me: executing $ac_file commands" >&6;}
+ ;;
+ esac
+
+
+ case $ac_file$ac_mode in
+ "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
+ # Older Autoconf quotes --file arguments for eval, but not when files
+ # are listed without --file. Let's play safe and only enable the eval
+ # if we detect the quoting.
+ case $CONFIG_FILES in
+ *\'*) eval set x "$CONFIG_FILES" ;;
+ *) set x $CONFIG_FILES ;;
+ esac
+ shift
+ for mf
+ do
+ # Strip MF so we end up with the name of the file.
+ mf=`echo "$mf" | sed -e 's/:.*$//'`
+ # Check whether this is an Automake generated Makefile or not.
+ # We used to match only the files named 'Makefile.in', but
+ # some people rename them; so instead we look at the file content.
+ # Grep'ing the first line is not enough: some people post-process
+ # each Makefile.in and add a new line on top of each file to say so.
+ # Grep'ing the whole file is not good either: AIX grep has a line
+ # limit of 2048, but all sed's we know have understand at least 4000.
+ if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
+ dirpart=`$as_dirname -- "$mf" ||
+$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$mf" : 'X\(//\)[^/]' \| \
+ X"$mf" : 'X\(//\)$' \| \
+ X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$mf" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+ else
+ continue
+ fi
+ # Extract the definition of DEPDIR, am__include, and am__quote
+ # from the Makefile without running 'make'.
+ DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+ test -z "$DEPDIR" && continue
+ am__include=`sed -n 's/^am__include = //p' < "$mf"`
+ test -z "$am__include" && continue
+ am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+ # Find all dependency output files, they are included files with
+ # $(DEPDIR) in their names. We invoke sed twice because it is the
+ # simplest approach to changing $(DEPDIR) to its actual value in the
+ # expansion.
+ for file in `sed -n "
+ s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
+ # Make sure the directory exists.
+ test -f "$dirpart/$file" && continue
+ fdir=`$as_dirname -- "$file" ||
+$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$file" : 'X\(//\)[^/]' \| \
+ X"$file" : 'X\(//\)$' \| \
+ X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$file" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+ as_dir=$dirpart/$fdir; as_fn_mkdir_p
+ # echo "creating $dirpart/$file"
+ echo '# dummy' > "$dirpart/$file"
+ done
+ done
+}
+ ;;
+ "libtool":C)
+
+ # See if we are running on zsh, and set the options which allow our
+ # commands through without removal of \ escapes.
+ if test -n "${ZSH_VERSION+set}" ; then
+ setopt NO_GLOB_SUBST
+ fi
+
+ cfgfile="${ofile}T"
+ trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+ $RM "$cfgfile"
+
+ cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+
+# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+# 2006, 2007, 2008, 2009, 2010, 2011 Free Software
+# Foundation, Inc.
+# Written by Gordon Matzigkeit, 1996
+#
+# This file is part of GNU Libtool.
+#
+# GNU Libtool is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of
+# the License, or (at your option) any later version.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Libtool; see the file COPYING. If not, a copy
+# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
+# obtained by writing to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+
+# The names of the tagged configurations supported by this script.
+available_tags="CXX "
+
+# ### BEGIN LIBTOOL CONFIG
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# Which release of libtool.m4 was used?
+macro_version=$macro_version
+macro_revision=$macro_revision
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# What type of objects to build.
+pic_mode=$pic_mode
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# An echo program that protects backslashes.
+ECHO=$lt_ECHO
+
+# The PATH separator for the build system.
+PATH_SEPARATOR=$lt_PATH_SEPARATOR
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# A sed program that does not truncate output.
+SED=$lt_SED
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="\$SED -e 1s/^X//"
+
+# A grep program that handles long lines.
+GREP=$lt_GREP
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# A literal string matcher.
+FGREP=$lt_FGREP
+
+# A BSD- or MS-compatible name lister.
+NM=$lt_NM
+
+# Whether we need soft or hard links.
+LN_S=$lt_LN_S
+
+# What is the maximum length of a command?
+max_cmd_len=$max_cmd_len
+
+# Object file suffix (normally "o").
+objext=$ac_objext
+
+# Executable file suffix (normally "").
+exeext=$exeext
+
+# whether the shell understands "unset".
+lt_unset=$lt_unset
+
+# turn spaces into newlines.
+SP2NL=$lt_lt_SP2NL
+
+# turn newlines into spaces.
+NL2SP=$lt_lt_NL2SP
+
+# convert \$build file names to \$host format.
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+
+# convert \$build files to toolchain format.
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+
+# An object symbol dumper.
+OBJDUMP=$lt_OBJDUMP
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method = "file_magic".
+file_magic_cmd=$lt_file_magic_cmd
+
+# How to find potential files when deplibs_check_method = "file_magic".
+file_magic_glob=$lt_file_magic_glob
+
+# Find potential files using nocaseglob when deplibs_check_method = "file_magic".
+want_nocaseglob=$lt_want_nocaseglob
+
+# DLL creation program.
+DLLTOOL=$lt_DLLTOOL
+
+# Command to associate shared and link libraries.
+sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd
+
+# The archiver.
+AR=$lt_AR
+
+# Flags to create an archive.
+AR_FLAGS=$lt_AR_FLAGS
+
+# How to feed a file listing to the archiver.
+archiver_list_spec=$lt_archiver_list_spec
+
+# A symbol stripping program.
+STRIP=$lt_STRIP
+
+# Commands used to install an old-style archive.
+RANLIB=$lt_RANLIB
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Whether to use a lock for old archive extraction.
+lock_old_archive_extraction=$lock_old_archive_extraction
+
+# A C compiler.
+LTCC=$lt_CC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_CFLAGS
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration.
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm in a C name address pair.
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# Transform the output of nm in a C name address pair when lib prefix is needed.
+global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix
+
+# Specify filename containing input files for \$NM.
+nm_file_list_spec=$lt_nm_file_list_spec
+
+# The root where to search for dependent libraries,and in which our libraries should be installed.
+lt_sysroot=$lt_sysroot
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# Used to examine libraries when file_magic_cmd begins with "file".
+MAGIC_CMD=$MAGIC_CMD
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Manifest tool.
+MANIFEST_TOOL=$lt_MANIFEST_TOOL
+
+# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
+DSYMUTIL=$lt_DSYMUTIL
+
+# Tool to change global to local symbols on Mac OS X.
+NMEDIT=$lt_NMEDIT
+
+# Tool to manipulate fat objects and archives on Mac OS X.
+LIPO=$lt_LIPO
+
+# ldd/readelf like tool for Mach-O binaries on Mac OS X.
+OTOOL=$lt_OTOOL
+
+# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
+OTOOL64=$lt_OTOOL64
+
+# Old archive suffix (normally "a").
+libext=$libext
+
+# Shared library suffix (normally ".so").
+shrext_cmds=$lt_shrext_cmds
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at link time.
+variables_saved_for_relink=$lt_variables_saved_for_relink
+
+# Do we need the "lib" prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Library versioning type.
+version_type=$version_type
+
+# Shared library runtime path variable.
+runpath_var=$runpath_var
+
+# Shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names. First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Permission mode override for installation of shared libraries.
+install_override_mode=$lt_install_override_mode
+
+# Command to use after installation of a shared archive.
+postinstall_cmds=$lt_postinstall_cmds
+
+# Command to use after uninstallation of a shared archive.
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# As "finish_cmds", except a single script fragment to be evaled but
+# not shown.
+finish_eval=$lt_finish_eval
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Compile-time system search path for libraries.
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Run-time system search path for libraries.
+sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+
+# The linker used to build libraries.
+LD=$lt_LD
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds
+
+# A language specific compiler.
+CC=$lt_compiler
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds
+archive_expsym_cmds=$lt_archive_expsym_cmds
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds
+module_expsym_cmds=$lt_module_expsym_cmds
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator
+
+# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct
+
+# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action
+
+# The directories searched by this compiler when creating a shared library.
+compiler_lib_search_dirs=$lt_compiler_lib_search_dirs
+
+# Dependencies to place before and after the objects being linked to
+# create a shared library.
+predep_objects=$lt_predep_objects
+postdep_objects=$lt_postdep_objects
+predeps=$lt_predeps
+postdeps=$lt_postdeps
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path
+
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+ case $host_os in
+ aix3*)
+ cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program. For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+ COLLECT_NAMES=
+ export COLLECT_NAMES
+fi
+_LT_EOF
+ ;;
+ esac
+
+
+ltmain="$ac_aux_dir/ltmain.sh"
+
+
+ # We use sed instead of cat because bash on DJGPP gets confused if
+ # if finds mixed CR/LF and LF-only lines. Since sed operates in
+ # text mode, it properly converts lines to CR/LF. This bash problem
+ # is reportedly fixed, but why not run on old versions too?
+ sed '$q' "$ltmain" >> "$cfgfile" \
+ || (rm -f "$cfgfile"; exit 1)
+
+ if test x"$xsi_shell" = xyes; then
+ sed -e '/^func_dirname ()$/,/^} # func_dirname /c\
+func_dirname ()\
+{\
+\ case ${1} in\
+\ */*) func_dirname_result="${1%/*}${2}" ;;\
+\ * ) func_dirname_result="${3}" ;;\
+\ esac\
+} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_basename ()$/,/^} # func_basename /c\
+func_basename ()\
+{\
+\ func_basename_result="${1##*/}"\
+} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\
+func_dirname_and_basename ()\
+{\
+\ case ${1} in\
+\ */*) func_dirname_result="${1%/*}${2}" ;;\
+\ * ) func_dirname_result="${3}" ;;\
+\ esac\
+\ func_basename_result="${1##*/}"\
+} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_stripname ()$/,/^} # func_stripname /c\
+func_stripname ()\
+{\
+\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\
+\ # positional parameters, so assign one to ordinary parameter first.\
+\ func_stripname_result=${3}\
+\ func_stripname_result=${func_stripname_result#"${1}"}\
+\ func_stripname_result=${func_stripname_result%"${2}"}\
+} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\
+func_split_long_opt ()\
+{\
+\ func_split_long_opt_name=${1%%=*}\
+\ func_split_long_opt_arg=${1#*=}\
+} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\
+func_split_short_opt ()\
+{\
+\ func_split_short_opt_arg=${1#??}\
+\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\
+} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\
+func_lo2o ()\
+{\
+\ case ${1} in\
+\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\
+\ *) func_lo2o_result=${1} ;;\
+\ esac\
+} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_xform ()$/,/^} # func_xform /c\
+func_xform ()\
+{\
+ func_xform_result=${1%.*}.lo\
+} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_arith ()$/,/^} # func_arith /c\
+func_arith ()\
+{\
+ func_arith_result=$(( $* ))\
+} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_len ()$/,/^} # func_len /c\
+func_len ()\
+{\
+ func_len_result=${#1}\
+} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+fi
+
+if test x"$lt_shell_append" = xyes; then
+ sed -e '/^func_append ()$/,/^} # func_append /c\
+func_append ()\
+{\
+ eval "${1}+=\\${2}"\
+} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\
+func_append_quoted ()\
+{\
+\ func_quote_for_eval "${2}"\
+\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\
+} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+
+
+ # Save a `func_append' function call where possible by direct use of '+='
+ sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+ test 0 -eq $? || _lt_function_replace_fail=:
+else
+ # Save a `func_append' function call even when '+=' is not available
+ sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+ test 0 -eq $? || _lt_function_replace_fail=:
+fi
+
+if test x"$_lt_function_replace_fail" = x":"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5
+$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;}
+fi
+
+
+ mv -f "$cfgfile" "$ofile" ||
+ (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+ chmod +x "$ofile"
+
+
+ cat <<_LT_EOF >> "$ofile"
+
+# ### BEGIN LIBTOOL TAG CONFIG: CXX
+
+# The linker used to build libraries.
+LD=$lt_LD_CXX
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag_CXX
+reload_cmds=$lt_reload_cmds_CXX
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds_CXX
+
+# A language specific compiler.
+CC=$lt_compiler_CXX
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC_CXX
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_CXX
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_CXX
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_CXX
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_CXX
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object_CXX
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds_CXX
+archive_expsym_cmds=$lt_archive_expsym_cmds_CXX
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds_CXX
+module_expsym_cmds=$lt_module_expsym_cmds_CXX
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld_CXX
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_CXX
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_CXX
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX
+
+# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct_CXX
+
+# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute_CXX
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L_CXX
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic_CXX
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath_CXX
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_CXX
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols_CXX
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_CXX
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_CXX
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_CXX
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds_CXX
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds_CXX
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec_CXX
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_CXX
+
+# The directories searched by this compiler when creating a shared library.
+compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX
+
+# Dependencies to place before and after the objects being linked to
+# create a shared library.
+predep_objects=$lt_predep_objects_CXX
+postdep_objects=$lt_postdep_objects_CXX
+predeps=$lt_predeps_CXX
+postdeps=$lt_postdeps_CXX
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_CXX
+
+# ### END LIBTOOL TAG CONFIG: CXX
+_LT_EOF
+
+ ;;
+
+ esac
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+ as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded. So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status. When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+ ac_cs_success=:
+ ac_config_status_args=
+ test "$silent" = yes &&
+ ac_config_status_args="$ac_config_status_args --quiet"
+ exec 5>/dev/null
+ $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+ exec 5>>config.log
+ # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+ # would make configure fail if this is the last instruction.
+ $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+
--- /dev/null
+AC_INIT([OpenFst], [1.6.0], [help@www.openfst.org])
+AM_INIT_AUTOMAKE([foreign nostdinc -Wall -Werror subdir-objects])
+AM_PROG_AR
+
+CPPFLAGS="$CPPFLAGS -funsigned-char"
+CXXFLAGS="$CXXFLAGS -std=c++11"
+
+AC_PROG_CXX
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
+
+AC_CONFIG_HEADERS([config.h src/include/fst/config.h])
+AC_CONFIG_SRCDIR([src/lib/fst.cc])
+AC_CONFIG_FILES([
+ Makefile
+ src/Makefile
+ src/include/Makefile
+ src/lib/Makefile
+ src/bin/Makefile
+ src/test/Makefile
+ src/extensions/Makefile
+ src/extensions/compact/Makefile
+ src/extensions/compress/Makefile
+ src/extensions/const/Makefile
+ src/extensions/far/Makefile
+ src/extensions/linear/Makefile
+ src/extensions/lookahead/Makefile
+ src/extensions/mpdt/Makefile
+ src/extensions/ngram/Makefile
+ src/extensions/pdt/Makefile
+ src/extensions/python/Makefile
+ src/extensions/special/Makefile
+ src/script/Makefile
+])
+AC_CONFIG_MACRO_DIR([m4])
+AC_LANG([C++])
+
+AC_ARG_ENABLE([compact-fsts],
+ [AS_HELP_STRING([--enable-compact-fsts],
+ [enable CompactFst extensions])],
+ [],
+ [enable_compact_fsts=no])
+AM_CONDITIONAL([HAVE_COMPACT], [test "x$enable_compact_fsts" != xno])
+
+AC_ARG_ENABLE([compress],
+ [AS_HELP_STRING([--enable-compress],
+ [enable compression extension])],
+ [],
+ [enable_compress=no])
+AM_CONDITIONAL([HAVE_COMPRESS], [test "x$enable_compress" != xno])
+
+AC_ARG_ENABLE([const-fsts],
+ [AS_HELP_STRING([--enable-const-fsts],
+ [enable ConstFst extensions])],
+ [],
+ [enable_const_fsts=no])
+AM_CONDITIONAL([HAVE_CONST], [test "x$enable_const_fsts" != xno])
+
+AC_ARG_ENABLE([far],
+ [AS_HELP_STRING([--enable-far], [enable FAR extensions])],
+ [],
+ [enable_far=no])
+AM_CONDITIONAL([HAVE_FAR], [test "x$enable_far" != xno])
+
+AC_ARG_ENABLE([linear-fsts],
+ [AS_HELP_STRING([--enable-linear-fsts],
+ [enable LinearTagger/ClassifierFst extensions])],
+ [],
+ [enable_linear_fsts=no])
+AM_CONDITIONAL([HAVE_LINEAR], [test "x$enable_linear_fsts" != xno])
+
+AC_ARG_ENABLE([lookahead-fsts],
+ [AS_HELP_STRING([--enable-lookahead-fsts],
+ [enable LookAheadFst extensions])],
+ [],
+ [enable_lookahead_fsts=no])
+AM_CONDITIONAL([HAVE_LOOKAHEAD], [test "x$enable_lookahead_fsts" != xno])
+
+AC_ARG_ENABLE([mpdt],
+ [AS_HELP_STRING([--enable-mpdt],
+ [enable MPDT extensions])],
+ [],
+ [enable_mpdt=no])
+AM_CONDITIONAL([HAVE_MPDT], [test "x$enable_mpdt" != xno])
+
+AC_ARG_ENABLE([ngram-fsts],
+ [AS_HELP_STRING([--enable-ngram-fsts],
+ [enable NGramFst extension])],
+ [],
+ [enable_ngram_fsts=no])
+AM_CONDITIONAL([HAVE_NGRAM], [test "x$enable_ngram_fsts" != xno])
+
+AC_ARG_ENABLE([pdt],
+ [AS_HELP_STRING([--enable-pdt],
+ [enable PDT extensions])],
+ [],
+ [enable_pdt=no])
+AM_CONDITIONAL([HAVE_PDT], [test "x$enable_pdt" != xno])
+
+AC_ARG_ENABLE([python],
+ [AS_HELP_STRING([--enable-python],
+ [enable Python extensions])],
+ [],
+ [enable_python=no])
+AM_CONDITIONAL([HAVE_PYTHON], [test "x$enable_python" != xno])
+if test "x$enable_python" != xno; then
+ AM_PATH_PYTHON(2.7)
+ AC_PYTHON_DEVEL([>= '2.7'])
+fi
+
+AC_ARG_ENABLE([special],
+ [AS_HELP_STRING([--enable-special],
+ [enable special-matcher extensions])],
+ [],
+ [enable_special=no])
+AM_CONDITIONAL([HAVE_SPECIAL], [test "x$enable_special" != xno])
+
+# --enable-bin enables script and bin "extensions".
+AC_ARG_ENABLE([bin],
+ [AS_HELP_STRING([--enable-bin],
+ [enable fst::script and command-line binaries])],
+ [],
+ [enable_bin=yes])
+AM_CONDITIONAL([HAVE_BIN], [test "x$enable_bin" != xno])
+AM_CONDITIONAL([HAVE_SCRIPT], [test "x$enable_bin" != xno])
+
+# --enable-grm enables dependencies of OpenGrm: far, mpdt, and pdt.
+AC_ARG_ENABLE([grm],
+ [AS_HELP_STRING([--enable-grm],
+ [enable all dependencies of OpenGrm])],
+ [],
+ [enable_grm=no])
+AM_CONDITIONAL([HAVE_GRM], [test "x$enable_grm" != xno])
+
+AC_ARG_WITH([libfstdir],
+[--with-libfstdir[=DIR] fst dynamic extensions [[LIBDIR/fst]]],
+[], [with_libfstdir=[${libdir}/fst]])
+
+AC_SUBST([libfstdir], $with_libfstdir)
+
+AC_CHECK_LIB([dl], dlopen, [DL_LIBS=-ldl])
+AC_SUBST([DL_LIBS])
+
+AC_OUTPUT
--- /dev/null
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2013-05-30.07; # UTC
+
+# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# 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 <oliva@dcc.unicamp.br>.
+
+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 <bug-automake@gnu.org>.
+EOF
+ exit $?
+ ;;
+ -v | --v*)
+ echo "depcomp $scriptversion"
+ exit $?
+ ;;
+esac
+
+# Get the directory component of the given path, and save it in the
+# global variables '$dir'. Note that this directory component will
+# be either empty or ending with a '/' character. This is deliberate.
+set_dir_from ()
+{
+ case $1 in
+ */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
+ *) dir=;;
+ esac
+}
+
+# Get the suffix-stripped basename of the given path, and save it the
+# global variable '$base'.
+set_base_from ()
+{
+ base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
+}
+
+# If no dependency file was actually created by the compiler invocation,
+# we still have to create a dummy depfile, to avoid errors with the
+# Makefile "include basename.Plo" scheme.
+make_dummy_depfile ()
+{
+ echo "#dummy" > "$depfile"
+}
+
+# Factor out some common post-processing of the generated depfile.
+# Requires the auxiliary global variable '$tmpdepfile' to be set.
+aix_post_process_depfile ()
+{
+ # If the compiler actually managed to produce a dependency file,
+ # post-process it.
+ if test -f "$tmpdepfile"; then
+ # Each line is of the form 'foo.o: dependency.h'.
+ # Do two passes, one to just change these to
+ # $object: dependency.h
+ # and one to simply output
+ # dependency.h:
+ # which is needed to avoid the deleted-header problem.
+ { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
+ sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
+ } > "$depfile"
+ rm -f "$tmpdepfile"
+ else
+ make_dummy_depfile
+ fi
+}
+
+# A tabulation character.
+tab=' '
+# A newline character.
+nl='
+'
+# Character ranges might be problematic outside the C locale.
+# These definitions help.
+upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
+lower=abcdefghijklmnopqrstuvwxyz
+digits=0123456789
+alpha=${upper}${lower}
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+ echo "depcomp: Variables source, object and depmode must be set" 1>&2
+ exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+ sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Avoid interferences from the environment.
+gccflag= dashmflag=
+
+# Some modes work just like other modes, but use different flags. We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write. Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+ # HP compiler uses -M and no extra arg.
+ gccflag=-M
+ depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+ # This is just like dashmstdout with a different argument.
+ dashmflag=-xM
+ depmode=dashmstdout
+fi
+
+cygpath_u="cygpath -u -f -"
+if test "$depmode" = msvcmsys; then
+ # This is just like msvisualcpp but w/o cygpath translation.
+ # Just convert the backslash-escaped backslashes to single forward
+ # slashes to satisfy depend.m4
+ cygpath_u='sed s,\\\\,/,g'
+ depmode=msvisualcpp
+fi
+
+if test "$depmode" = msvc7msys; then
+ # This is just like msvc7 but w/o cygpath translation.
+ # Just convert the backslash-escaped backslashes to single forward
+ # slashes to satisfy depend.m4
+ cygpath_u='sed s,\\\\,/,g'
+ depmode=msvc7
+fi
+
+if test "$depmode" = xlc; then
+ # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
+ gccflag=-qmakedep=gcc,-MF
+ depmode=gcc
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want. Yay! Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff. Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am. Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+ for arg
+ do
+ case $arg in
+ -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+ *) set fnord "$@" "$arg" ;;
+ esac
+ shift # fnord
+ shift # $arg
+ done
+ "$@"
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ mv "$tmpdepfile" "$depfile"
+ ;;
+
+gcc)
+## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
+## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
+## (see the conditional assignment to $gccflag above).
+## There are various ways to get dependency output from gcc. Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+## up in a subdir. Having to rename by hand is ugly.
+## (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+## -MM, not -M (despite what the docs say). Also, it might not be
+## supported by the other compilers which use the 'gcc' depmode.
+## - Using -M directly means running the compiler twice (even worse
+## than renaming).
+ if test -z "$gccflag"; then
+ gccflag=-MD,
+ fi
+ "$@" -Wp,"$gccflag$tmpdepfile"
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+ echo "$object : \\" > "$depfile"
+ # The second -e expression handles DOS-style file names with drive
+ # letters.
+ sed -e 's/^[^:]*: / /' \
+ -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the "deleted header file" problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header). We avoid this by adding
+## dummy dependencies for each header file. Too bad gcc doesn't do
+## this for us directly.
+## Some versions of gcc put a space before the ':'. On the theory
+## that the space means something, we add a space to the output as
+## well. hp depmode also adds that space, but also prefixes the VPATH
+## to the object. Take care to not repeat it in the output.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly. Breaking it into two sed invocations is a workaround.
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+ | sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+hp)
+ # This case exists only to let depend.m4 do its work. It works by
+ # looking at the text of this script. This case will never be run,
+ # since it is checked for above.
+ exit 1
+ ;;
+
+sgi)
+ if test "$libtool" = yes; then
+ "$@" "-Wp,-MDupdate,$tmpdepfile"
+ else
+ "$@" -MDupdate "$tmpdepfile"
+ fi
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+
+ if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
+ echo "$object : \\" > "$depfile"
+ # Clip off the initial element (the dependent). Don't try to be
+ # clever and replace this with sed code, as IRIX sed won't handle
+ # lines with more than a fixed number of characters (4096 in
+ # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
+ # the IRIX cc adds comments like '#:fec' to the end of the
+ # dependency line.
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
+ | tr "$nl" ' ' >> "$depfile"
+ echo >> "$depfile"
+ # The second pass generates a dummy entry for each header file.
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+ >> "$depfile"
+ else
+ make_dummy_depfile
+ fi
+ rm -f "$tmpdepfile"
+ ;;
+
+xlc)
+ # This case exists only to let depend.m4 do its work. It works by
+ # looking at the text of this script. This case will never be run,
+ # since it is checked for above.
+ exit 1
+ ;;
+
+aix)
+ # The C for AIX Compiler uses -M and outputs the dependencies
+ # in a .u file. In older versions, this file always lives in the
+ # current directory. Also, the AIX compiler puts '$object:' at the
+ # start of each line; $object doesn't have directory information.
+ # Version 6 uses the directory in both cases.
+ set_dir_from "$object"
+ set_base_from "$object"
+ if test "$libtool" = yes; then
+ tmpdepfile1=$dir$base.u
+ tmpdepfile2=$base.u
+ tmpdepfile3=$dir.libs/$base.u
+ "$@" -Wc,-M
+ else
+ tmpdepfile1=$dir$base.u
+ tmpdepfile2=$dir$base.u
+ tmpdepfile3=$dir$base.u
+ "$@" -M
+ fi
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ exit $stat
+ fi
+
+ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ do
+ test -f "$tmpdepfile" && break
+ done
+ aix_post_process_depfile
+ ;;
+
+tcc)
+ # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
+ # FIXME: That version still under development at the moment of writing.
+ # Make that this statement remains true also for stable, released
+ # versions.
+ # It will wrap lines (doesn't matter whether long or short) with a
+ # trailing '\', as in:
+ #
+ # foo.o : \
+ # foo.c \
+ # foo.h \
+ #
+ # It will put a trailing '\' even on the last line, and will use leading
+ # spaces rather than leading tabs (at least since its commit 0394caf7
+ # "Emit spaces for -MD").
+ "$@" -MD -MF "$tmpdepfile"
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+ # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
+ # We have to change lines of the first kind to '$object: \'.
+ sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
+ # And for each line of the second kind, we have to emit a 'dep.h:'
+ # dummy dependency, to avoid the deleted-header problem.
+ sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+## The order of this option in the case statement is important, since the
+## shell code in configure will try each of these formats in the order
+## listed in this file. A plain '-MD' option would be understood by many
+## compilers, so we must ensure this comes after the gcc and icc options.
+pgcc)
+ # Portland's C compiler understands '-MD'.
+ # Will always output deps to 'file.d' where file is the root name of the
+ # source file under compilation, even if file resides in a subdirectory.
+ # The object file name does not affect the name of the '.d' file.
+ # pgcc 10.2 will output
+ # foo.o: sub/foo.c sub/foo.h
+ # and will wrap long lines using '\' :
+ # foo.o: sub/foo.c ... \
+ # sub/foo.h ... \
+ # ...
+ set_dir_from "$object"
+ # Use the source, not the object, to determine the base name, since
+ # that's sadly what pgcc will do too.
+ set_base_from "$source"
+ tmpdepfile=$base.d
+
+ # For projects that build the same source file twice into different object
+ # files, the pgcc approach of using the *source* file root name can cause
+ # problems in parallel builds. Use a locking strategy to avoid stomping on
+ # the same $tmpdepfile.
+ lockdir=$base.d-lock
+ trap "
+ echo '$0: caught signal, cleaning up...' >&2
+ rmdir '$lockdir'
+ exit 1
+ " 1 2 13 15
+ numtries=100
+ i=$numtries
+ while test $i -gt 0; do
+ # mkdir is a portable test-and-set.
+ if mkdir "$lockdir" 2>/dev/null; then
+ # This process acquired the lock.
+ "$@" -MD
+ stat=$?
+ # Release the lock.
+ rmdir "$lockdir"
+ break
+ else
+ # If the lock is being held by a different process, wait
+ # until the winning process is done or we timeout.
+ while test -d "$lockdir" && test $i -gt 0; do
+ sleep 1
+ i=`expr $i - 1`
+ done
+ fi
+ i=`expr $i - 1`
+ done
+ trap - 1 2 13 15
+ if test $i -le 0; then
+ echo "$0: failed to acquire lock after $numtries attempts" >&2
+ echo "$0: check lockdir '$lockdir'" >&2
+ exit 1
+ fi
+
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+ # Each line is of the form `foo.o: dependent.h',
+ # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
+ # Do two passes, one to just change these to
+ # `$object: dependent.h' and one to simply `dependent.h:'.
+ sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
+ # Some versions of the HPUX 10.20 sed can't process this invocation
+ # correctly. Breaking it into two sed invocations is a workaround.
+ sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
+ | sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+hp2)
+ # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+ # compilers, which have integrated preprocessors. The correct option
+ # to use with these is +Maked; it writes dependencies to a file named
+ # 'foo.d', which lands next to the object file, wherever that
+ # happens to be.
+ # Much of this is similar to the tru64 case; see comments there.
+ set_dir_from "$object"
+ set_base_from "$object"
+ if test "$libtool" = yes; then
+ tmpdepfile1=$dir$base.d
+ tmpdepfile2=$dir.libs/$base.d
+ "$@" -Wc,+Maked
+ else
+ tmpdepfile1=$dir$base.d
+ tmpdepfile2=$dir$base.d
+ "$@" +Maked
+ fi
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile1" "$tmpdepfile2"
+ exit $stat
+ fi
+
+ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+ do
+ test -f "$tmpdepfile" && break
+ done
+ if test -f "$tmpdepfile"; then
+ sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
+ # Add 'dependent.h:' lines.
+ sed -ne '2,${
+ s/^ *//
+ s/ \\*$//
+ s/$/:/
+ p
+ }' "$tmpdepfile" >> "$depfile"
+ else
+ make_dummy_depfile
+ fi
+ rm -f "$tmpdepfile" "$tmpdepfile2"
+ ;;
+
+tru64)
+ # The Tru64 compiler uses -MD to generate dependencies as a side
+ # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
+ # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+ # dependencies in 'foo.d' instead, so we check for that too.
+ # Subdirectories are respected.
+ set_dir_from "$object"
+ set_base_from "$object"
+
+ if test "$libtool" = yes; then
+ # Libtool generates 2 separate objects for the 2 libraries. These
+ # two compilations output dependencies in $dir.libs/$base.o.d and
+ # in $dir$base.o.d. We have to check for both files, because
+ # one of the two compilations can be disabled. We should prefer
+ # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+ # automatically cleaned when .libs/ is deleted, while ignoring
+ # the former would cause a distcleancheck panic.
+ tmpdepfile1=$dir$base.o.d # libtool 1.5
+ tmpdepfile2=$dir.libs/$base.o.d # Likewise.
+ tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504
+ "$@" -Wc,-MD
+ else
+ tmpdepfile1=$dir$base.d
+ tmpdepfile2=$dir$base.d
+ tmpdepfile3=$dir$base.d
+ "$@" -MD
+ fi
+
+ stat=$?
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ exit $stat
+ fi
+
+ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+ do
+ test -f "$tmpdepfile" && break
+ done
+ # Same post-processing that is required for AIX mode.
+ aix_post_process_depfile
+ ;;
+
+msvc7)
+ if test "$libtool" = yes; then
+ showIncludes=-Wc,-showIncludes
+ else
+ showIncludes=-showIncludes
+ fi
+ "$@" $showIncludes > "$tmpdepfile"
+ stat=$?
+ grep -v '^Note: including file: ' "$tmpdepfile"
+ if test $stat -ne 0; then
+ rm -f "$tmpdepfile"
+ exit $stat
+ fi
+ rm -f "$depfile"
+ echo "$object : \\" > "$depfile"
+ # The first sed program below extracts the file names and escapes
+ # backslashes for cygpath. The second sed program outputs the file
+ # name when reading, but also accumulates all include files in the
+ # hold buffer in order to output them again at the end. This only
+ # works with sed implementations that can handle large buffers.
+ sed < "$tmpdepfile" -n '
+/^Note: including file: *\(.*\)/ {
+ s//\1/
+ s/\\/\\\\/g
+ p
+}' | $cygpath_u | sort -u | sed -n '
+s/ /\\ /g
+s/\(.*\)/'"$tab"'\1 \\/p
+s/.\(.*\) \\/\1:/
+H
+$ {
+ s/.*/'"$tab"'/
+ G
+ p
+}' >> "$depfile"
+ echo >> "$depfile" # make sure the fragment doesn't end with a backslash
+ rm -f "$tmpdepfile"
+ ;;
+
+msvc7msys)
+ # This case exists only to let depend.m4 do its work. It works by
+ # looking at the text of this script. This case will never be run,
+ # since it is checked for above.
+ exit 1
+ ;;
+
+#nosideeffect)
+ # This comment above is used by automake to tell side-effect
+ # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+ # Important note: in order to support this mode, a compiler *must*
+ # always write the preprocessed file to stdout, regardless of -o.
+ "$@" || exit $?
+
+ # Remove the call to Libtool.
+ if test "$libtool" = yes; then
+ while test "X$1" != 'X--mode=compile'; do
+ shift
+ done
+ shift
+ fi
+
+ # Remove '-o $object'.
+ IFS=" "
+ for arg
+ do
+ case $arg in
+ -o)
+ shift
+ ;;
+ $object)
+ shift
+ ;;
+ *)
+ set fnord "$@" "$arg"
+ shift # fnord
+ shift # $arg
+ ;;
+ esac
+ done
+
+ test -z "$dashmflag" && dashmflag=-M
+ # Require at least two characters before searching for ':'
+ # in the target name. This is to cope with DOS-style filenames:
+ # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
+ "$@" $dashmflag |
+ sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
+ rm -f "$depfile"
+ cat < "$tmpdepfile" > "$depfile"
+ # Some versions of the HPUX 10.20 sed can't process this sed invocation
+ # correctly. Breaking it into two sed invocations is a workaround.
+ tr ' ' "$nl" < "$tmpdepfile" \
+ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+ | sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+dashXmstdout)
+ # This case only exists to satisfy depend.m4. It is never actually
+ # run, as this mode is specially recognized in the preamble.
+ exit 1
+ ;;
+
+makedepend)
+ "$@" || exit $?
+ # Remove any Libtool call
+ if test "$libtool" = yes; then
+ while test "X$1" != 'X--mode=compile'; do
+ shift
+ done
+ shift
+ fi
+ # X makedepend
+ shift
+ cleared=no eat=no
+ for arg
+ do
+ case $cleared in
+ no)
+ set ""; shift
+ cleared=yes ;;
+ esac
+ if test $eat = yes; then
+ eat=no
+ continue
+ fi
+ case "$arg" in
+ -D*|-I*)
+ set fnord "$@" "$arg"; shift ;;
+ # Strip any option that makedepend may not understand. Remove
+ # the object too, otherwise makedepend will parse it as a source file.
+ -arch)
+ eat=yes ;;
+ -*|$object)
+ ;;
+ *)
+ set fnord "$@" "$arg"; shift ;;
+ esac
+ done
+ obj_suffix=`echo "$object" | sed 's/^.*\././'`
+ touch "$tmpdepfile"
+ ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+ rm -f "$depfile"
+ # makedepend may prepend the VPATH from the source file name to the object.
+ # No need to regex-escape $object, excess matching of '.' is harmless.
+ sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
+ # Some versions of the HPUX 10.20 sed can't process the last invocation
+ # correctly. Breaking it into two sed invocations is a workaround.
+ sed '1,2d' "$tmpdepfile" \
+ | tr ' ' "$nl" \
+ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+ | sed -e 's/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile" "$tmpdepfile".bak
+ ;;
+
+cpp)
+ # Important note: in order to support this mode, a compiler *must*
+ # always write the preprocessed file to stdout.
+ "$@" || exit $?
+
+ # Remove the call to Libtool.
+ if test "$libtool" = yes; then
+ while test "X$1" != 'X--mode=compile'; do
+ shift
+ done
+ shift
+ fi
+
+ # Remove '-o $object'.
+ IFS=" "
+ for arg
+ do
+ case $arg in
+ -o)
+ shift
+ ;;
+ $object)
+ shift
+ ;;
+ *)
+ set fnord "$@" "$arg"
+ shift # fnord
+ shift # $arg
+ ;;
+ esac
+ done
+
+ "$@" -E \
+ | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+ -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+ | sed '$ s: \\$::' > "$tmpdepfile"
+ rm -f "$depfile"
+ echo "$object : \\" > "$depfile"
+ cat < "$tmpdepfile" >> "$depfile"
+ sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+msvisualcpp)
+ # Important note: in order to support this mode, a compiler *must*
+ # always write the preprocessed file to stdout.
+ "$@" || exit $?
+
+ # Remove the call to Libtool.
+ if test "$libtool" = yes; then
+ while test "X$1" != 'X--mode=compile'; do
+ shift
+ done
+ shift
+ fi
+
+ IFS=" "
+ for arg
+ do
+ case "$arg" in
+ -o)
+ shift
+ ;;
+ $object)
+ shift
+ ;;
+ "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+ set fnord "$@"
+ shift
+ shift
+ ;;
+ *)
+ set fnord "$@" "$arg"
+ shift
+ shift
+ ;;
+ esac
+ done
+ "$@" -E 2>/dev/null |
+ sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
+ rm -f "$depfile"
+ echo "$object : \\" > "$depfile"
+ sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
+ echo "$tab" >> "$depfile"
+ sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
+ rm -f "$tmpdepfile"
+ ;;
+
+msvcmsys)
+ # This case exists only to let depend.m4 do its work. It works by
+ # looking at the text of this script. This case will never be run,
+ # since it is checked for above.
+ exit 1
+ ;;
+
+none)
+ exec "$@"
+ ;;
+
+*)
+ echo "Unknown depmode $depmode" 1>&2
+ exit 1
+ ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
--- /dev/null
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2011-11-20.07; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# 'make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+nl='
+'
+IFS=" "" $nl"
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit=${DOITPROG-}
+if test -z "$doit"; then
+ doit_exec=exec
+else
+ doit_exec=$doit
+fi
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_glob='?'
+initialize_posix_glob='
+ test "$posix_glob" != "?" || {
+ if (set -f) 2>/dev/null; then
+ posix_glob=
+ else
+ posix_glob=:
+ fi
+ }
+'
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+no_target_directory=
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+ or: $0 [OPTION]... SRCFILES... DIRECTORY
+ or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+ or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+ --help display this help and exit.
+ --version display version info and exit.
+
+ -c (ignored)
+ -C install only if different (preserve the last data modification time)
+ -d create directories instead of installing files.
+ -g GROUP $chgrpprog installed files to GROUP.
+ -m MODE $chmodprog installed files to MODE.
+ -o USER $chownprog installed files to USER.
+ -s $stripprog installed files.
+ -t DIRECTORY install into DIRECTORY.
+ -T report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+ CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+ RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+ case $1 in
+ -c) ;;
+
+ -C) copy_on_change=true;;
+
+ -d) dir_arg=true;;
+
+ -g) chgrpcmd="$chgrpprog $2"
+ shift;;
+
+ --help) echo "$usage"; exit $?;;
+
+ -m) mode=$2
+ case $mode in
+ *' '* | *' '* | *'
+'* | *'*'* | *'?'* | *'['*)
+ echo "$0: invalid mode: $mode" >&2
+ exit 1;;
+ esac
+ shift;;
+
+ -o) chowncmd="$chownprog $2"
+ shift;;
+
+ -s) stripcmd=$stripprog;;
+
+ -t) dst_arg=$2
+ # Protect names problematic for 'test' and other utilities.
+ case $dst_arg in
+ -* | [=\(\)!]) dst_arg=./$dst_arg;;
+ esac
+ shift;;
+
+ -T) no_target_directory=true;;
+
+ --version) echo "$0 $scriptversion"; exit $?;;
+
+ --) shift
+ break;;
+
+ -*) echo "$0: invalid option: $1" >&2
+ exit 1;;
+
+ *) break;;
+ esac
+ shift
+done
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+ # When -d is used, all remaining arguments are directories to create.
+ # When -t is used, the destination is already specified.
+ # Otherwise, the last argument is the destination. Remove it from $@.
+ for arg
+ do
+ if test -n "$dst_arg"; then
+ # $@ is not empty: it contains at least $arg.
+ set fnord "$@" "$dst_arg"
+ shift # fnord
+ fi
+ shift # arg
+ dst_arg=$arg
+ # Protect names problematic for 'test' and other utilities.
+ case $dst_arg in
+ -* | [=\(\)!]) dst_arg=./$dst_arg;;
+ esac
+ done
+fi
+
+if test $# -eq 0; then
+ if test -z "$dir_arg"; then
+ echo "$0: no input file specified." >&2
+ exit 1
+ fi
+ # It's OK to call 'install-sh -d' without argument.
+ # This can happen when creating conditional directories.
+ exit 0
+fi
+
+if test -z "$dir_arg"; then
+ do_exit='(exit $ret); exit $ret'
+ trap "ret=129; $do_exit" 1
+ trap "ret=130; $do_exit" 2
+ trap "ret=141; $do_exit" 13
+ trap "ret=143; $do_exit" 15
+
+ # Set umask so as not to create temps with too-generous modes.
+ # However, 'strip' requires both read and write access to temps.
+ case $mode in
+ # Optimize common cases.
+ *644) cp_umask=133;;
+ *755) cp_umask=22;;
+
+ *[0-7])
+ if test -z "$stripcmd"; then
+ u_plus_rw=
+ else
+ u_plus_rw='% 200'
+ fi
+ cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+ *)
+ if test -z "$stripcmd"; then
+ u_plus_rw=
+ else
+ u_plus_rw=,u+rw
+ fi
+ cp_umask=$mode$u_plus_rw;;
+ esac
+fi
+
+for src
+do
+ # Protect names problematic for 'test' and other utilities.
+ case $src in
+ -* | [=\(\)!]) src=./$src;;
+ esac
+
+ if test -n "$dir_arg"; then
+ dst=$src
+ dstdir=$dst
+ test -d "$dstdir"
+ dstdir_status=$?
+ else
+
+ # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+ # might cause directories to be created, which would be especially bad
+ # if $src (and thus $dsttmp) contains '*'.
+ if test ! -f "$src" && test ! -d "$src"; then
+ echo "$0: $src does not exist." >&2
+ exit 1
+ fi
+
+ if test -z "$dst_arg"; then
+ echo "$0: no destination specified." >&2
+ exit 1
+ fi
+ dst=$dst_arg
+
+ # If destination is a directory, append the input filename; won't work
+ # if double slashes aren't ignored.
+ if test -d "$dst"; then
+ if test -n "$no_target_directory"; then
+ echo "$0: $dst_arg: Is a directory" >&2
+ exit 1
+ fi
+ dstdir=$dst
+ dst=$dstdir/`basename "$src"`
+ dstdir_status=0
+ else
+ # Prefer dirname, but fall back on a substitute if dirname fails.
+ dstdir=`
+ (dirname "$dst") 2>/dev/null ||
+ expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$dst" : 'X\(//\)[^/]' \| \
+ X"$dst" : 'X\(//\)$' \| \
+ X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$dst" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'
+ `
+
+ test -d "$dstdir"
+ dstdir_status=$?
+ fi
+ fi
+
+ obsolete_mkdir_used=false
+
+ if test $dstdir_status != 0; then
+ case $posix_mkdir in
+ '')
+ # Create intermediate dirs using mode 755 as modified by the umask.
+ # This is like FreeBSD 'install' as of 1997-10-28.
+ umask=`umask`
+ case $stripcmd.$umask in
+ # Optimize common cases.
+ *[2367][2367]) mkdir_umask=$umask;;
+ .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+ *[0-7])
+ mkdir_umask=`expr $umask + 22 \
+ - $umask % 100 % 40 + $umask % 20 \
+ - $umask % 10 % 4 + $umask % 2
+ `;;
+ *) mkdir_umask=$umask,go-w;;
+ esac
+
+ # With -d, create the new directory with the user-specified mode.
+ # Otherwise, rely on $mkdir_umask.
+ if test -n "$dir_arg"; then
+ mkdir_mode=-m$mode
+ else
+ mkdir_mode=
+ fi
+
+ posix_mkdir=false
+ case $umask in
+ *[123567][0-7][0-7])
+ # POSIX mkdir -p sets u+wx bits regardless of umask, which
+ # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+ ;;
+ *)
+ tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+ trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+ if (umask $mkdir_umask &&
+ exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+ then
+ if test -z "$dir_arg" || {
+ # Check for POSIX incompatibilities with -m.
+ # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+ # other-writable bit of parent directory when it shouldn't.
+ # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+ ls_ld_tmpdir=`ls -ld "$tmpdir"`
+ case $ls_ld_tmpdir in
+ d????-?r-*) different_mode=700;;
+ d????-?--*) different_mode=755;;
+ *) false;;
+ esac &&
+ $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+ ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+ test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+ }
+ }
+ then posix_mkdir=:
+ fi
+ rmdir "$tmpdir/d" "$tmpdir"
+ else
+ # Remove any dirs left behind by ancient mkdir implementations.
+ rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+ fi
+ trap '' 0;;
+ esac;;
+ esac
+
+ if
+ $posix_mkdir && (
+ umask $mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+ )
+ then :
+ else
+
+ # The umask is ridiculous, or mkdir does not conform to POSIX,
+ # or it failed possibly due to a race condition. Create the
+ # directory the slow way, step by step, checking for races as we go.
+
+ case $dstdir in
+ /*) prefix='/';;
+ [-=\(\)!]*) prefix='./';;
+ *) prefix='';;
+ esac
+
+ eval "$initialize_posix_glob"
+
+ oIFS=$IFS
+ IFS=/
+ $posix_glob set -f
+ set fnord $dstdir
+ shift
+ $posix_glob set +f
+ IFS=$oIFS
+
+ prefixes=
+
+ for d
+ do
+ test X"$d" = X && continue
+
+ prefix=$prefix$d
+ if test -d "$prefix"; then
+ prefixes=
+ else
+ if $posix_mkdir; then
+ (umask=$mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+ # Don't fail if two instances are running concurrently.
+ test -d "$prefix" || exit 1
+ else
+ case $prefix in
+ *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+ *) qprefix=$prefix;;
+ esac
+ prefixes="$prefixes '$qprefix'"
+ fi
+ fi
+ prefix=$prefix/
+ done
+
+ if test -n "$prefixes"; then
+ # Don't fail if two instances are running concurrently.
+ (umask $mkdir_umask &&
+ eval "\$doit_exec \$mkdirprog $prefixes") ||
+ test -d "$dstdir" || exit 1
+ obsolete_mkdir_used=true
+ fi
+ fi
+ fi
+
+ if test -n "$dir_arg"; then
+ { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+ { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+ test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+ else
+
+ # Make a couple of temp file names in the proper directory.
+ dsttmp=$dstdir/_inst.$$_
+ rmtmp=$dstdir/_rm.$$_
+
+ # Trap to clean up those temp files at exit.
+ trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+ # Copy the file name to the temp name.
+ (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+ # and set any options; do chmod last to preserve setuid bits.
+ #
+ # If any of these fail, we abort the whole thing. If we want to
+ # ignore errors from any of these, just make sure not to ignore
+ # errors from the above "$doit $cpprog $src $dsttmp" command.
+ #
+ { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+ { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+ { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+ # If -C, don't bother to copy if it wouldn't change the file.
+ if $copy_on_change &&
+ old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
+ new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
+
+ eval "$initialize_posix_glob" &&
+ $posix_glob set -f &&
+ set X $old && old=:$2:$4:$5:$6 &&
+ set X $new && new=:$2:$4:$5:$6 &&
+ $posix_glob set +f &&
+
+ test "$old" = "$new" &&
+ $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+ then
+ rm -f "$dsttmp"
+ else
+ # Rename the file to the real destination.
+ $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+ # The rename failed, perhaps because mv can't rename something else
+ # to itself, or perhaps because mv is so ancient that it does not
+ # support -f.
+ {
+ # Now remove or move aside any old file at destination location.
+ # We try this two ways since rm can't unlink itself on some
+ # systems and the destination file might be busy for other
+ # reasons. In this case, the final cleanup might fail but the new
+ # file should still install successfully.
+ {
+ test ! -f "$dst" ||
+ $doit $rmcmd -f "$dst" 2>/dev/null ||
+ { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+ { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+ } ||
+ { echo "$0: cannot unlink or rename $dst" >&2
+ (exit 1); exit 1
+ }
+ } &&
+
+ # Now rename the file to the real destination.
+ $doit $mvcmd "$dsttmp" "$dst"
+ }
+ fi || exit 1
+
+ trap '' 0
+ fi
+done
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
--- /dev/null
+
+# libtool (GNU libtool) 2.4.2
+# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
+# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions. There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Libtool; see the file COPYING. If not, a copy
+# can be downloaded from http://www.gnu.org/licenses/gpl.html,
+# or obtained by writing to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+# Usage: $progname [OPTION]... [MODE-ARG]...
+#
+# Provide generalized library-building support services.
+#
+# --config show all configuration variables
+# --debug enable verbose shell tracing
+# -n, --dry-run display commands without modifying any files
+# --features display basic configuration information and exit
+# --mode=MODE use operation mode MODE
+# --preserve-dup-deps don't remove duplicate dependency libraries
+# --quiet, --silent don't print informational messages
+# --no-quiet, --no-silent
+# print informational messages (default)
+# --no-warn don't display warning messages
+# --tag=TAG use configuration variables from tag TAG
+# -v, --verbose print more informational messages than default
+# --no-verbose don't print the extra informational messages
+# --version print version information
+# -h, --help, --help-all print short, long, or detailed help message
+#
+# MODE must be one of the following:
+#
+# clean remove files from the build directory
+# compile compile a source file into a libtool object
+# execute automatically set library path, then run a program
+# finish complete the installation of libtool libraries
+# install install libraries or executables
+# link create a library or an executable
+# uninstall remove libraries from an installed directory
+#
+# MODE-ARGS vary depending on the MODE. When passed as first option,
+# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
+# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
+#
+# When reporting a bug, please describe a test case to reproduce it and
+# include the following information:
+#
+# host-triplet: $host
+# shell: $SHELL
+# compiler: $LTCC
+# compiler flags: $LTCFLAGS
+# linker: $LD (gnu? $with_gnu_ld)
+# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1.7ubuntu1
+# automake: $automake_version
+# autoconf: $autoconf_version
+#
+# Report bugs to <bug-libtool@gnu.org>.
+# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
+# General help using GNU software: <http://www.gnu.org/gethelp/>.
+
+PROGRAM=libtool
+PACKAGE=libtool
+VERSION="2.4.2 Debian-2.4.2-1.7ubuntu1"
+TIMESTAMP=""
+package_revision=1.3337
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+ emulate sh
+ NULLCMD=:
+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+ # is contrary to our usage. Disable this feature.
+ alias -g '${1+"$@"}'='"$@"'
+ setopt NO_GLOB_SUBST
+else
+ case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+ eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+}
+
+# NLS nuisances: We save the old values to restore during execute mode.
+lt_user_locale=
+lt_safe_locale=
+for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+do
+ eval "if test \"\${$lt_var+set}\" = set; then
+ save_$lt_var=\$$lt_var
+ $lt_var=C
+ export $lt_var
+ lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
+ lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
+ fi"
+done
+LC_ALL=C
+LANGUAGE=C
+export LANGUAGE LC_ALL
+
+$lt_unset CDPATH
+
+
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath="$0"
+
+
+
+: ${CP="cp -f"}
+test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
+: ${MAKE="make"}
+: ${MKDIR="mkdir"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
+: ${Xsed="$SED -e 1s/^X//"}
+
+# Global variables:
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing.
+EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake.
+
+exit_status=$EXIT_SUCCESS
+
+# Make sure IFS has a sensible default
+lt_nl='
+'
+IFS=" $lt_nl"
+
+dirname="s,/[^/]*$,,"
+basename="s,^.*/,,"
+
+# func_dirname file append nondir_replacement
+# Compute the dirname of FILE. If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+func_dirname ()
+{
+ func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
+ if test "X$func_dirname_result" = "X${1}"; then
+ func_dirname_result="${3}"
+ else
+ func_dirname_result="$func_dirname_result${2}"
+ fi
+} # func_dirname may be replaced by extended shell implementation
+
+
+# func_basename file
+func_basename ()
+{
+ func_basename_result=`$ECHO "${1}" | $SED "$basename"`
+} # func_basename may be replaced by extended shell implementation
+
+
+# func_dirname_and_basename file append nondir_replacement
+# perform func_basename and func_dirname in a single function
+# call:
+# dirname: Compute the dirname of FILE. If nonempty,
+# add APPEND to the result, otherwise set result
+# to NONDIR_REPLACEMENT.
+# value returned in "$func_dirname_result"
+# basename: Compute filename of FILE.
+# value retuned in "$func_basename_result"
+# Implementation must be kept synchronized with func_dirname
+# and func_basename. For efficiency, we do not delegate to
+# those functions but instead duplicate the functionality here.
+func_dirname_and_basename ()
+{
+ # Extract subdirectory from the argument.
+ func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
+ if test "X$func_dirname_result" = "X${1}"; then
+ func_dirname_result="${3}"
+ else
+ func_dirname_result="$func_dirname_result${2}"
+ fi
+ func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
+} # func_dirname_and_basename may be replaced by extended shell implementation
+
+
+# func_stripname prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+# func_strip_suffix prefix name
+func_stripname ()
+{
+ case ${2} in
+ .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
+ *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
+ esac
+} # func_stripname may be replaced by extended shell implementation
+
+
+# These SED scripts presuppose an absolute path with a trailing slash.
+pathcar='s,^/\([^/]*\).*$,\1,'
+pathcdr='s,^/[^/]*,,'
+removedotparts=':dotsl
+ s@/\./@/@g
+ t dotsl
+ s,/\.$,/,'
+collapseslashes='s@/\{1,\}@/@g'
+finalslash='s,/*$,/,'
+
+# func_normal_abspath PATH
+# Remove doubled-up and trailing slashes, "." path components,
+# and cancel out any ".." path components in PATH after making
+# it an absolute path.
+# value returned in "$func_normal_abspath_result"
+func_normal_abspath ()
+{
+ # Start from root dir and reassemble the path.
+ func_normal_abspath_result=
+ func_normal_abspath_tpath=$1
+ func_normal_abspath_altnamespace=
+ case $func_normal_abspath_tpath in
+ "")
+ # Empty path, that just means $cwd.
+ func_stripname '' '/' "`pwd`"
+ func_normal_abspath_result=$func_stripname_result
+ return
+ ;;
+ # The next three entries are used to spot a run of precisely
+ # two leading slashes without using negated character classes;
+ # we take advantage of case's first-match behaviour.
+ ///*)
+ # Unusual form of absolute path, do nothing.
+ ;;
+ //*)
+ # Not necessarily an ordinary path; POSIX reserves leading '//'
+ # and for example Cygwin uses it to access remote file shares
+ # over CIFS/SMB, so we conserve a leading double slash if found.
+ func_normal_abspath_altnamespace=/
+ ;;
+ /*)
+ # Absolute path, do nothing.
+ ;;
+ *)
+ # Relative path, prepend $cwd.
+ func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
+ ;;
+ esac
+ # Cancel out all the simple stuff to save iterations. We also want
+ # the path to end with a slash for ease of parsing, so make sure
+ # there is one (and only one) here.
+ func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+ -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
+ while :; do
+ # Processed it all yet?
+ if test "$func_normal_abspath_tpath" = / ; then
+ # If we ascended to the root using ".." the result may be empty now.
+ if test -z "$func_normal_abspath_result" ; then
+ func_normal_abspath_result=/
+ fi
+ break
+ fi
+ func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
+ -e "$pathcar"`
+ func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+ -e "$pathcdr"`
+ # Figure out what to do with it
+ case $func_normal_abspath_tcomponent in
+ "")
+ # Trailing empty path component, ignore it.
+ ;;
+ ..)
+ # Parent dir; strip last assembled component from result.
+ func_dirname "$func_normal_abspath_result"
+ func_normal_abspath_result=$func_dirname_result
+ ;;
+ *)
+ # Actual path component, append it.
+ func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
+ ;;
+ esac
+ done
+ # Restore leading double-slash if one was found on entry.
+ func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
+}
+
+# func_relative_path SRCDIR DSTDIR
+# generates a relative path from SRCDIR to DSTDIR, with a trailing
+# slash if non-empty, suitable for immediately appending a filename
+# without needing to append a separator.
+# value returned in "$func_relative_path_result"
+func_relative_path ()
+{
+ func_relative_path_result=
+ func_normal_abspath "$1"
+ func_relative_path_tlibdir=$func_normal_abspath_result
+ func_normal_abspath "$2"
+ func_relative_path_tbindir=$func_normal_abspath_result
+
+ # Ascend the tree starting from libdir
+ while :; do
+ # check if we have found a prefix of bindir
+ case $func_relative_path_tbindir in
+ $func_relative_path_tlibdir)
+ # found an exact match
+ func_relative_path_tcancelled=
+ break
+ ;;
+ $func_relative_path_tlibdir*)
+ # found a matching prefix
+ func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
+ func_relative_path_tcancelled=$func_stripname_result
+ if test -z "$func_relative_path_result"; then
+ func_relative_path_result=.
+ fi
+ break
+ ;;
+ *)
+ func_dirname $func_relative_path_tlibdir
+ func_relative_path_tlibdir=${func_dirname_result}
+ if test "x$func_relative_path_tlibdir" = x ; then
+ # Have to descend all the way to the root!
+ func_relative_path_result=../$func_relative_path_result
+ func_relative_path_tcancelled=$func_relative_path_tbindir
+ break
+ fi
+ func_relative_path_result=../$func_relative_path_result
+ ;;
+ esac
+ done
+
+ # Now calculate path; take care to avoid doubling-up slashes.
+ func_stripname '' '/' "$func_relative_path_result"
+ func_relative_path_result=$func_stripname_result
+ func_stripname '/' '/' "$func_relative_path_tcancelled"
+ if test "x$func_stripname_result" != x ; then
+ func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
+ fi
+
+ # Normalisation. If bindir is libdir, return empty string,
+ # else relative path ending with a slash; either way, target
+ # file name can be directly appended.
+ if test ! -z "$func_relative_path_result"; then
+ func_stripname './' '' "$func_relative_path_result/"
+ func_relative_path_result=$func_stripname_result
+ fi
+}
+
+# The name of this program:
+func_dirname_and_basename "$progpath"
+progname=$func_basename_result
+
+# Make sure we have an absolute path for reexecution:
+case $progpath in
+ [\\/]*|[A-Za-z]:\\*) ;;
+ *[\\/]*)
+ progdir=$func_dirname_result
+ progdir=`cd "$progdir" && pwd`
+ progpath="$progdir/$progname"
+ ;;
+ *)
+ save_IFS="$IFS"
+ IFS=${PATH_SEPARATOR-:}
+ for progdir in $PATH; do
+ IFS="$save_IFS"
+ test -x "$progdir/$progname" && break
+ done
+ IFS="$save_IFS"
+ test -n "$progdir" || progdir=`pwd`
+ progpath="$progdir/$progname"
+ ;;
+esac
+
+# Sed substitution that helps us do robust quoting. It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed="${SED}"' -e 1s/^X//'
+sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\(["`\\]\)/\\\1/g'
+
+# Sed substitution that turns a string into a regex matching for the
+# string literally.
+sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
+
+# Sed substitution that converts a w32 file name or path
+# which contains forward slashes, into one that contains
+# (escaped) backslashes. A very naive implementation.
+lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+
+# Re-`\' parameter expansions in output of double_quote_subst that were
+# `\'-ed in input to the same. If an odd number of `\' preceded a '$'
+# in input to double_quote_subst, that '$' was protected from expansion.
+# Since each input `\' is now two `\'s, look for any number of runs of
+# four `\'s followed by two `\'s and then a '$'. `\' that '$'.
+bs='\\'
+bs2='\\\\'
+bs4='\\\\\\\\'
+dollar='\$'
+sed_double_backslash="\
+ s/$bs4/&\\
+/g
+ s/^$bs2$dollar/$bs&/
+ s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
+ s/\n//g"
+
+# Standard options:
+opt_dry_run=false
+opt_help=false
+opt_quiet=false
+opt_verbose=false
+opt_warning=:
+
+# func_echo arg...
+# Echo program name prefixed message, along with the current mode
+# name if it has been set yet.
+func_echo ()
+{
+ $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
+}
+
+# func_verbose arg...
+# Echo program name prefixed message in verbose mode only.
+func_verbose ()
+{
+ $opt_verbose && func_echo ${1+"$@"}
+
+ # A bug in bash halts the script if the last line of a function
+ # fails when set -e is in force, so we need another command to
+ # work around that:
+ :
+}
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+ $ECHO "$*"
+}
+
+# func_error arg...
+# Echo program name prefixed message to standard error.
+func_error ()
+{
+ $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
+}
+
+# func_warning arg...
+# Echo program name prefixed warning message to standard error.
+func_warning ()
+{
+ $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
+
+ # bash bug again:
+ :
+}
+
+# func_fatal_error arg...
+# Echo program name prefixed message to standard error, and exit.
+func_fatal_error ()
+{
+ func_error ${1+"$@"}
+ exit $EXIT_FAILURE
+}
+
+# func_fatal_help arg...
+# Echo program name prefixed message to standard error, followed by
+# a help hint, and exit.
+func_fatal_help ()
+{
+ func_error ${1+"$@"}
+ func_fatal_error "$help"
+}
+help="Try \`$progname --help' for more information." ## default
+
+
+# func_grep expression filename
+# Check whether EXPRESSION matches any line of FILENAME, without output.
+func_grep ()
+{
+ $GREP "$1" "$2" >/dev/null 2>&1
+}
+
+
+# func_mkdir_p directory-path
+# Make sure the entire path to DIRECTORY-PATH is available.
+func_mkdir_p ()
+{
+ my_directory_path="$1"
+ my_dir_list=
+
+ if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
+
+ # Protect directory names starting with `-'
+ case $my_directory_path in
+ -*) my_directory_path="./$my_directory_path" ;;
+ esac
+
+ # While some portion of DIR does not yet exist...
+ while test ! -d "$my_directory_path"; do
+ # ...make a list in topmost first order. Use a colon delimited
+ # list incase some portion of path contains whitespace.
+ my_dir_list="$my_directory_path:$my_dir_list"
+
+ # If the last portion added has no slash in it, the list is done
+ case $my_directory_path in */*) ;; *) break ;; esac
+
+ # ...otherwise throw away the child directory and loop
+ my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
+ done
+ my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
+
+ save_mkdir_p_IFS="$IFS"; IFS=':'
+ for my_dir in $my_dir_list; do
+ IFS="$save_mkdir_p_IFS"
+ # mkdir can fail with a `File exist' error if two processes
+ # try to create one of the directories concurrently. Don't
+ # stop in that case!
+ $MKDIR "$my_dir" 2>/dev/null || :
+ done
+ IFS="$save_mkdir_p_IFS"
+
+ # Bail out if we (or some other process) failed to create a directory.
+ test -d "$my_directory_path" || \
+ func_fatal_error "Failed to create \`$1'"
+ fi
+}
+
+
+# func_mktempdir [string]
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible. If
+# given, STRING is the basename for that directory.
+func_mktempdir ()
+{
+ my_template="${TMPDIR-/tmp}/${1-$progname}"
+
+ if test "$opt_dry_run" = ":"; then
+ # Return a directory name, but don't create it in dry-run mode
+ my_tmpdir="${my_template}-$$"
+ else
+
+ # If mktemp works, use that first and foremost
+ my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
+
+ if test ! -d "$my_tmpdir"; then
+ # Failing that, at least try and use $RANDOM to avoid a race
+ my_tmpdir="${my_template}-${RANDOM-0}$$"
+
+ save_mktempdir_umask=`umask`
+ umask 0077
+ $MKDIR "$my_tmpdir"
+ umask $save_mktempdir_umask
+ fi
+
+ # If we're not in dry-run mode, bomb out on failure
+ test -d "$my_tmpdir" || \
+ func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
+ fi
+
+ $ECHO "$my_tmpdir"
+}
+
+
+# func_quote_for_eval arg
+# Aesthetically quote ARG to be evaled later.
+# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
+# is double-quoted, suitable for a subsequent eval, whereas
+# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
+# which are still active within double quotes backslashified.
+func_quote_for_eval ()
+{
+ case $1 in
+ *[\\\`\"\$]*)
+ func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
+ *)
+ func_quote_for_eval_unquoted_result="$1" ;;
+ esac
+
+ case $func_quote_for_eval_unquoted_result in
+ # Double-quote args containing shell metacharacters to delay
+ # word splitting, command substitution and and variable
+ # expansion for a subsequent eval.
+ # Many Bourne shells cannot handle close brackets correctly
+ # in scan sets, so we specify it separately.
+ *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
+ func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
+ ;;
+ *)
+ func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
+ esac
+}
+
+
+# func_quote_for_expand arg
+# Aesthetically quote ARG to be evaled later; same as above,
+# but do not quote variable references.
+func_quote_for_expand ()
+{
+ case $1 in
+ *[\\\`\"]*)
+ my_arg=`$ECHO "$1" | $SED \
+ -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
+ *)
+ my_arg="$1" ;;
+ esac
+
+ case $my_arg in
+ # Double-quote args containing shell metacharacters to delay
+ # word splitting and command substitution for a subsequent eval.
+ # Many Bourne shells cannot handle close brackets correctly
+ # in scan sets, so we specify it separately.
+ *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
+ my_arg="\"$my_arg\""
+ ;;
+ esac
+
+ func_quote_for_expand_result="$my_arg"
+}
+
+
+# func_show_eval cmd [fail_exp]
+# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
+# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it.
+func_show_eval ()
+{
+ my_cmd="$1"
+ my_fail_exp="${2-:}"
+
+ ${opt_silent-false} || {
+ func_quote_for_expand "$my_cmd"
+ eval "func_echo $func_quote_for_expand_result"
+ }
+
+ if ${opt_dry_run-false}; then :; else
+ eval "$my_cmd"
+ my_status=$?
+ if test "$my_status" -eq 0; then :; else
+ eval "(exit $my_status); $my_fail_exp"
+ fi
+ fi
+}
+
+
+# func_show_eval_locale cmd [fail_exp]
+# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is
+# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it. Use the saved locale for evaluation.
+func_show_eval_locale ()
+{
+ my_cmd="$1"
+ my_fail_exp="${2-:}"
+
+ ${opt_silent-false} || {
+ func_quote_for_expand "$my_cmd"
+ eval "func_echo $func_quote_for_expand_result"
+ }
+
+ if ${opt_dry_run-false}; then :; else
+ eval "$lt_user_locale
+ $my_cmd"
+ my_status=$?
+ eval "$lt_safe_locale"
+ if test "$my_status" -eq 0; then :; else
+ eval "(exit $my_status); $my_fail_exp"
+ fi
+ fi
+}
+
+# func_tr_sh
+# Turn $1 into a string suitable for a shell variable name.
+# Result is stored in $func_tr_sh_result. All characters
+# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
+# if $1 begins with a digit, a '_' is prepended as well.
+func_tr_sh ()
+{
+ case $1 in
+ [0-9]* | *[!a-zA-Z0-9_]*)
+ func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
+ ;;
+ * )
+ func_tr_sh_result=$1
+ ;;
+ esac
+}
+
+
+# func_version
+# Echo version message to standard output and exit.
+func_version ()
+{
+ $opt_debug
+
+ $SED -n '/(C)/!b go
+ :more
+ /\./!{
+ N
+ s/\n# / /
+ b more
+ }
+ :go
+ /^# '$PROGRAM' (GNU /,/# warranty; / {
+ s/^# //
+ s/^# *$//
+ s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
+ p
+ }' < "$progpath"
+ exit $?
+}
+
+# func_usage
+# Echo short help message to standard output and exit.
+func_usage ()
+{
+ $opt_debug
+
+ $SED -n '/^# Usage:/,/^# *.*--help/ {
+ s/^# //
+ s/^# *$//
+ s/\$progname/'$progname'/
+ p
+ }' < "$progpath"
+ echo
+ $ECHO "run \`$progname --help | more' for full usage"
+ exit $?
+}
+
+# func_help [NOEXIT]
+# Echo long help message to standard output and exit,
+# unless 'noexit' is passed as argument.
+func_help ()
+{
+ $opt_debug
+
+ $SED -n '/^# Usage:/,/# Report bugs to/ {
+ :print
+ s/^# //
+ s/^# *$//
+ s*\$progname*'$progname'*
+ s*\$host*'"$host"'*
+ s*\$SHELL*'"$SHELL"'*
+ s*\$LTCC*'"$LTCC"'*
+ s*\$LTCFLAGS*'"$LTCFLAGS"'*
+ s*\$LD*'"$LD"'*
+ s/\$with_gnu_ld/'"$with_gnu_ld"'/
+ s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
+ s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
+ p
+ d
+ }
+ /^# .* home page:/b print
+ /^# General help using/b print
+ ' < "$progpath"
+ ret=$?
+ if test -z "$1"; then
+ exit $ret
+ fi
+}
+
+# func_missing_arg argname
+# Echo program name prefixed message to standard error and set global
+# exit_cmd.
+func_missing_arg ()
+{
+ $opt_debug
+
+ func_error "missing argument for $1."
+ exit_cmd=exit
+}
+
+
+# func_split_short_opt shortopt
+# Set func_split_short_opt_name and func_split_short_opt_arg shell
+# variables after splitting SHORTOPT after the 2nd character.
+func_split_short_opt ()
+{
+ my_sed_short_opt='1s/^\(..\).*$/\1/;q'
+ my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
+
+ func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
+ func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
+} # func_split_short_opt may be replaced by extended shell implementation
+
+
+# func_split_long_opt longopt
+# Set func_split_long_opt_name and func_split_long_opt_arg shell
+# variables after splitting LONGOPT at the `=' sign.
+func_split_long_opt ()
+{
+ my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
+ my_sed_long_arg='1s/^--[^=]*=//'
+
+ func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
+ func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
+} # func_split_long_opt may be replaced by extended shell implementation
+
+exit_cmd=:
+
+
+
+
+
+magic="%%%MAGIC variable%%%"
+magic_exe="%%%MAGIC EXE variable%%%"
+
+# Global variables.
+nonopt=
+preserve_args=
+lo2o="s/\\.lo\$/.${objext}/"
+o2lo="s/\\.${objext}\$/.lo/"
+extracted_archives=
+extracted_serial=0
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end. This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+# func_append var value
+# Append VALUE to the end of shell variable VAR.
+func_append ()
+{
+ eval "${1}=\$${1}\${2}"
+} # func_append may be replaced by extended shell implementation
+
+# func_append_quoted var value
+# Quote VALUE and append to the end of shell variable VAR, separated
+# by a space.
+func_append_quoted ()
+{
+ func_quote_for_eval "${2}"
+ eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
+} # func_append_quoted may be replaced by extended shell implementation
+
+
+# func_arith arithmetic-term...
+func_arith ()
+{
+ func_arith_result=`expr "${@}"`
+} # func_arith may be replaced by extended shell implementation
+
+
+# func_len string
+# STRING may not start with a hyphen.
+func_len ()
+{
+ func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
+} # func_len may be replaced by extended shell implementation
+
+
+# func_lo2o object
+func_lo2o ()
+{
+ func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
+} # func_lo2o may be replaced by extended shell implementation
+
+
+# func_xform libobj-or-source
+func_xform ()
+{
+ func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
+} # func_xform may be replaced by extended shell implementation
+
+
+# func_fatal_configuration arg...
+# Echo program name prefixed message to standard error, followed by
+# a configuration failure hint, and exit.
+func_fatal_configuration ()
+{
+ func_error ${1+"$@"}
+ func_error "See the $PACKAGE documentation for more information."
+ func_fatal_error "Fatal configuration error."
+}
+
+
+# func_config
+# Display the configuration for all the tags in this script.
+func_config ()
+{
+ re_begincf='^# ### BEGIN LIBTOOL'
+ re_endcf='^# ### END LIBTOOL'
+
+ # Default configuration.
+ $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
+
+ # Now print the configurations for the tags.
+ for tagname in $taglist; do
+ $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
+ done
+
+ exit $?
+}
+
+# func_features
+# Display the features supported by this script.
+func_features ()
+{
+ echo "host: $host"
+ if test "$build_libtool_libs" = yes; then
+ echo "enable shared libraries"
+ else
+ echo "disable shared libraries"
+ fi
+ if test "$build_old_libs" = yes; then
+ echo "enable static libraries"
+ else
+ echo "disable static libraries"
+ fi
+
+ exit $?
+}
+
+# func_enable_tag tagname
+# Verify that TAGNAME is valid, and either flag an error and exit, or
+# enable the TAGNAME tag. We also add TAGNAME to the global $taglist
+# variable here.
+func_enable_tag ()
+{
+ # Global variable:
+ tagname="$1"
+
+ re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
+ re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
+ sed_extractcf="/$re_begincf/,/$re_endcf/p"
+
+ # Validate tagname.
+ case $tagname in
+ *[!-_A-Za-z0-9,/]*)
+ func_fatal_error "invalid tag name: $tagname"
+ ;;
+ esac
+
+ # Don't test for the "default" C tag, as we know it's
+ # there but not specially marked.
+ case $tagname in
+ CC) ;;
+ *)
+ if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
+ taglist="$taglist $tagname"
+
+ # Evaluate the configuration. Be careful to quote the path
+ # and the sed script, to avoid splitting on whitespace, but
+ # also don't use non-portable quotes within backquotes within
+ # quotes we have to do it in 2 steps:
+ extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
+ eval "$extractedcf"
+ else
+ func_error "ignoring unknown tag $tagname"
+ fi
+ ;;
+ esac
+}
+
+# func_check_version_match
+# Ensure that we are using m4 macros, and libtool script from the same
+# release of libtool.
+func_check_version_match ()
+{
+ if test "$package_revision" != "$macro_revision"; then
+ if test "$VERSION" != "$macro_version"; then
+ if test -z "$macro_version"; then
+ cat >&2 <<_LT_EOF
+$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from an older release.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+ else
+ cat >&2 <<_LT_EOF
+$progname: Version mismatch error. This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+ fi
+ else
+ cat >&2 <<_LT_EOF
+$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision,
+$progname: but the definition of this LT_INIT comes from revision $macro_revision.
+$progname: You should recreate aclocal.m4 with macros from revision $package_revision
+$progname: of $PACKAGE $VERSION and run autoconf again.
+_LT_EOF
+ fi
+
+ exit $EXIT_MISMATCH
+ fi
+}
+
+
+# Shorthand for --mode=foo, only valid as the first argument
+case $1 in
+clean|clea|cle|cl)
+ shift; set dummy --mode clean ${1+"$@"}; shift
+ ;;
+compile|compil|compi|comp|com|co|c)
+ shift; set dummy --mode compile ${1+"$@"}; shift
+ ;;
+execute|execut|execu|exec|exe|ex|e)
+ shift; set dummy --mode execute ${1+"$@"}; shift
+ ;;
+finish|finis|fini|fin|fi|f)
+ shift; set dummy --mode finish ${1+"$@"}; shift
+ ;;
+install|instal|insta|inst|ins|in|i)
+ shift; set dummy --mode install ${1+"$@"}; shift
+ ;;
+link|lin|li|l)
+ shift; set dummy --mode link ${1+"$@"}; shift
+ ;;
+uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
+ shift; set dummy --mode uninstall ${1+"$@"}; shift
+ ;;
+esac
+
+
+
+# Option defaults:
+opt_debug=:
+opt_dry_run=false
+opt_config=false
+opt_preserve_dup_deps=false
+opt_features=false
+opt_finish=false
+opt_help=false
+opt_help_all=false
+opt_silent=:
+opt_warning=:
+opt_verbose=:
+opt_silent=false
+opt_verbose=false
+
+
+# Parse options once, thoroughly. This comes as soon as possible in the
+# script to make things like `--version' happen as quickly as we can.
+{
+ # this just eases exit handling
+ while test $# -gt 0; do
+ opt="$1"
+ shift
+ case $opt in
+ --debug|-x) opt_debug='set -x'
+ func_echo "enabling shell trace mode"
+ $opt_debug
+ ;;
+ --dry-run|--dryrun|-n)
+ opt_dry_run=:
+ ;;
+ --config)
+ opt_config=:
+func_config
+ ;;
+ --dlopen|-dlopen)
+ optarg="$1"
+ opt_dlopen="${opt_dlopen+$opt_dlopen
+}$optarg"
+ shift
+ ;;
+ --preserve-dup-deps)
+ opt_preserve_dup_deps=:
+ ;;
+ --features)
+ opt_features=:
+func_features
+ ;;
+ --finish)
+ opt_finish=:
+set dummy --mode finish ${1+"$@"}; shift
+ ;;
+ --help)
+ opt_help=:
+ ;;
+ --help-all)
+ opt_help_all=:
+opt_help=': help-all'
+ ;;
+ --mode)
+ test $# = 0 && func_missing_arg $opt && break
+ optarg="$1"
+ opt_mode="$optarg"
+case $optarg in
+ # Valid mode arguments:
+ clean|compile|execute|finish|install|link|relink|uninstall) ;;
+
+ # Catch anything else as an error
+ *) func_error "invalid argument for $opt"
+ exit_cmd=exit
+ break
+ ;;
+esac
+ shift
+ ;;
+ --no-silent|--no-quiet)
+ opt_silent=false
+func_append preserve_args " $opt"
+ ;;
+ --no-warning|--no-warn)
+ opt_warning=false
+func_append preserve_args " $opt"
+ ;;
+ --no-verbose)
+ opt_verbose=false
+func_append preserve_args " $opt"
+ ;;
+ --silent|--quiet)
+ opt_silent=:
+func_append preserve_args " $opt"
+ opt_verbose=false
+ ;;
+ --verbose|-v)
+ opt_verbose=:
+func_append preserve_args " $opt"
+opt_silent=false
+ ;;
+ --tag)
+ test $# = 0 && func_missing_arg $opt && break
+ optarg="$1"
+ opt_tag="$optarg"
+func_append preserve_args " $opt $optarg"
+func_enable_tag "$optarg"
+ shift
+ ;;
+
+ -\?|-h) func_usage ;;
+ --help) func_help ;;
+ --version) func_version ;;
+
+ # Separate optargs to long options:
+ --*=*)
+ func_split_long_opt "$opt"
+ set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
+ shift
+ ;;
+
+ # Separate non-argument short options:
+ -\?*|-h*|-n*|-v*)
+ func_split_short_opt "$opt"
+ set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
+ shift
+ ;;
+
+ --) break ;;
+ -*) func_fatal_help "unrecognized option \`$opt'" ;;
+ *) set dummy "$opt" ${1+"$@"}; shift; break ;;
+ esac
+ done
+
+ # Validate options:
+
+ # save first non-option argument
+ if test "$#" -gt 0; then
+ nonopt="$opt"
+ shift
+ fi
+
+ # preserve --debug
+ test "$opt_debug" = : || func_append preserve_args " --debug"
+
+ case $host in
+ *cygwin* | *mingw* | *pw32* | *cegcc*)
+ # don't eliminate duplications in $postdeps and $predeps
+ opt_duplicate_compiler_generated_deps=:
+ ;;
+ *)
+ opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
+ ;;
+ esac
+
+ $opt_help || {
+ # Sanity checks first:
+ func_check_version_match
+
+ if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
+ func_fatal_configuration "not configured to build any kind of library"
+ fi
+
+ # Darwin sucks
+ eval std_shrext=\"$shrext_cmds\"
+
+ # Only execute mode is allowed to have -dlopen flags.
+ if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
+ func_error "unrecognized option \`-dlopen'"
+ $ECHO "$help" 1>&2
+ exit $EXIT_FAILURE
+ fi
+
+ # Change the help message to a mode-specific one.
+ generic_help="$help"
+ help="Try \`$progname --help --mode=$opt_mode' for more information."
+ }
+
+
+ # Bail if the options were screwed
+ $exit_cmd $EXIT_FAILURE
+}
+
+
+
+
+## ----------- ##
+## Main. ##
+## ----------- ##
+
+# func_lalib_p file
+# True iff FILE is a libtool `.la' library or `.lo' object file.
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_lalib_p ()
+{
+ test -f "$1" &&
+ $SED -e 4q "$1" 2>/dev/null \
+ | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+}
+
+# func_lalib_unsafe_p file
+# True iff FILE is a libtool `.la' library or `.lo' object file.
+# This function implements the same check as func_lalib_p without
+# resorting to external programs. To this end, it redirects stdin and
+# closes it afterwards, without saving the original file descriptor.
+# As a safety measure, use it only where a negative result would be
+# fatal anyway. Works if `file' does not exist.
+func_lalib_unsafe_p ()
+{
+ lalib_p=no
+ if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
+ for lalib_p_l in 1 2 3 4
+ do
+ read lalib_p_line
+ case "$lalib_p_line" in
+ \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
+ esac
+ done
+ exec 0<&5 5<&-
+ fi
+ test "$lalib_p" = yes
+}
+
+# func_ltwrapper_script_p file
+# True iff FILE is a libtool wrapper script
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_script_p ()
+{
+ func_lalib_p "$1"
+}
+
+# func_ltwrapper_executable_p file
+# True iff FILE is a libtool wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_executable_p ()
+{
+ func_ltwrapper_exec_suffix=
+ case $1 in
+ *.exe) ;;
+ *) func_ltwrapper_exec_suffix=.exe ;;
+ esac
+ $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
+}
+
+# func_ltwrapper_scriptname file
+# Assumes file is an ltwrapper_executable
+# uses $file to determine the appropriate filename for a
+# temporary ltwrapper_script.
+func_ltwrapper_scriptname ()
+{
+ func_dirname_and_basename "$1" "" "."
+ func_stripname '' '.exe' "$func_basename_result"
+ func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
+}
+
+# func_ltwrapper_p file
+# True iff FILE is a libtool wrapper script or wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_p ()
+{
+ func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
+}
+
+
+# func_execute_cmds commands fail_cmd
+# Execute tilde-delimited COMMANDS.
+# If FAIL_CMD is given, eval that upon failure.
+# FAIL_CMD may read-access the current command in variable CMD!
+func_execute_cmds ()
+{
+ $opt_debug
+ save_ifs=$IFS; IFS='~'
+ for cmd in $1; do
+ IFS=$save_ifs
+ eval cmd=\"$cmd\"
+ func_show_eval "$cmd" "${2-:}"
+ done
+ IFS=$save_ifs
+}
+
+
+# func_source file
+# Source FILE, adding directory component if necessary.
+# Note that it is not necessary on cygwin/mingw to append a dot to
+# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
+# behavior happens only for exec(3), not for open(2)! Also, sourcing
+# `FILE.' does not work on cygwin managed mounts.
+func_source ()
+{
+ $opt_debug
+ case $1 in
+ */* | *\\*) . "$1" ;;
+ *) . "./$1" ;;
+ esac
+}
+
+
+# func_resolve_sysroot PATH
+# Replace a leading = in PATH with a sysroot. Store the result into
+# func_resolve_sysroot_result
+func_resolve_sysroot ()
+{
+ func_resolve_sysroot_result=$1
+ case $func_resolve_sysroot_result in
+ =*)
+ func_stripname '=' '' "$func_resolve_sysroot_result"
+ func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
+ ;;
+ esac
+}
+
+# func_replace_sysroot PATH
+# If PATH begins with the sysroot, replace it with = and
+# store the result into func_replace_sysroot_result.
+func_replace_sysroot ()
+{
+ case "$lt_sysroot:$1" in
+ ?*:"$lt_sysroot"*)
+ func_stripname "$lt_sysroot" '' "$1"
+ func_replace_sysroot_result="=$func_stripname_result"
+ ;;
+ *)
+ # Including no sysroot.
+ func_replace_sysroot_result=$1
+ ;;
+ esac
+}
+
+# func_infer_tag arg
+# Infer tagged configuration to use if any are available and
+# if one wasn't chosen via the "--tag" command line option.
+# Only attempt this if the compiler in the base compile
+# command doesn't match the default compiler.
+# arg is usually of the form 'gcc ...'
+func_infer_tag ()
+{
+ $opt_debug
+ if test -n "$available_tags" && test -z "$tagname"; then
+ CC_quoted=
+ for arg in $CC; do
+ func_append_quoted CC_quoted "$arg"
+ done
+ CC_expanded=`func_echo_all $CC`
+ CC_quoted_expanded=`func_echo_all $CC_quoted`
+ case $@ in
+ # Blanks in the command may have been stripped by the calling shell,
+ # but not from the CC environment variable when configure was run.
+ " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
+ # Blanks at the start of $base_compile will cause this to fail
+ # if we don't check for them as well.
+ *)
+ for z in $available_tags; do
+ if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+ # Evaluate the configuration.
+ eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+ CC_quoted=
+ for arg in $CC; do
+ # Double-quote args containing other shell metacharacters.
+ func_append_quoted CC_quoted "$arg"
+ done
+ CC_expanded=`func_echo_all $CC`
+ CC_quoted_expanded=`func_echo_all $CC_quoted`
+ case "$@ " in
+ " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
+ # The compiler in the base compile command matches
+ # the one in the tagged configuration.
+ # Assume this is the tagged configuration we want.
+ tagname=$z
+ break
+ ;;
+ esac
+ fi
+ done
+ # If $tagname still isn't set, then no tagged configuration
+ # was found and let the user know that the "--tag" command
+ # line option must be used.
+ if test -z "$tagname"; then
+ func_echo "unable to infer tagged configuration"
+ func_fatal_error "specify a tag with \`--tag'"
+# else
+# func_verbose "using $tagname tagged configuration"
+ fi
+ ;;
+ esac
+ fi
+}
+
+
+
+# func_write_libtool_object output_name pic_name nonpic_name
+# Create a libtool object file (analogous to a ".la" file),
+# but don't create it if we're doing a dry run.
+func_write_libtool_object ()
+{
+ write_libobj=${1}
+ if test "$build_libtool_libs" = yes; then
+ write_lobj=\'${2}\'
+ else
+ write_lobj=none
+ fi
+
+ if test "$build_old_libs" = yes; then
+ write_oldobj=\'${3}\'
+ else
+ write_oldobj=none
+ fi
+
+ $opt_dry_run || {
+ cat >${write_libobj}T <<EOF
+# $write_libobj - a libtool object file
+# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object=$write_lobj
+
+# Name of the non-PIC object
+non_pic_object=$write_oldobj
+
+EOF
+ $MV "${write_libobj}T" "${write_libobj}"
+ }
+}
+
+
+##################################################
+# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
+##################################################
+
+# func_convert_core_file_wine_to_w32 ARG
+# Helper function used by file name 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.
+#
+# ARG is the $build file name to be converted to w32 format.
+# Result is available in $func_convert_core_file_wine_to_w32_result, and will
+# be empty on error (or when ARG is empty)
+func_convert_core_file_wine_to_w32 ()
+{
+ $opt_debug
+ func_convert_core_file_wine_to_w32_result="$1"
+ if test -n "$1"; then
+ # Unfortunately, winepath does not exit with a non-zero error code, so we
+ # are forced to check the contents of stdout. On the other hand, if the
+ # command is not found, the shell will set an exit code of 127 and print
+ # *an error message* to stdout. So we must check for both error code of
+ # zero AND non-empty stdout, which explains the odd construction:
+ func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
+ if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
+ func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
+ $SED -e "$lt_sed_naive_backslashify"`
+ else
+ func_convert_core_file_wine_to_w32_result=
+ fi
+ fi
+}
+# end: func_convert_core_file_wine_to_w32
+
+
+# func_convert_core_path_wine_to_w32 ARG
+# Helper function used by path conversion functions when $build is *nix, and
+# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
+# configured wine environment available, with the winepath program in $build's
+# $PATH. Assumes ARG has no leading or trailing path separator characters.
+#
+# ARG is path to be converted from $build format to win32.
+# Result is available in $func_convert_core_path_wine_to_w32_result.
+# Unconvertible file (directory) names in ARG are skipped; if no directory names
+# are convertible, then the result may be empty.
+func_convert_core_path_wine_to_w32 ()
+{
+ $opt_debug
+ # unfortunately, winepath doesn't convert paths, only file names
+ func_convert_core_path_wine_to_w32_result=""
+ if test -n "$1"; then
+ oldIFS=$IFS
+ IFS=:
+ for func_convert_core_path_wine_to_w32_f in $1; do
+ IFS=$oldIFS
+ func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
+ if test -n "$func_convert_core_file_wine_to_w32_result" ; then
+ if test -z "$func_convert_core_path_wine_to_w32_result"; then
+ func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
+ else
+ func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
+ fi
+ fi
+ done
+ IFS=$oldIFS
+ fi
+}
+# end: func_convert_core_path_wine_to_w32
+
+
+# func_cygpath ARGS...
+# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
+# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
+# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
+# (2), returns the Cygwin file name or path in func_cygpath_result (input
+# file name or path is assumed to be in w32 format, as previously converted
+# from $build's *nix or MSYS format). In case (3), returns the w32 file name
+# or path in func_cygpath_result (input file name or path is assumed to be in
+# Cygwin format). Returns an empty string on error.
+#
+# ARGS are passed to cygpath, with the last one being the file name or path to
+# be converted.
+#
+# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
+# environment variable; do not put it in $PATH.
+func_cygpath ()
+{
+ $opt_debug
+ if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
+ func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
+ if test "$?" -ne 0; then
+ # on failure, ensure result is empty
+ func_cygpath_result=
+ fi
+ else
+ func_cygpath_result=
+ func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
+ fi
+}
+#end: func_cygpath
+
+
+# func_convert_core_msys_to_w32 ARG
+# Convert file name or path ARG from MSYS format to w32 format. Return
+# result in func_convert_core_msys_to_w32_result.
+func_convert_core_msys_to_w32 ()
+{
+ $opt_debug
+ # awkward: cmd appends spaces to result
+ func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
+ $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
+}
+#end: func_convert_core_msys_to_w32
+
+
+# func_convert_file_check ARG1 ARG2
+# Verify that ARG1 (a file name in $build format) was converted to $host
+# format in ARG2. Otherwise, emit an error message, but continue (resetting
+# func_to_host_file_result to ARG1).
+func_convert_file_check ()
+{
+ $opt_debug
+ if test -z "$2" && test -n "$1" ; then
+ func_error "Could not determine host file name corresponding to"
+ func_error " \`$1'"
+ func_error "Continuing, but uninstalled executables may not work."
+ # Fallback:
+ func_to_host_file_result="$1"
+ fi
+}
+# end func_convert_file_check
+
+
+# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
+# Verify that FROM_PATH (a path in $build format) was converted to $host
+# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
+# func_to_host_file_result to a simplistic fallback value (see below).
+func_convert_path_check ()
+{
+ $opt_debug
+ if test -z "$4" && test -n "$3"; then
+ func_error "Could not determine the host path corresponding to"
+ func_error " \`$3'"
+ func_error "Continuing, but uninstalled executables may not work."
+ # Fallback. This is a deliberately simplistic "conversion" and
+ # should not be "improved". See libtool.info.
+ if test "x$1" != "x$2"; then
+ lt_replace_pathsep_chars="s|$1|$2|g"
+ func_to_host_path_result=`echo "$3" |
+ $SED -e "$lt_replace_pathsep_chars"`
+ else
+ func_to_host_path_result="$3"
+ fi
+ fi
+}
+# end func_convert_path_check
+
+
+# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
+# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
+# and appending REPL if ORIG matches BACKPAT.
+func_convert_path_front_back_pathsep ()
+{
+ $opt_debug
+ case $4 in
+ $1 ) func_to_host_path_result="$3$func_to_host_path_result"
+ ;;
+ esac
+ case $4 in
+ $2 ) func_append func_to_host_path_result "$3"
+ ;;
+ esac
+}
+# end func_convert_path_front_back_pathsep
+
+
+##################################################
+# $build to $host FILE NAME CONVERSION FUNCTIONS #
+##################################################
+# invoked via `$to_host_file_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# Result will be available in $func_to_host_file_result.
+
+
+# func_to_host_file ARG
+# Converts the file name ARG from $build format to $host format. Return result
+# in func_to_host_file_result.
+func_to_host_file ()
+{
+ $opt_debug
+ $to_host_file_cmd "$1"
+}
+# end func_to_host_file
+
+
+# func_to_tool_file ARG LAZY
+# converts the file name ARG from $build format to toolchain format. Return
+# result in func_to_tool_file_result. If the conversion in use is listed
+# in (the comma separated) LAZY, no conversion takes place.
+func_to_tool_file ()
+{
+ $opt_debug
+ case ,$2, in
+ *,"$to_tool_file_cmd",*)
+ func_to_tool_file_result=$1
+ ;;
+ *)
+ $to_tool_file_cmd "$1"
+ func_to_tool_file_result=$func_to_host_file_result
+ ;;
+ esac
+}
+# end func_to_tool_file
+
+
+# func_convert_file_noop ARG
+# Copy ARG to func_to_host_file_result.
+func_convert_file_noop ()
+{
+ func_to_host_file_result="$1"
+}
+# end func_convert_file_noop
+
+
+# func_convert_file_msys_to_w32 ARG
+# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper. Returns result in
+# func_to_host_file_result.
+func_convert_file_msys_to_w32 ()
+{
+ $opt_debug
+ func_to_host_file_result="$1"
+ if test -n "$1"; then
+ func_convert_core_msys_to_w32 "$1"
+ func_to_host_file_result="$func_convert_core_msys_to_w32_result"
+ fi
+ func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_w32
+
+
+# func_convert_file_cygwin_to_w32 ARG
+# Convert file name ARG from Cygwin to w32 format. Returns result in
+# func_to_host_file_result.
+func_convert_file_cygwin_to_w32 ()
+{
+ $opt_debug
+ func_to_host_file_result="$1"
+ if test -n "$1"; then
+ # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
+ # LT_CYGPATH in this case.
+ func_to_host_file_result=`cygpath -m "$1"`
+ fi
+ func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_cygwin_to_w32
+
+
+# func_convert_file_nix_to_w32 ARG
+# Convert file name ARG from *nix to w32 format. Requires a wine environment
+# and a working winepath. Returns result in func_to_host_file_result.
+func_convert_file_nix_to_w32 ()
+{
+ $opt_debug
+ func_to_host_file_result="$1"
+ if test -n "$1"; then
+ func_convert_core_file_wine_to_w32 "$1"
+ func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
+ fi
+ func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_w32
+
+
+# func_convert_file_msys_to_cygwin ARG
+# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_file_msys_to_cygwin ()
+{
+ $opt_debug
+ func_to_host_file_result="$1"
+ if test -n "$1"; then
+ func_convert_core_msys_to_w32 "$1"
+ func_cygpath -u "$func_convert_core_msys_to_w32_result"
+ func_to_host_file_result="$func_cygpath_result"
+ fi
+ func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_cygwin
+
+
+# func_convert_file_nix_to_cygwin ARG
+# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed
+# in a wine environment, working winepath, and LT_CYGPATH set. Returns result
+# in func_to_host_file_result.
+func_convert_file_nix_to_cygwin ()
+{
+ $opt_debug
+ func_to_host_file_result="$1"
+ if test -n "$1"; then
+ # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
+ func_convert_core_file_wine_to_w32 "$1"
+ func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
+ func_to_host_file_result="$func_cygpath_result"
+ fi
+ func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_cygwin
+
+
+#############################################
+# $build to $host PATH CONVERSION FUNCTIONS #
+#############################################
+# invoked via `$to_host_path_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# The result will be available in $func_to_host_path_result.
+#
+# Path separators are also converted from $build format to $host format. If
+# ARG begins or ends with a path separator character, it is preserved (but
+# converted to $host format) on output.
+#
+# All path conversion functions are named using the following convention:
+# file name conversion function : func_convert_file_X_to_Y ()
+# path conversion function : func_convert_path_X_to_Y ()
+# where, for any given $build/$host combination the 'X_to_Y' value is the
+# same. If conversion functions are added for new $build/$host combinations,
+# the two new functions must follow this pattern, or func_init_to_host_path_cmd
+# will break.
+
+
+# func_init_to_host_path_cmd
+# Ensures that function "pointer" variable $to_host_path_cmd is set to the
+# appropriate value, based on the value of $to_host_file_cmd.
+to_host_path_cmd=
+func_init_to_host_path_cmd ()
+{
+ $opt_debug
+ if test -z "$to_host_path_cmd"; then
+ func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
+ to_host_path_cmd="func_convert_path_${func_stripname_result}"
+ fi
+}
+
+
+# func_to_host_path ARG
+# Converts the path ARG from $build format to $host format. Return result
+# in func_to_host_path_result.
+func_to_host_path ()
+{
+ $opt_debug
+ func_init_to_host_path_cmd
+ $to_host_path_cmd "$1"
+}
+# end func_to_host_path
+
+
+# func_convert_path_noop ARG
+# Copy ARG to func_to_host_path_result.
+func_convert_path_noop ()
+{
+ func_to_host_path_result="$1"
+}
+# end func_convert_path_noop
+
+
+# func_convert_path_msys_to_w32 ARG
+# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper. Returns result in
+# func_to_host_path_result.
+func_convert_path_msys_to_w32 ()
+{
+ $opt_debug
+ func_to_host_path_result="$1"
+ if test -n "$1"; then
+ # Remove leading and trailing path separator characters from ARG. MSYS
+ # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
+ # and winepath ignores them completely.
+ func_stripname : : "$1"
+ func_to_host_path_tmp1=$func_stripname_result
+ func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+ func_to_host_path_result="$func_convert_core_msys_to_w32_result"
+ func_convert_path_check : ";" \
+ "$func_to_host_path_tmp1" "$func_to_host_path_result"
+ func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+ fi
+}
+# end func_convert_path_msys_to_w32
+
+
+# func_convert_path_cygwin_to_w32 ARG
+# Convert path ARG from Cygwin to w32 format. Returns result in
+# func_to_host_file_result.
+func_convert_path_cygwin_to_w32 ()
+{
+ $opt_debug
+ func_to_host_path_result="$1"
+ if test -n "$1"; then
+ # See func_convert_path_msys_to_w32:
+ func_stripname : : "$1"
+ func_to_host_path_tmp1=$func_stripname_result
+ func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
+ func_convert_path_check : ";" \
+ "$func_to_host_path_tmp1" "$func_to_host_path_result"
+ func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+ fi
+}
+# end func_convert_path_cygwin_to_w32
+
+
+# func_convert_path_nix_to_w32 ARG
+# Convert path ARG from *nix to w32 format. Requires a wine environment and
+# a working winepath. Returns result in func_to_host_file_result.
+func_convert_path_nix_to_w32 ()
+{
+ $opt_debug
+ func_to_host_path_result="$1"
+ if test -n "$1"; then
+ # See func_convert_path_msys_to_w32:
+ func_stripname : : "$1"
+ func_to_host_path_tmp1=$func_stripname_result
+ func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+ func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
+ func_convert_path_check : ";" \
+ "$func_to_host_path_tmp1" "$func_to_host_path_result"
+ func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+ fi
+}
+# end func_convert_path_nix_to_w32
+
+
+# func_convert_path_msys_to_cygwin ARG
+# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_path_msys_to_cygwin ()
+{
+ $opt_debug
+ func_to_host_path_result="$1"
+ if test -n "$1"; then
+ # See func_convert_path_msys_to_w32:
+ func_stripname : : "$1"
+ func_to_host_path_tmp1=$func_stripname_result
+ func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+ func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
+ func_to_host_path_result="$func_cygpath_result"
+ func_convert_path_check : : \
+ "$func_to_host_path_tmp1" "$func_to_host_path_result"
+ func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+ fi
+}
+# end func_convert_path_msys_to_cygwin
+
+
+# func_convert_path_nix_to_cygwin ARG
+# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a
+# a wine environment, working winepath, and LT_CYGPATH set. Returns result in
+# func_to_host_file_result.
+func_convert_path_nix_to_cygwin ()
+{
+ $opt_debug
+ func_to_host_path_result="$1"
+ if test -n "$1"; then
+ # Remove leading and trailing path separator characters from
+ # ARG. msys behavior is inconsistent here, cygpath turns them
+ # into '.;' and ';.', and winepath ignores them completely.
+ func_stripname : : "$1"
+ func_to_host_path_tmp1=$func_stripname_result
+ func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+ func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
+ func_to_host_path_result="$func_cygpath_result"
+ func_convert_path_check : : \
+ "$func_to_host_path_tmp1" "$func_to_host_path_result"
+ func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+ fi
+}
+# end func_convert_path_nix_to_cygwin
+
+
+# func_mode_compile arg...
+func_mode_compile ()
+{
+ $opt_debug
+ # Get the compilation command and the source file.
+ base_compile=
+ srcfile="$nonopt" # always keep a non-empty value in "srcfile"
+ suppress_opt=yes
+ suppress_output=
+ arg_mode=normal
+ libobj=
+ later=
+ pie_flag=
+
+ for arg
+ do
+ case $arg_mode in
+ arg )
+ # do not "continue". Instead, add this to base_compile
+ lastarg="$arg"
+ arg_mode=normal
+ ;;
+
+ target )
+ libobj="$arg"
+ arg_mode=normal
+ continue
+ ;;
+
+ normal )
+ # Accept any command-line options.
+ case $arg in
+ -o)
+ test -n "$libobj" && \
+ func_fatal_error "you cannot specify \`-o' more than once"
+ arg_mode=target
+ continue
+ ;;
+
+ -pie | -fpie | -fPIE)
+ func_append pie_flag " $arg"
+ continue
+ ;;
+
+ -shared | -static | -prefer-pic | -prefer-non-pic)
+ func_append later " $arg"
+ continue
+ ;;
+
+ -no-suppress)
+ suppress_opt=no
+ continue
+ ;;
+
+ -Xcompiler)
+ arg_mode=arg # the next one goes into the "base_compile" arg list
+ continue # The current "srcfile" will either be retained or
+ ;; # replaced later. I would guess that would be a bug.
+
+ -Wc,*)
+ func_stripname '-Wc,' '' "$arg"
+ args=$func_stripname_result
+ lastarg=
+ save_ifs="$IFS"; IFS=','
+ for arg in $args; do
+ IFS="$save_ifs"
+ func_append_quoted lastarg "$arg"
+ done
+ IFS="$save_ifs"
+ func_stripname ' ' '' "$lastarg"
+ lastarg=$func_stripname_result
+
+ # Add the arguments to base_compile.
+ func_append base_compile " $lastarg"
+ continue
+ ;;
+
+ *)
+ # Accept the current argument as the source file.
+ # The previous "srcfile" becomes the current argument.
+ #
+ lastarg="$srcfile"
+ srcfile="$arg"
+ ;;
+ esac # case $arg
+ ;;
+ esac # case $arg_mode
+
+ # Aesthetically quote the previous argument.
+ func_append_quoted base_compile "$lastarg"
+ done # for arg
+
+ case $arg_mode in
+ arg)
+ func_fatal_error "you must specify an argument for -Xcompile"
+ ;;
+ target)
+ func_fatal_error "you must specify a target with \`-o'"
+ ;;
+ *)
+ # Get the name of the library object.
+ test -z "$libobj" && {
+ func_basename "$srcfile"
+ libobj="$func_basename_result"
+ }
+ ;;
+ esac
+
+ # Recognize several different file suffixes.
+ # If the user specifies -o file.o, it is replaced with file.lo
+ case $libobj in
+ *.[cCFSifmso] | \
+ *.ada | *.adb | *.ads | *.asm | \
+ *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
+ *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
+ func_xform "$libobj"
+ libobj=$func_xform_result
+ ;;
+ esac
+
+ case $libobj in
+ *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
+ *)
+ func_fatal_error "cannot determine name of library object from \`$libobj'"
+ ;;
+ esac
+
+ func_infer_tag $base_compile
+
+ for arg in $later; do
+ case $arg in
+ -shared)
+ test "$build_libtool_libs" != yes && \
+ func_fatal_configuration "can not build a shared library"
+ build_old_libs=no
+ continue
+ ;;
+
+ -static)
+ build_libtool_libs=no
+ build_old_libs=yes
+ continue
+ ;;
+
+ -prefer-pic)
+ pic_mode=yes
+ continue
+ ;;
+
+ -prefer-non-pic)
+ pic_mode=no
+ continue
+ ;;
+ esac
+ done
+
+ func_quote_for_eval "$libobj"
+ test "X$libobj" != "X$func_quote_for_eval_result" \
+ && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \
+ && func_warning "libobj name \`$libobj' may not contain shell special characters."
+ func_dirname_and_basename "$obj" "/" ""
+ objname="$func_basename_result"
+ xdir="$func_dirname_result"
+ lobj=${xdir}$objdir/$objname
+
+ test -z "$base_compile" && \
+ func_fatal_help "you must specify a compilation command"
+
+ # Delete any leftover library objects.
+ if test "$build_old_libs" = yes; then
+ removelist="$obj $lobj $libobj ${libobj}T"
+ else
+ removelist="$lobj $libobj ${libobj}T"
+ fi
+
+ # On Cygwin there's no "real" PIC flag so we must build both object types
+ case $host_os in
+ cygwin* | mingw* | pw32* | os2* | cegcc*)
+ pic_mode=default
+ ;;
+ esac
+ if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
+ # non-PIC code in shared libraries is not supported
+ pic_mode=default
+ fi
+
+ # Calculate the filename of the output object if compiler does
+ # not support -o with -c
+ if test "$compiler_c_o" = no; then
+ output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
+ lockfile="$output_obj.lock"
+ else
+ output_obj=
+ need_locks=no
+ lockfile=
+ fi
+
+ # Lock this critical section if it is needed
+ # We use this script file to make the link, it avoids creating a new file
+ if test "$need_locks" = yes; then
+ until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+ func_echo "Waiting for $lockfile to be removed"
+ sleep 2
+ done
+ elif test "$need_locks" = warn; then
+ if test -f "$lockfile"; then
+ $ECHO "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together. If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+ $opt_dry_run || $RM $removelist
+ exit $EXIT_FAILURE
+ fi
+ func_append removelist " $output_obj"
+ $ECHO "$srcfile" > "$lockfile"
+ fi
+
+ $opt_dry_run || $RM $removelist
+ func_append removelist " $lockfile"
+ trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
+
+ func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
+ srcfile=$func_to_tool_file_result
+ func_quote_for_eval "$srcfile"
+ qsrcfile=$func_quote_for_eval_result
+
+ # Only build a PIC object if we are building libtool libraries.
+ if test "$build_libtool_libs" = yes; then
+ # Without this assignment, base_compile gets emptied.
+ fbsd_hideous_sh_bug=$base_compile
+
+ if test "$pic_mode" != no; then
+ command="$base_compile $qsrcfile $pic_flag"
+ else
+ # Don't build PIC code
+ command="$base_compile $qsrcfile"
+ fi
+
+ func_mkdir_p "$xdir$objdir"
+
+ if test -z "$output_obj"; then
+ # Place PIC objects in $objdir
+ func_append command " -o $lobj"
+ fi
+
+ func_show_eval_locale "$command" \
+ 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
+
+ if test "$need_locks" = warn &&
+ test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+ $ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together. If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+ $opt_dry_run || $RM $removelist
+ exit $EXIT_FAILURE
+ fi
+
+ # Just move the object if needed, then go on to compile the next one
+ if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
+ func_show_eval '$MV "$output_obj" "$lobj"' \
+ 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+ fi
+
+ # Allow error messages only from the first compilation.
+ if test "$suppress_opt" = yes; then
+ suppress_output=' >/dev/null 2>&1'
+ fi
+ fi
+
+ # Only build a position-dependent object if we build old libraries.
+ if test "$build_old_libs" = yes; then
+ if test "$pic_mode" != yes; then
+ # Don't build PIC code
+ command="$base_compile $qsrcfile$pie_flag"
+ else
+ command="$base_compile $qsrcfile $pic_flag"
+ fi
+ if test "$compiler_c_o" = yes; then
+ func_append command " -o $obj"
+ fi
+
+ # Suppress compiler output if we already did a PIC compilation.
+ func_append command "$suppress_output"
+ func_show_eval_locale "$command" \
+ '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
+
+ if test "$need_locks" = warn &&
+ test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+ $ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support \`-c' and \`-o' together. If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+ $opt_dry_run || $RM $removelist
+ exit $EXIT_FAILURE
+ fi
+
+ # Just move the object if needed
+ if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
+ func_show_eval '$MV "$output_obj" "$obj"' \
+ 'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+ fi
+ fi
+
+ $opt_dry_run || {
+ func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
+
+ # Unlock the critical section if it was locked
+ if test "$need_locks" != no; then
+ removelist=$lockfile
+ $RM "$lockfile"
+ fi
+ }
+
+ exit $EXIT_SUCCESS
+}
+
+$opt_help || {
+ test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
+}
+
+func_mode_help ()
+{
+ # We need to display help for each of the modes.
+ case $opt_mode in
+ "")
+ # Generic help is extracted from the usage comments
+ # at the start of this file.
+ func_help
+ ;;
+
+ clean)
+ $ECHO \
+"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
+
+Remove files from the build directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, object or program, all the files associated
+with it are deleted. Otherwise, only FILE itself is deleted using RM."
+ ;;
+
+ compile)
+ $ECHO \
+"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+ -o OUTPUT-FILE set the output file name to OUTPUT-FILE
+ -no-suppress do not suppress compiler output for multiple passes
+ -prefer-pic try to build PIC objects only
+ -prefer-non-pic try to build non-PIC objects only
+ -shared do not build a \`.o' file suitable for static linking
+ -static only build a \`.o' file suitable for static linking
+ -Wc,FLAG pass FLAG directly to the compiler
+
+COMPILE-COMMAND is a command to be used in creating a \`standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix \`.c' with the
+library object suffix, \`.lo'."
+ ;;
+
+ execute)
+ $ECHO \
+"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+ -dlopen FILE add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to \`-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+ ;;
+
+ finish)
+ $ECHO \
+"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges. Use
+the \`--dry-run' option if you just want to see what would be executed."
+ ;;
+
+ install)
+ $ECHO \
+"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command. The first component should be
+either the \`install' or \`cp' program.
+
+The following components of INSTALL-COMMAND are treated specially:
+
+ -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+ ;;
+
+ link)
+ $ECHO \
+"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+ -all-static do not do any dynamic linking at all
+ -avoid-version do not add a version suffix if possible
+ -bindir BINDIR specify path to binaries directory (for systems where
+ libraries must be found in the PATH setting at runtime)
+ -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime
+ -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols
+ -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+ -export-symbols SYMFILE
+ try to export only the symbols listed in SYMFILE
+ -export-symbols-regex REGEX
+ try to export only the symbols matching REGEX
+ -LLIBDIR search LIBDIR for required installed libraries
+ -lNAME OUTPUT-FILE requires the installed library libNAME
+ -module build a library that can dlopened
+ -no-fast-install disable the fast-install mode
+ -no-install link a not-installable executable
+ -no-undefined declare that a library does not refer to external symbols
+ -o OUTPUT-FILE create OUTPUT-FILE from the specified objects
+ -objectlist FILE Use a list of object files found in FILE to specify objects
+ -precious-files-regex REGEX
+ don't remove output files matching REGEX
+ -release RELEASE specify package release information
+ -rpath LIBDIR the created library will eventually be installed in LIBDIR
+ -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries
+ -shared only do dynamic linking of libtool libraries
+ -shrext SUFFIX override the standard shared library file extension
+ -static do not do any dynamic linking of uninstalled libtool libraries
+ -static-libtool-libs
+ do not do any dynamic linking of libtool libraries
+ -version-info CURRENT[:REVISION[:AGE]]
+ specify library version info [each variable defaults to 0]
+ -weak LIBNAME declare that the target provides the LIBNAME interface
+ -Wc,FLAG
+ -Xcompiler FLAG pass linker-specific FLAG directly to the compiler
+ -Wl,FLAG
+ -Xlinker FLAG pass linker-specific FLAG directly to the linker
+ -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC)
+
+All other options (arguments beginning with \`-') are ignored.
+
+Every other argument is treated as a filename. Files ending in \`.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
+only library objects (\`.lo' files) may be specified, and \`-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
+using \`ar' and \`ranlib', or on Windows using \`lib'.
+
+If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
+is created, otherwise an executable program is created."
+ ;;
+
+ uninstall)
+ $ECHO \
+"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+ ;;
+
+ *)
+ func_fatal_help "invalid operation mode \`$opt_mode'"
+ ;;
+ esac
+
+ echo
+ $ECHO "Try \`$progname --help' for more information about other modes."
+}
+
+# Now that we've collected a possible --mode arg, show help if necessary
+if $opt_help; then
+ if test "$opt_help" = :; then
+ func_mode_help
+ else
+ {
+ func_help noexit
+ for opt_mode in compile link execute install finish uninstall clean; do
+ func_mode_help
+ done
+ } | sed -n '1p; 2,$s/^Usage:/ or: /p'
+ {
+ func_help noexit
+ for opt_mode in compile link execute install finish uninstall clean; do
+ echo
+ func_mode_help
+ done
+ } |
+ sed '1d
+ /^When reporting/,/^Report/{
+ H
+ d
+ }
+ $x
+ /information about other modes/d
+ /more detailed .*MODE/d
+ s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
+ fi
+ exit $?
+fi
+
+
+# func_mode_execute arg...
+func_mode_execute ()
+{
+ $opt_debug
+ # The first argument is the command name.
+ cmd="$nonopt"
+ test -z "$cmd" && \
+ func_fatal_help "you must specify a COMMAND"
+
+ # Handle -dlopen flags immediately.
+ for file in $opt_dlopen; do
+ test -f "$file" \
+ || func_fatal_help "\`$file' is not a file"
+
+ dir=
+ case $file in
+ *.la)
+ func_resolve_sysroot "$file"
+ file=$func_resolve_sysroot_result
+
+ # Check to see that this really is a libtool archive.
+ func_lalib_unsafe_p "$file" \
+ || func_fatal_help "\`$lib' is not a valid libtool archive"
+
+ # Read the libtool library.
+ dlname=
+ library_names=
+ func_source "$file"
+
+ # Skip this library if it cannot be dlopened.
+ if test -z "$dlname"; then
+ # Warn if it was a shared library.
+ test -n "$library_names" && \
+ func_warning "\`$file' was not linked with \`-export-dynamic'"
+ continue
+ fi
+
+ func_dirname "$file" "" "."
+ dir="$func_dirname_result"
+
+ if test -f "$dir/$objdir/$dlname"; then
+ func_append dir "/$objdir"
+ else
+ if test ! -f "$dir/$dlname"; then
+ func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
+ fi
+ fi
+ ;;
+
+ *.lo)
+ # Just add the directory containing the .lo file.
+ func_dirname "$file" "" "."
+ dir="$func_dirname_result"
+ ;;
+
+ *)
+ func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
+ continue
+ ;;
+ esac
+
+ # Get the absolute pathname.
+ absdir=`cd "$dir" && pwd`
+ test -n "$absdir" && dir="$absdir"
+
+ # Now add the directory to shlibpath_var.
+ if eval "test -z \"\$$shlibpath_var\""; then
+ eval "$shlibpath_var=\"\$dir\""
+ else
+ eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+ fi
+ done
+
+ # This variable tells wrapper scripts just to set shlibpath_var
+ # rather than running their programs.
+ libtool_execute_magic="$magic"
+
+ # Check if any of the arguments is a wrapper script.
+ args=
+ for file
+ do
+ case $file in
+ -* | *.la | *.lo ) ;;
+ *)
+ # Do a test to see if this is really a libtool program.
+ if func_ltwrapper_script_p "$file"; then
+ func_source "$file"
+ # Transform arg to wrapped name.
+ file="$progdir/$program"
+ elif func_ltwrapper_executable_p "$file"; then
+ func_ltwrapper_scriptname "$file"
+ func_source "$func_ltwrapper_scriptname_result"
+ # Transform arg to wrapped name.
+ file="$progdir/$program"
+ fi
+ ;;
+ esac
+ # Quote arguments (to preserve shell metacharacters).
+ func_append_quoted args "$file"
+ done
+
+ if test "X$opt_dry_run" = Xfalse; then
+ if test -n "$shlibpath_var"; then
+ # Export the shlibpath_var.
+ eval "export $shlibpath_var"
+ fi
+
+ # Restore saved environment variables
+ for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+ do
+ eval "if test \"\${save_$lt_var+set}\" = set; then
+ $lt_var=\$save_$lt_var; export $lt_var
+ else
+ $lt_unset $lt_var
+ fi"
+ done
+
+ # Now prepare to actually exec the command.
+ exec_cmd="\$cmd$args"
+ else
+ # Display what would be done.
+ if test -n "$shlibpath_var"; then
+ eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
+ echo "export $shlibpath_var"
+ fi
+ $ECHO "$cmd$args"
+ exit $EXIT_SUCCESS
+ fi
+}
+
+test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
+
+
+# func_mode_finish arg...
+func_mode_finish ()
+{
+ $opt_debug
+ libs=
+ libdirs=
+ admincmds=
+
+ for opt in "$nonopt" ${1+"$@"}
+ do
+ if test -d "$opt"; then
+ func_append libdirs " $opt"
+
+ elif test -f "$opt"; then
+ if func_lalib_unsafe_p "$opt"; then
+ func_append libs " $opt"
+ else
+ func_warning "\`$opt' is not a valid libtool archive"
+ fi
+
+ else
+ func_fatal_error "invalid argument \`$opt'"
+ fi
+ done
+
+ if test -n "$libs"; then
+ if test -n "$lt_sysroot"; then
+ sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
+ sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
+ else
+ sysroot_cmd=
+ fi
+
+ # Remove sysroot references
+ if $opt_dry_run; then
+ for lib in $libs; do
+ echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
+ done
+ else
+ tmpdir=`func_mktempdir`
+ for lib in $libs; do
+ sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
+ > $tmpdir/tmp-la
+ mv -f $tmpdir/tmp-la $lib
+ done
+ ${RM}r "$tmpdir"
+ fi
+ fi
+
+ if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+ for libdir in $libdirs; do
+ if test -n "$finish_cmds"; then
+ # Do each command in the finish commands.
+ func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
+'"$cmd"'"'
+ fi
+ if test -n "$finish_eval"; then
+ # Do the single finish_eval.
+ eval cmds=\"$finish_eval\"
+ $opt_dry_run || eval "$cmds" || func_append admincmds "
+ $cmds"
+ fi
+ done
+ fi
+
+ # Exit here if they wanted silent mode.
+ $opt_silent && exit $EXIT_SUCCESS
+
+ if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+ echo "----------------------------------------------------------------------"
+ echo "Libraries have been installed in:"
+ for libdir in $libdirs; do
+ $ECHO " $libdir"
+ done
+ echo
+ echo "If you ever happen to want to link against installed libraries"
+ echo "in a given directory, LIBDIR, you must either use libtool, and"
+ echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
+ echo "flag during linking and do at least one of the following:"
+ if test -n "$shlibpath_var"; then
+ echo " - add LIBDIR to the \`$shlibpath_var' environment variable"
+ echo " during execution"
+ fi
+ if test -n "$runpath_var"; then
+ echo " - add LIBDIR to the \`$runpath_var' environment variable"
+ echo " during linking"
+ fi
+ if test -n "$hardcode_libdir_flag_spec"; then
+ libdir=LIBDIR
+ eval flag=\"$hardcode_libdir_flag_spec\"
+
+ $ECHO " - use the \`$flag' linker flag"
+ fi
+ if test -n "$admincmds"; then
+ $ECHO " - have your system administrator run these commands:$admincmds"
+ fi
+ if test -f /etc/ld.so.conf; then
+ echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
+ fi
+ echo
+
+ echo "See any operating system documentation about shared libraries for"
+ case $host in
+ solaris2.[6789]|solaris2.1[0-9])
+ echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
+ echo "pages."
+ ;;
+ *)
+ echo "more information, such as the ld(1) and ld.so(8) manual pages."
+ ;;
+ esac
+ echo "----------------------------------------------------------------------"
+ fi
+ exit $EXIT_SUCCESS
+}
+
+test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
+
+
+# func_mode_install arg...
+func_mode_install ()
+{
+ $opt_debug
+ # There may be an optional sh(1) argument at the beginning of
+ # install_prog (especially on Windows NT).
+ if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
+ # Allow the use of GNU shtool's install command.
+ case $nonopt in *shtool*) :;; *) false;; esac; then
+ # Aesthetically quote it.
+ func_quote_for_eval "$nonopt"
+ install_prog="$func_quote_for_eval_result "
+ arg=$1
+ shift
+ else
+ install_prog=
+ arg=$nonopt
+ fi
+
+ # The real first argument should be the name of the installation program.
+ # Aesthetically quote it.
+ func_quote_for_eval "$arg"
+ func_append install_prog "$func_quote_for_eval_result"
+ install_shared_prog=$install_prog
+ case " $install_prog " in
+ *[\\\ /]cp\ *) install_cp=: ;;
+ *) install_cp=false ;;
+ esac
+
+ # We need to accept at least all the BSD install flags.
+ dest=
+ files=
+ opts=
+ prev=
+ install_type=
+ isdir=no
+ stripme=
+ no_mode=:
+ for arg
+ do
+ arg2=
+ if test -n "$dest"; then
+ func_append files " $dest"
+ dest=$arg
+ continue
+ fi
+
+ case $arg in
+ -d) isdir=yes ;;
+ -f)
+ if $install_cp; then :; else
+ prev=$arg
+ fi
+ ;;
+ -g | -m | -o)
+ prev=$arg
+ ;;
+ -s)
+ stripme=" -s"
+ continue
+ ;;
+ -*)
+ ;;
+ *)
+ # If the previous option needed an argument, then skip it.
+ if test -n "$prev"; then
+ if test "x$prev" = x-m && test -n "$install_override_mode"; then
+ arg2=$install_override_mode
+ no_mode=false
+ fi
+ prev=
+ else
+ dest=$arg
+ continue
+ fi
+ ;;
+ esac
+
+ # Aesthetically quote the argument.
+ func_quote_for_eval "$arg"
+ func_append install_prog " $func_quote_for_eval_result"
+ if test -n "$arg2"; then
+ func_quote_for_eval "$arg2"
+ fi
+ func_append install_shared_prog " $func_quote_for_eval_result"
+ done
+
+ test -z "$install_prog" && \
+ func_fatal_help "you must specify an install program"
+
+ test -n "$prev" && \
+ func_fatal_help "the \`$prev' option requires an argument"
+
+ if test -n "$install_override_mode" && $no_mode; then
+ if $install_cp; then :; else
+ func_quote_for_eval "$install_override_mode"
+ func_append install_shared_prog " -m $func_quote_for_eval_result"
+ fi
+ fi
+
+ if test -z "$files"; then
+ if test -z "$dest"; then
+ func_fatal_help "no file or destination specified"
+ else
+ func_fatal_help "you must specify a destination"
+ fi
+ fi
+
+ # Strip any trailing slash from the destination.
+ func_stripname '' '/' "$dest"
+ dest=$func_stripname_result
+
+ # Check to see that the destination is a directory.
+ test -d "$dest" && isdir=yes
+ if test "$isdir" = yes; then
+ destdir="$dest"
+ destname=
+ else
+ func_dirname_and_basename "$dest" "" "."
+ destdir="$func_dirname_result"
+ destname="$func_basename_result"
+
+ # Not a directory, so check to see that there is only one file specified.
+ set dummy $files; shift
+ test "$#" -gt 1 && \
+ func_fatal_help "\`$dest' is not a directory"
+ fi
+ case $destdir in
+ [\\/]* | [A-Za-z]:[\\/]*) ;;
+ *)
+ for file in $files; do
+ case $file in
+ *.lo) ;;
+ *)
+ func_fatal_help "\`$destdir' must be an absolute directory name"
+ ;;
+ esac
+ done
+ ;;
+ esac
+
+ # This variable tells wrapper scripts just to set variables rather
+ # than running their programs.
+ libtool_install_magic="$magic"
+
+ staticlibs=
+ future_libdirs=
+ current_libdirs=
+ for file in $files; do
+
+ # Do each installation.
+ case $file in
+ *.$libext)
+ # Do the static libraries later.
+ func_append staticlibs " $file"
+ ;;
+
+ *.la)
+ func_resolve_sysroot "$file"
+ file=$func_resolve_sysroot_result
+
+ # Check to see that this really is a libtool archive.
+ func_lalib_unsafe_p "$file" \
+ || func_fatal_help "\`$file' is not a valid libtool archive"
+
+ library_names=
+ old_library=
+ relink_command=
+ func_source "$file"
+
+ # Add the libdir to current_libdirs if it is the destination.
+ if test "X$destdir" = "X$libdir"; then
+ case "$current_libdirs " in
+ *" $libdir "*) ;;
+ *) func_append current_libdirs " $libdir" ;;
+ esac
+ else
+ # Note the libdir as a future libdir.
+ case "$future_libdirs " in
+ *" $libdir "*) ;;
+ *) func_append future_libdirs " $libdir" ;;
+ esac
+ fi
+
+ func_dirname "$file" "/" ""
+ dir="$func_dirname_result"
+ func_append dir "$objdir"
+
+ if test -n "$relink_command"; then
+ # Determine the prefix the user has applied to our future dir.
+ inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
+
+ # Don't allow the user to place us outside of our expected
+ # location b/c this prevents finding dependent libraries that
+ # are installed to the same prefix.
+ # At present, this check doesn't affect windows .dll's that
+ # are installed into $libdir/../bin (currently, that works fine)
+ # but it's something to keep an eye on.
+ test "$inst_prefix_dir" = "$destdir" && \
+ func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
+
+ if test -n "$inst_prefix_dir"; then
+ # Stick the inst_prefix_dir data into the link command.
+ relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+ else
+ relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+ fi
+
+ func_warning "relinking \`$file'"
+ func_show_eval "$relink_command" \
+ 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
+ fi
+
+ # See the names of the shared library.
+ set dummy $library_names; shift
+ if test -n "$1"; then
+ realname="$1"
+ shift
+
+ srcname="$realname"
+ test -n "$relink_command" && srcname="$realname"T
+
+ # Install the shared library and build the symlinks.
+ func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
+ 'exit $?'
+ tstripme="$stripme"
+ case $host_os in
+ cygwin* | mingw* | pw32* | cegcc*)
+ case $realname in
+ *.dll.a)
+ tstripme=""
+ ;;
+ esac
+ ;;
+ esac
+ if test -n "$tstripme" && test -n "$striplib"; then
+ func_show_eval "$striplib $destdir/$realname" 'exit $?'
+ fi
+
+ if test "$#" -gt 0; then
+ # Delete the old symlinks, and create new ones.
+ # Try `ln -sf' first, because the `ln' binary might depend on
+ # the symlink we replace! Solaris /bin/ln does not understand -f,
+ # so we also need to try rm && ln -s.
+ for linkname
+ do
+ test "$linkname" != "$realname" \
+ && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
+ done
+ fi
+
+ # Do each command in the postinstall commands.
+ lib="$destdir/$realname"
+ func_execute_cmds "$postinstall_cmds" 'exit $?'
+ fi
+
+ # Install the pseudo-library for information purposes.
+ func_basename "$file"
+ name="$func_basename_result"
+ instname="$dir/$name"i
+ func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
+
+ # Maybe install the static library, too.
+ test -n "$old_library" && func_append staticlibs " $dir/$old_library"
+ ;;
+
+ *.lo)
+ # Install (i.e. copy) a libtool object.
+
+ # Figure out destination file name, if it wasn't already specified.
+ if test -n "$destname"; then
+ destfile="$destdir/$destname"
+ else
+ func_basename "$file"
+ destfile="$func_basename_result"
+ destfile="$destdir/$destfile"
+ fi
+
+ # Deduce the name of the destination old-style object file.
+ case $destfile in
+ *.lo)
+ func_lo2o "$destfile"
+ staticdest=$func_lo2o_result
+ ;;
+ *.$objext)
+ staticdest="$destfile"
+ destfile=
+ ;;
+ *)
+ func_fatal_help "cannot copy a libtool object to \`$destfile'"
+ ;;
+ esac
+
+ # Install the libtool object if requested.
+ test -n "$destfile" && \
+ func_show_eval "$install_prog $file $destfile" 'exit $?'
+
+ # Install the old object if enabled.
+ if test "$build_old_libs" = yes; then
+ # Deduce the name of the old-style object file.
+ func_lo2o "$file"
+ staticobj=$func_lo2o_result
+ func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
+ fi
+ exit $EXIT_SUCCESS
+ ;;
+
+ *)
+ # Figure out destination file name, if it wasn't already specified.
+ if test -n "$destname"; then
+ destfile="$destdir/$destname"
+ else
+ func_basename "$file"
+ destfile="$func_basename_result"
+ destfile="$destdir/$destfile"
+ fi
+
+ # If the file is missing, and there is a .exe on the end, strip it
+ # because it is most likely a libtool script we actually want to
+ # install
+ stripped_ext=""
+ case $file in
+ *.exe)
+ if test ! -f "$file"; then
+ func_stripname '' '.exe' "$file"
+ file=$func_stripname_result
+ stripped_ext=".exe"
+ fi
+ ;;
+ esac
+
+ # Do a test to see if this is really a libtool program.
+ case $host in
+ *cygwin* | *mingw*)
+ if func_ltwrapper_executable_p "$file"; then
+ func_ltwrapper_scriptname "$file"
+ wrapper=$func_ltwrapper_scriptname_result
+ else
+ func_stripname '' '.exe' "$file"
+ wrapper=$func_stripname_result
+ fi
+ ;;
+ *)
+ wrapper=$file
+ ;;
+ esac
+ if func_ltwrapper_script_p "$wrapper"; then
+ notinst_deplibs=
+ relink_command=
+
+ func_source "$wrapper"
+
+ # Check the variables that should have been set.
+ test -z "$generated_by_libtool_version" && \
+ func_fatal_error "invalid libtool wrapper script \`$wrapper'"
+
+ finalize=yes
+ for lib in $notinst_deplibs; do
+ # Check to see that each library is installed.
+ libdir=
+ if test -f "$lib"; then
+ func_source "$lib"
+ fi
+ libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
+ if test -n "$libdir" && test ! -f "$libfile"; then
+ func_warning "\`$lib' has not been installed in \`$libdir'"
+ finalize=no
+ fi
+ done
+
+ relink_command=
+ func_source "$wrapper"
+
+ outputname=
+ if test "$fast_install" = no && test -n "$relink_command"; then
+ $opt_dry_run || {
+ if test "$finalize" = yes; then
+ tmpdir=`func_mktempdir`
+ func_basename "$file$stripped_ext"
+ file="$func_basename_result"
+ outputname="$tmpdir/$file"
+ # Replace the output file specification.
+ relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
+
+ $opt_silent || {
+ func_quote_for_expand "$relink_command"
+ eval "func_echo $func_quote_for_expand_result"
+ }
+ if eval "$relink_command"; then :
+ else
+ func_error "error: relink \`$file' with the above command before installing it"
+ $opt_dry_run || ${RM}r "$tmpdir"
+ continue
+ fi
+ file="$outputname"
+ else
+ func_warning "cannot relink \`$file'"
+ fi
+ }
+ else
+ # Install the binary that we compiled earlier.
+ file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
+ fi
+ fi
+
+ # remove .exe since cygwin /usr/bin/install will append another
+ # one anyway
+ case $install_prog,$host in
+ */usr/bin/install*,*cygwin*)
+ case $file:$destfile in
+ *.exe:*.exe)
+ # this is ok
+ ;;
+ *.exe:*)
+ destfile=$destfile.exe
+ ;;
+ *:*.exe)
+ func_stripname '' '.exe' "$destfile"
+ destfile=$func_stripname_result
+ ;;
+ esac
+ ;;
+ esac
+ func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
+ $opt_dry_run || if test -n "$outputname"; then
+ ${RM}r "$tmpdir"
+ fi
+ ;;
+ esac
+ done
+
+ for file in $staticlibs; do
+ func_basename "$file"
+ name="$func_basename_result"
+
+ # Set up the ranlib parameters.
+ oldlib="$destdir/$name"
+ func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+ tool_oldlib=$func_to_tool_file_result
+
+ func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
+
+ if test -n "$stripme" && test -n "$old_striplib"; then
+ func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
+ fi
+
+ # Do each command in the postinstall commands.
+ func_execute_cmds "$old_postinstall_cmds" 'exit $?'
+ done
+
+ test -n "$future_libdirs" && \
+ func_warning "remember to run \`$progname --finish$future_libdirs'"
+
+ if test -n "$current_libdirs"; then
+ # Maybe just do a dry run.
+ $opt_dry_run && current_libdirs=" -n$current_libdirs"
+ exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
+ else
+ exit $EXIT_SUCCESS
+ fi
+}
+
+test "$opt_mode" = install && func_mode_install ${1+"$@"}
+
+
+# func_generate_dlsyms outputname originator pic_p
+# Extract symbols from dlprefiles and create ${outputname}S.o with
+# a dlpreopen symbol table.
+func_generate_dlsyms ()
+{
+ $opt_debug
+ my_outputname="$1"
+ my_originator="$2"
+ my_pic_p="${3-no}"
+ my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
+ my_dlsyms=
+
+ if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+ if test -n "$NM" && test -n "$global_symbol_pipe"; then
+ my_dlsyms="${my_outputname}S.c"
+ else
+ func_error "not configured to extract global symbols from dlpreopened files"
+ fi
+ fi
+
+ if test -n "$my_dlsyms"; then
+ case $my_dlsyms in
+ "") ;;
+ *.c)
+ # Discover the nlist of each of the dlfiles.
+ nlist="$output_objdir/${my_outputname}.nm"
+
+ func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
+
+ # Parse the name list into a source file.
+ func_verbose "creating $output_objdir/$my_dlsyms"
+
+ $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
+/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
+/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
+#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
+#endif
+
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+/* DATA imports from DLLs on WIN32 con't be const, because runtime
+ relocations are performed -- see ld's documentation on pseudo-relocs. */
+# define LT_DLSYM_CONST
+#elif defined(__osf__)
+/* This system does not cope well with relocations in const data. */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+/* External symbol declarations for the compiler. */\
+"
+
+ if test "$dlself" = yes; then
+ func_verbose "generating symbol list for \`$output'"
+
+ $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
+
+ # Add our own program objects to the symbol list.
+ progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+ for progfile in $progfiles; do
+ func_to_tool_file "$progfile" func_convert_file_msys_to_w32
+ func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
+ $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
+ done
+
+ if test -n "$exclude_expsyms"; then
+ $opt_dry_run || {
+ eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+ eval '$MV "$nlist"T "$nlist"'
+ }
+ fi
+
+ if test -n "$export_symbols_regex"; then
+ $opt_dry_run || {
+ eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+ eval '$MV "$nlist"T "$nlist"'
+ }
+ fi
+
+ # Prepare the list of exported symbols
+ if test -z "$export_symbols"; then
+ export_symbols="$output_objdir/$outputname.exp"
+ $opt_dry_run || {
+ $RM $export_symbols
+ eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
+ case $host in
+ *cygwin* | *mingw* | *cegcc* )
+ eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+ eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+ ;;
+ esac
+ }
+ else
+ $opt_dry_run || {
+ eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+ eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+ eval '$MV "$nlist"T "$nlist"'
+ case $host in
+ *cygwin* | *mingw* | *cegcc* )
+ eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+ eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+ ;;
+ esac
+ }
+ fi
+ fi
+
+ for dlprefile in $dlprefiles; do
+ func_verbose "extracting global C symbols from \`$dlprefile'"
+ func_basename "$dlprefile"
+ name="$func_basename_result"
+ case $host in
+ *cygwin* | *mingw* | *cegcc* )
+ # if an import library, we need to obtain dlname
+ if func_win32_import_lib_p "$dlprefile"; then
+ func_tr_sh "$dlprefile"
+ eval "curr_lafile=\$libfile_$func_tr_sh_result"
+ dlprefile_dlbasename=""
+ if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
+ # Use subshell, to avoid clobbering current variable values
+ dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
+ if test -n "$dlprefile_dlname" ; then
+ func_basename "$dlprefile_dlname"
+ dlprefile_dlbasename="$func_basename_result"
+ else
+ # no lafile. user explicitly requested -dlpreopen <import library>.
+ $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 >/dev/null 2>&1; then
+ sort -k 3
+ else
+ sort +2
+ fi |
+ uniq > "$nlist"S; then
+ :
+ else
+ $GREP -v "^: " < "$nlist" > "$nlist"S
+ fi
+
+ if test -f "$nlist"S; then
+ eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
+ else
+ echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
+ fi
+
+ echo >> "$output_objdir/$my_dlsyms" "\
+
+/* The mapping between symbol names and symbols. */
+typedef struct {
+ const char *name;
+ void *address;
+} lt_dlsymlist;
+extern LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols[];
+LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols[] =
+{\
+ { \"$my_originator\", (void *) 0 },"
+
+ case $need_lib_prefix in
+ no)
+ eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
+ ;;
+ *)
+ eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
+ ;;
+ esac
+ echo >> "$output_objdir/$my_dlsyms" "\
+ {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+ return lt_${my_prefix}_LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+ } # !$opt_dry_run
+
+ pic_flag_for_symtable=
+ case "$compile_command " in
+ *" -static "*) ;;
+ *)
+ case $host in
+ # compiling the symbol table file with pic_flag works around
+ # a FreeBSD bug that causes programs to crash when -lm is
+ # linked before any other PIC object. But we must not use
+ # pic_flag when linking with -static. The problem exists in
+ # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+ *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+ pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
+ *-*-hpux*)
+ pic_flag_for_symtable=" $pic_flag" ;;
+ *)
+ if test "X$my_pic_p" != Xno; then
+ pic_flag_for_symtable=" $pic_flag"
+ fi
+ ;;
+ esac
+ ;;
+ esac
+ symtab_cflags=
+ for arg in $LTCFLAGS; do
+ case $arg in
+ -pie | -fpie | -fPIE) ;;
+ *) func_append symtab_cflags " $arg" ;;
+ esac
+ done
+
+ # Now compile the dynamic symbol file.
+ func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
+
+ # Clean up the generated files.
+ func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
+
+ # Transform the symbol file into the correct name.
+ symfileobj="$output_objdir/${my_outputname}S.$objext"
+ case $host in
+ *cygwin* | *mingw* | *cegcc* )
+ if test -f "$output_objdir/$my_outputname.def"; then
+ compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+ finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+ else
+ compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+ finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+ fi
+ ;;
+ *)
+ compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+ finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+ ;;
+ esac
+ ;;
+ *)
+ func_fatal_error "unknown suffix for \`$my_dlsyms'"
+ ;;
+ esac
+ else
+ # We keep going just in case the user didn't refer to
+ # lt_preloaded_symbols. The linker will fail if global_symbol_pipe
+ # really was required.
+
+ # Nullify the symbol file.
+ compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
+ finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
+ fi
+}
+
+# func_win32_libid arg
+# return the library type of file 'arg'
+#
+# Need a lot of goo to handle *both* DLLs and import libs
+# Has to be a shell function in order to 'eat' the argument
+# that is supplied when $file_magic_command is called.
+# Despite the name, also deal with 64 bit binaries.
+func_win32_libid ()
+{
+ $opt_debug
+ win32_libid_type="unknown"
+ win32_fileres=`file -L $1 2>/dev/null`
+ case $win32_fileres in
+ *ar\ archive\ import\ library*) # definitely import
+ win32_libid_type="x86 archive import"
+ ;;
+ *ar\ archive*) # could be an import, or static
+ # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
+ if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
+ $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
+ func_to_tool_file "$1" func_convert_file_msys_to_w32
+ win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
+ $SED -n -e '
+ 1,100{
+ / I /{
+ s,.*,import,
+ p
+ q
+ }
+ }'`
+ case $win32_nmres in
+ import*) win32_libid_type="x86 archive import";;
+ *) win32_libid_type="x86 archive static";;
+ esac
+ fi
+ ;;
+ *DLL*)
+ win32_libid_type="x86 DLL"
+ ;;
+ *executable*) # but shell scripts are "executable" too...
+ case $win32_fileres in
+ *MS\ Windows\ PE\ Intel*)
+ win32_libid_type="x86 DLL"
+ ;;
+ esac
+ ;;
+ esac
+ $ECHO "$win32_libid_type"
+}
+
+# func_cygming_dll_for_implib ARG
+#
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+# Invoked by eval'ing the libtool variable
+# $sharedlib_from_linklib_cmd
+# Result is available in the variable
+# $sharedlib_from_linklib_result
+func_cygming_dll_for_implib ()
+{
+ $opt_debug
+ sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
+}
+
+# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
+#
+# The is the core of a fallback implementation of a
+# platform-specific function to extract the name of the
+# DLL associated with the specified import library LIBNAME.
+#
+# SECTION_NAME is either .idata$6 or .idata$7, depending
+# on the platform and compiler that created the implib.
+#
+# Echos the name of the DLL associated with the
+# specified import library.
+func_cygming_dll_for_implib_fallback_core ()
+{
+ $opt_debug
+ match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
+ $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
+ $SED '/^Contents of section '"$match_literal"':/{
+ # Place marker at beginning of archive member dllname section
+ s/.*/====MARK====/
+ p
+ d
+ }
+ # These lines can sometimes be longer than 43 characters, but
+ # are always uninteresting
+ /:[ ]*file format pe[i]\{,1\}-/d
+ /^In archive [^:]*:/d
+ # Ensure marker is printed
+ /^====MARK====/p
+ # Remove all lines with less than 43 characters
+ /^.\{43\}/!d
+ # From remaining lines, remove first 43 characters
+ s/^.\{43\}//' |
+ $SED -n '
+ # Join marker and all lines until next marker into a single line
+ /^====MARK====/ b para
+ H
+ $ b para
+ b
+ :para
+ x
+ s/\n//g
+ # Remove the marker
+ s/^====MARK====//
+ # Remove trailing dots and whitespace
+ s/[\. \t]*$//
+ # Print
+ /./p' |
+ # we now have a list, one entry per line, of the stringified
+ # contents of the appropriate section of all members of the
+ # archive which possess that section. Heuristic: eliminate
+ # all those which have a first or second character that is
+ # a '.' (that is, objdump's representation of an unprintable
+ # character.) This should work for all archives with less than
+ # 0x302f exports -- but will fail for DLLs whose name actually
+ # begins with a literal '.' or a single character followed by
+ # a '.'.
+ #
+ # Of those that remain, print the first one.
+ $SED -e '/^\./d;/^.\./d;q'
+}
+
+# func_cygming_gnu_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is a GNU/binutils-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_gnu_implib_p ()
+{
+ $opt_debug
+ func_to_tool_file "$1" func_convert_file_msys_to_w32
+ func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
+ test -n "$func_cygming_gnu_implib_tmp"
+}
+
+# func_cygming_ms_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is an MS-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_ms_implib_p ()
+{
+ $opt_debug
+ func_to_tool_file "$1" func_convert_file_msys_to_w32
+ func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
+ test -n "$func_cygming_ms_implib_tmp"
+}
+
+# func_cygming_dll_for_implib_fallback ARG
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+#
+# This fallback implementation is for use when $DLLTOOL
+# does not support the --identify-strict option.
+# Invoked by eval'ing the libtool variable
+# $sharedlib_from_linklib_cmd
+# Result is available in the variable
+# $sharedlib_from_linklib_result
+func_cygming_dll_for_implib_fallback ()
+{
+ $opt_debug
+ if func_cygming_gnu_implib_p "$1" ; then
+ # binutils import library
+ sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
+ elif func_cygming_ms_implib_p "$1" ; then
+ # ms-generated import library
+ sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
+ else
+ # unknown
+ sharedlib_from_linklib_result=""
+ fi
+}
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+ $opt_debug
+ f_ex_an_ar_dir="$1"; shift
+ f_ex_an_ar_oldlib="$1"
+ if test "$lock_old_archive_extraction" = yes; then
+ lockfile=$f_ex_an_ar_oldlib.lock
+ until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+ func_echo "Waiting for $lockfile to be removed"
+ sleep 2
+ done
+ fi
+ func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
+ 'stat=$?; rm -f "$lockfile"; exit $stat'
+ if test "$lock_old_archive_extraction" = yes; then
+ $opt_dry_run || rm -f "$lockfile"
+ fi
+ if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+ :
+ else
+ func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
+ fi
+}
+
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+ $opt_debug
+ my_gentop="$1"; shift
+ my_oldlibs=${1+"$@"}
+ my_oldobjs=""
+ my_xlib=""
+ my_xabs=""
+ my_xdir=""
+
+ for my_xlib in $my_oldlibs; do
+ # Extract the objects.
+ case $my_xlib in
+ [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
+ *) my_xabs=`pwd`"/$my_xlib" ;;
+ esac
+ func_basename "$my_xlib"
+ my_xlib="$func_basename_result"
+ my_xlib_u=$my_xlib
+ while :; do
+ case " $extracted_archives " in
+ *" $my_xlib_u "*)
+ func_arith $extracted_serial + 1
+ extracted_serial=$func_arith_result
+ my_xlib_u=lt$extracted_serial-$my_xlib ;;
+ *) break ;;
+ esac
+ done
+ extracted_archives="$extracted_archives $my_xlib_u"
+ my_xdir="$my_gentop/$my_xlib_u"
+
+ func_mkdir_p "$my_xdir"
+
+ case $host in
+ *-darwin*)
+ func_verbose "Extracting $my_xabs"
+ # Do not bother doing anything if just a dry run
+ $opt_dry_run || {
+ darwin_orig_dir=`pwd`
+ cd $my_xdir || exit $?
+ darwin_archive=$my_xabs
+ darwin_curdir=`pwd`
+ darwin_base_archive=`basename "$darwin_archive"`
+ darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
+ if test -n "$darwin_arches"; then
+ darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
+ darwin_arch=
+ func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
+ for darwin_arch in $darwin_arches ; do
+ func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+ $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
+ cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
+ func_extract_an_archive "`pwd`" "${darwin_base_archive}"
+ cd "$darwin_curdir"
+ $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
+ done # $darwin_arches
+ ## Okay now we've a bunch of thin objects, gotta fatten them up :)
+ darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
+ darwin_file=
+ darwin_files=
+ for darwin_file in $darwin_filelist; do
+ darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
+ $LIPO -create -output "$darwin_file" $darwin_files
+ done # $darwin_filelist
+ $RM -rf unfat-$$
+ cd "$darwin_orig_dir"
+ else
+ cd $darwin_orig_dir
+ func_extract_an_archive "$my_xdir" "$my_xabs"
+ fi # $darwin_arches
+ } # !$opt_dry_run
+ ;;
+ *)
+ func_extract_an_archive "$my_xdir" "$my_xabs"
+ ;;
+ esac
+ my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
+ done
+
+ func_extract_archives_result="$my_oldobjs"
+}
+
+
+# func_emit_wrapper [arg=no]
+#
+# Emit a libtool wrapper script on stdout.
+# Don't directly open a file because we may want to
+# incorporate the script contents within a cygwin/mingw
+# wrapper executable. Must ONLY be called from within
+# func_mode_link because it depends on a number of variables
+# set therein.
+#
+# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
+# variable will take. If 'yes', then the emitted script
+# will assume that the directory in which it is stored is
+# the $objdir directory. This is a cygwin/mingw-specific
+# behavior.
+func_emit_wrapper ()
+{
+ func_emit_wrapper_arg1=${1-no}
+
+ $ECHO "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting. It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='$sed_quote_subst'
+
+# Be Bourne compatible
+if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
+ emulate sh
+ NULLCMD=:
+ # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
+ # is contrary to our usage. Disable this feature.
+ alias -g '\${1+\"\$@\"}'='\"\$@\"'
+ setopt NO_GLOB_SUBST
+else
+ case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+ # install mode needs the following variables:
+ generated_by_libtool_version='$macro_version'
+ notinst_deplibs='$notinst_deplibs'
+else
+ # When we are sourced in execute mode, \$file and \$ECHO are already set.
+ if test \"\$libtool_execute_magic\" != \"$magic\"; then
+ file=\"\$0\""
+
+ qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
+ $ECHO "\
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+ eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+ ECHO=\"$qECHO\"
+ fi
+
+# Very basic option parsing. These options are (a) specific to
+# the libtool wrapper, (b) are identical between the wrapper
+# /script/ and the wrapper /executable/ which is used only on
+# windows platforms, and (c) all begin with the string "--lt-"
+# (application programs are unlikely to have options which match
+# this pattern).
+#
+# There are only two supported options: --lt-debug and
+# --lt-dump-script. There is, deliberately, no --lt-help.
+#
+# The first argument to this parsing function should be the
+# script's $0 value, followed by "$@".
+lt_option_debug=
+func_parse_lt_options ()
+{
+ lt_script_arg0=\$0
+ shift
+ for lt_opt
+ do
+ case \"\$lt_opt\" in
+ --lt-debug) lt_option_debug=1 ;;
+ --lt-dump-script)
+ lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
+ test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
+ lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
+ cat \"\$lt_dump_D/\$lt_dump_F\"
+ exit 0
+ ;;
+ --lt-*)
+ \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
+ exit 1
+ ;;
+ esac
+ done
+
+ # Print the debug banner immediately:
+ if test -n \"\$lt_option_debug\"; then
+ echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
+ fi
+}
+
+# Used when --lt-debug. Prints its arguments to stdout
+# (redirection is the responsibility of the caller)
+func_lt_dump_args ()
+{
+ lt_dump_args_N=1;
+ for lt_arg
+ do
+ \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
+ lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
+ done
+}
+
+# Core function for launching the target application
+func_exec_program_core ()
+{
+"
+ case $host in
+ # Backslashes separate directories on plain windows
+ *-*-mingw | *-*-os2* | *-cegcc*)
+ $ECHO "\
+ if test -n \"\$lt_option_debug\"; then
+ \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
+ func_lt_dump_args \${1+\"\$@\"} 1>&2
+ fi
+ exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+ ;;
+
+ *)
+ $ECHO "\
+ if test -n \"\$lt_option_debug\"; then
+ \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
+ func_lt_dump_args \${1+\"\$@\"} 1>&2
+ fi
+ exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+ ;;
+ esac
+ $ECHO "\
+ \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
+ exit 1
+}
+
+# A function to encapsulate launching the target application
+# Strips options in the --lt-* namespace from \$@ and
+# launches target application with the remaining arguments.
+func_exec_program ()
+{
+ case \" \$* \" in
+ *\\ --lt-*)
+ for lt_wr_arg
+ do
+ case \$lt_wr_arg in
+ --lt-*) ;;
+ *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
+ esac
+ shift
+ done ;;
+ esac
+ func_exec_program_core \${1+\"\$@\"}
+}
+
+ # Parse options
+ func_parse_lt_options \"\$0\" \${1+\"\$@\"}
+
+ # Find the directory that this script lives in.
+ thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
+ test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+ # Follow symbolic links until we get to the real thisdir.
+ file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
+ while test -n \"\$file\"; do
+ destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
+
+ # If there was a directory component, then change thisdir.
+ if test \"x\$destdir\" != \"x\$file\"; then
+ case \"\$destdir\" in
+ [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
+ *) thisdir=\"\$thisdir/\$destdir\" ;;
+ esac
+ fi
+
+ file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
+ file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
+ done
+
+ # Usually 'no', except on cygwin/mingw when embedded into
+ # the cwrapper.
+ WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
+ if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
+ # special case for '.'
+ if test \"\$thisdir\" = \".\"; then
+ thisdir=\`pwd\`
+ fi
+ # remove .libs from thisdir
+ case \"\$thisdir\" in
+ *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
+ $objdir ) thisdir=. ;;
+ esac
+ fi
+
+ # Try to get the absolute directory name.
+ absdir=\`cd \"\$thisdir\" && pwd\`
+ test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+ if test "$fast_install" = yes; then
+ $ECHO "\
+ program=lt-'$outputname'$exeext
+ progdir=\"\$thisdir/$objdir\"
+
+ if test ! -f \"\$progdir/\$program\" ||
+ { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
+ test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+ file=\"\$\$-\$program\"
+
+ if test ! -d \"\$progdir\"; then
+ $MKDIR \"\$progdir\"
+ else
+ $RM \"\$progdir/\$file\"
+ fi"
+
+ $ECHO "\
+
+ # relink executable if necessary
+ if test -n \"\$relink_command\"; then
+ if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+ else
+ $ECHO \"\$relink_command_output\" >&2
+ $RM \"\$progdir/\$file\"
+ exit 1
+ fi
+ fi
+
+ $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+ { $RM \"\$progdir/\$program\";
+ $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+ $RM \"\$progdir/\$file\"
+ fi"
+ else
+ $ECHO "\
+ program='$outputname'
+ progdir=\"\$thisdir/$objdir\"
+"
+ fi
+
+ $ECHO "\
+
+ if test -f \"\$progdir/\$program\"; then"
+
+ # fixup the dll searchpath if we need to.
+ #
+ # Fix the DLL searchpath if we need to. Do this before prepending
+ # to shlibpath, because on Windows, both are PATH and uninstalled
+ # libraries must come first.
+ if test -n "$dllsearchpath"; then
+ $ECHO "\
+ # Add the dll search path components to the executable PATH
+ PATH=$dllsearchpath:\$PATH
+"
+ fi
+
+ # Export our shlibpath_var if we have one.
+ if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+ $ECHO "\
+ # Add our own library path to $shlibpath_var
+ $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+ # Some systems cannot cope with colon-terminated $shlibpath_var
+ # The second colon is a workaround for a bug in BeOS R4 sed
+ $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
+
+ export $shlibpath_var
+"
+ fi
+
+ $ECHO "\
+ if test \"\$libtool_execute_magic\" != \"$magic\"; then
+ # Run the actual program with our arguments.
+ func_exec_program \${1+\"\$@\"}
+ fi
+ else
+ # The program doesn't exist.
+ \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
+ \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
+ \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
+ exit 1
+ fi
+fi\
+"
+}
+
+
+# func_emit_cwrapperexe_src
+# emit the source code for a wrapper executable on stdout
+# Must ONLY be called from within func_mode_link because
+# it depends on a number of variable set therein.
+func_emit_cwrapperexe_src ()
+{
+ cat <<EOF
+
+/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+ Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+
+ The $output program cannot be directly executed until all the libtool
+ libraries that it depends on are installed.
+
+ This wrapper executable should never be moved out of the build directory.
+ If it is, it will not operate correctly.
+*/
+EOF
+ cat <<"EOF"
+#ifdef _MSC_VER
+# define _CRT_SECURE_NO_DEPRECATE 1
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _MSC_VER
+# include <direct.h>
+# include <process.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <stdint.h>
+# ifdef __CYGWIN__
+# include <io.h>
+# endif
+#endif
+#include <malloc.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+/* declarations of non-ANSI functions */
+#if defined(__MINGW32__)
+# ifdef __STRICT_ANSI__
+int _putenv (const char *);
+# endif
+#elif defined(__CYGWIN__)
+# ifdef __STRICT_ANSI__
+char *realpath (const char *, char *);
+int putenv (char *);
+int setenv (const char *, const char *, int);
+# endif
+/* #elif defined (other platforms) ... */
+#endif
+
+/* portability defines, excluding path handling macros */
+#if defined(_MSC_VER)
+# define setmode _setmode
+# define stat _stat
+# define chmod _chmod
+# define getcwd _getcwd
+# define putenv _putenv
+# define S_IXUSR _S_IEXEC
+# ifndef _INTPTR_T_DEFINED
+# define _INTPTR_T_DEFINED
+# define intptr_t int
+# endif
+#elif defined(__MINGW32__)
+# define setmode _setmode
+# define stat _stat
+# define chmod _chmod
+# define getcwd _getcwd
+# define putenv _putenv
+#elif defined(__CYGWIN__)
+# define HAVE_SETENV
+# define FOPEN_WB "wb"
+/* #elif defined (other platforms) ... */
+#endif
+
+#if defined(PATH_MAX)
+# define LT_PATHMAX PATH_MAX
+#elif defined(MAXPATHLEN)
+# define LT_PATHMAX MAXPATHLEN
+#else
+# define LT_PATHMAX 1024
+#endif
+
+#ifndef S_IXOTH
+# define S_IXOTH 0
+#endif
+#ifndef S_IXGRP
+# define S_IXGRP 0
+#endif
+
+/* path handling portability macros */
+#ifndef DIR_SEPARATOR
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
+#endif
+
+#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
+ defined (__OS2__)
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# define FOPEN_WB "wb"
+# ifndef DIR_SEPARATOR_2
+# define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+# define PATH_SEPARATOR_2 ';'
+# endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else /* DIR_SEPARATOR_2 */
+# define IS_DIR_SEPARATOR(ch) \
+ (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif /* DIR_SEPARATOR_2 */
+
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
+#ifndef FOPEN_WB
+# define FOPEN_WB "w"
+#endif
+#ifndef _O_BINARY
+# define _O_BINARY 0
+#endif
+
+#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type)))
+#define XFREE(stale) do { \
+ if (stale) { free ((void *) stale); stale = 0; } \
+} while (0)
+
+#if defined(LT_DEBUGWRAPPER)
+static int lt_debug = 1;
+#else
+static int lt_debug = 0;
+#endif
+
+const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
+
+void *xmalloc (size_t num);
+char *xstrdup (const char *string);
+const char *base_name (const char *name);
+char *find_executable (const char *wrapper);
+char *chase_symlinks (const char *pathspec);
+int make_executable (const char *path);
+int check_executable (const char *path);
+char *strendzap (char *str, const char *pat);
+void lt_debugprintf (const char *file, int line, const char *fmt, ...);
+void lt_fatal (const char *file, int line, const char *message, ...);
+static const char *nonnull (const char *s);
+static const char *nonempty (const char *s);
+void lt_setenv (const char *name, const char *value);
+char *lt_extend_str (const char *orig_value, const char *add, int to_end);
+void lt_update_exe_path (const char *name, const char *value);
+void lt_update_lib_path (const char *name, const char *value);
+char **prepare_spawn (char **argv);
+void lt_dump_script (FILE *f);
+EOF
+
+ cat <<EOF
+volatile const char * MAGIC_EXE = "$magic_exe";
+const char * LIB_PATH_VARNAME = "$shlibpath_var";
+EOF
+
+ if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+ func_to_host_path "$temp_rpath"
+ cat <<EOF
+const char * LIB_PATH_VALUE = "$func_to_host_path_result";
+EOF
+ else
+ cat <<"EOF"
+const char * LIB_PATH_VALUE = "";
+EOF
+ fi
+
+ if test -n "$dllsearchpath"; then
+ func_to_host_path "$dllsearchpath:"
+ cat <<EOF
+const char * EXE_PATH_VARNAME = "PATH";
+const char * EXE_PATH_VALUE = "$func_to_host_path_result";
+EOF
+ else
+ cat <<"EOF"
+const char * EXE_PATH_VARNAME = "";
+const char * EXE_PATH_VALUE = "";
+EOF
+ fi
+
+ if test "$fast_install" = yes; then
+ cat <<EOF
+const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
+EOF
+ else
+ cat <<EOF
+const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
+EOF
+ fi
+
+
+ cat <<"EOF"
+
+#define LTWRAPPER_OPTION_PREFIX "--lt-"
+
+static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
+static const char *dumpscript_opt = LTWRAPPER_OPTION_PREFIX "dump-script";
+static const char *debug_opt = LTWRAPPER_OPTION_PREFIX "debug";
+
+int
+main (int argc, char *argv[])
+{
+ char **newargz;
+ int newargc;
+ char *tmp_pathspec;
+ char *actual_cwrapper_path;
+ char *actual_cwrapper_name;
+ char *target_name;
+ char *lt_argv_zero;
+ intptr_t rval = 127;
+
+ int i;
+
+ program_name = (char *) xstrdup (base_name (argv[0]));
+ newargz = XMALLOC (char *, argc + 1);
+
+ /* very simple arg parsing; don't want to rely on getopt
+ * also, copy all non cwrapper options to newargz, except
+ * argz[0], which is handled differently
+ */
+ newargc=0;
+ for (i = 1; i < argc; i++)
+ {
+ if (strcmp (argv[i], dumpscript_opt) == 0)
+ {
+EOF
+ case "$host" in
+ *mingw* | *cygwin* )
+ # make stdout use "unix" line endings
+ echo " setmode(1,_O_BINARY);"
+ ;;
+ esac
+
+ cat <<"EOF"
+ lt_dump_script (stdout);
+ return 0;
+ }
+ if (strcmp (argv[i], debug_opt) == 0)
+ {
+ lt_debug = 1;
+ continue;
+ }
+ if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
+ {
+ /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
+ namespace, but it is not one of the ones we know about and
+ have already dealt with, above (inluding dump-script), then
+ report an error. Otherwise, targets might begin to believe
+ they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
+ namespace. The first time any user complains about this, we'll
+ need to make LTWRAPPER_OPTION_PREFIX a configure-time option
+ or a configure.ac-settable value.
+ */
+ lt_fatal (__FILE__, __LINE__,
+ "unrecognized %s option: '%s'",
+ ltwrapper_option_prefix, argv[i]);
+ }
+ /* otherwise ... */
+ newargz[++newargc] = xstrdup (argv[i]);
+ }
+ newargz[++newargc] = NULL;
+
+EOF
+ cat <<EOF
+ /* The GNU banner must be the first non-error debug message */
+ lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
+EOF
+ cat <<"EOF"
+ lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
+ lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
+
+ tmp_pathspec = find_executable (argv[0]);
+ if (tmp_pathspec == NULL)
+ lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
+ lt_debugprintf (__FILE__, __LINE__,
+ "(main) found exe (before symlink chase) at: %s\n",
+ tmp_pathspec);
+
+ actual_cwrapper_path = chase_symlinks (tmp_pathspec);
+ lt_debugprintf (__FILE__, __LINE__,
+ "(main) found exe (after symlink chase) at: %s\n",
+ actual_cwrapper_path);
+ XFREE (tmp_pathspec);
+
+ actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
+ strendzap (actual_cwrapper_path, actual_cwrapper_name);
+
+ /* wrapper name transforms */
+ strendzap (actual_cwrapper_name, ".exe");
+ tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
+ XFREE (actual_cwrapper_name);
+ actual_cwrapper_name = tmp_pathspec;
+ tmp_pathspec = 0;
+
+ /* target_name transforms -- use actual target program name; might have lt- prefix */
+ target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
+ strendzap (target_name, ".exe");
+ tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
+ XFREE (target_name);
+ target_name = tmp_pathspec;
+ tmp_pathspec = 0;
+
+ lt_debugprintf (__FILE__, __LINE__,
+ "(main) libtool target name: %s\n",
+ target_name);
+EOF
+
+ cat <<EOF
+ newargz[0] =
+ XMALLOC (char, (strlen (actual_cwrapper_path) +
+ strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
+ strcpy (newargz[0], actual_cwrapper_path);
+ strcat (newargz[0], "$objdir");
+ strcat (newargz[0], "/");
+EOF
+
+ cat <<"EOF"
+ /* stop here, and copy so we don't have to do this twice */
+ tmp_pathspec = xstrdup (newargz[0]);
+
+ /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
+ strcat (newargz[0], actual_cwrapper_name);
+
+ /* DO want the lt- prefix here if it exists, so use target_name */
+ lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
+ XFREE (tmp_pathspec);
+ tmp_pathspec = NULL;
+EOF
+
+ case $host_os in
+ mingw*)
+ cat <<"EOF"
+ {
+ char* p;
+ while ((p = strchr (newargz[0], '\\')) != NULL)
+ {
+ *p = '/';
+ }
+ while ((p = strchr (lt_argv_zero, '\\')) != NULL)
+ {
+ *p = '/';
+ }
+ }
+EOF
+ ;;
+ esac
+
+ cat <<"EOF"
+ XFREE (target_name);
+ XFREE (actual_cwrapper_path);
+ XFREE (actual_cwrapper_name);
+
+ lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
+ lt_setenv ("DUALCASE", "1"); /* for MSK sh */
+ /* Update the DLL searchpath. EXE_PATH_VALUE ($dllsearchpath) must
+ be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
+ because on Windows, both *_VARNAMEs are PATH but uninstalled
+ libraries must come first. */
+ lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
+ lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
+
+ lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
+ nonnull (lt_argv_zero));
+ for (i = 0; i < newargc; i++)
+ {
+ lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
+ i, nonnull (newargz[i]));
+ }
+
+EOF
+
+ case $host_os in
+ mingw*)
+ cat <<"EOF"
+ /* execv doesn't actually work on mingw as expected on unix */
+ newargz = prepare_spawn (newargz);
+ rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
+ if (rval == -1)
+ {
+ /* failed to start process */
+ lt_debugprintf (__FILE__, __LINE__,
+ "(main) failed to launch target \"%s\": %s\n",
+ lt_argv_zero, nonnull (strerror (errno)));
+ return 127;
+ }
+ return rval;
+EOF
+ ;;
+ *)
+ cat <<"EOF"
+ execv (lt_argv_zero, newargz);
+ return rval; /* =127, but avoids unused variable warning */
+EOF
+ ;;
+ esac
+
+ cat <<"EOF"
+}
+
+void *
+xmalloc (size_t num)
+{
+ void *p = (void *) malloc (num);
+ if (!p)
+ lt_fatal (__FILE__, __LINE__, "memory exhausted");
+
+ return p;
+}
+
+char *
+xstrdup (const char *string)
+{
+ return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
+ string) : NULL;
+}
+
+const char *
+base_name (const char *name)
+{
+ const char *base;
+
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+ /* Skip over the disk name in MSDOS pathnames. */
+ if (isalpha ((unsigned char) name[0]) && name[1] == ':')
+ name += 2;
+#endif
+
+ for (base = name; *name; name++)
+ if (IS_DIR_SEPARATOR (*name))
+ base = name + 1;
+ return base;
+}
+
+int
+check_executable (const char *path)
+{
+ struct stat st;
+
+ lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
+ nonempty (path));
+ if ((!path) || (!*path))
+ return 0;
+
+ if ((stat (path, &st) >= 0)
+ && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
+ return 1;
+ else
+ return 0;
+}
+
+int
+make_executable (const char *path)
+{
+ int rval = 0;
+ struct stat st;
+
+ lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
+ nonempty (path));
+ if ((!path) || (!*path))
+ return 0;
+
+ if (stat (path, &st) >= 0)
+ {
+ rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
+ }
+ return rval;
+}
+
+/* Searches for the full path of the wrapper. Returns
+ newly allocated full path name if found, NULL otherwise
+ Does not chase symlinks, even on platforms that support them.
+*/
+char *
+find_executable (const char *wrapper)
+{
+ int has_slash = 0;
+ const char *p;
+ const char *p_next;
+ /* static buffer for getcwd */
+ char tmp[LT_PATHMAX + 1];
+ int tmp_len;
+ char *concat_name;
+
+ lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
+ nonempty (wrapper));
+
+ if ((wrapper == NULL) || (*wrapper == '\0'))
+ return NULL;
+
+ /* Absolute path? */
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+ if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
+ {
+ concat_name = xstrdup (wrapper);
+ if (check_executable (concat_name))
+ return concat_name;
+ XFREE (concat_name);
+ }
+ else
+ {
+#endif
+ if (IS_DIR_SEPARATOR (wrapper[0]))
+ {
+ concat_name = xstrdup (wrapper);
+ if (check_executable (concat_name))
+ return concat_name;
+ XFREE (concat_name);
+ }
+#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+ }
+#endif
+
+ for (p = wrapper; *p; p++)
+ if (*p == '/')
+ {
+ has_slash = 1;
+ break;
+ }
+ if (!has_slash)
+ {
+ /* no slashes; search PATH */
+ const char *path = getenv ("PATH");
+ if (path != NULL)
+ {
+ for (p = path; *p; p = p_next)
+ {
+ const char *q;
+ size_t p_len;
+ for (q = p; *q; q++)
+ if (IS_PATH_SEPARATOR (*q))
+ break;
+ p_len = q - p;
+ p_next = (*q == '\0' ? q : q + 1);
+ if (p_len == 0)
+ {
+ /* empty path: current directory */
+ if (getcwd (tmp, LT_PATHMAX) == NULL)
+ lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+ nonnull (strerror (errno)));
+ tmp_len = strlen (tmp);
+ concat_name =
+ XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+ memcpy (concat_name, tmp, tmp_len);
+ concat_name[tmp_len] = '/';
+ strcpy (concat_name + tmp_len + 1, wrapper);
+ }
+ else
+ {
+ concat_name =
+ XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
+ memcpy (concat_name, p, p_len);
+ concat_name[p_len] = '/';
+ strcpy (concat_name + p_len + 1, wrapper);
+ }
+ if (check_executable (concat_name))
+ return concat_name;
+ XFREE (concat_name);
+ }
+ }
+ /* not found in PATH; assume curdir */
+ }
+ /* Relative path | not found in path: prepend cwd */
+ if (getcwd (tmp, LT_PATHMAX) == NULL)
+ lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+ nonnull (strerror (errno)));
+ tmp_len = strlen (tmp);
+ concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+ memcpy (concat_name, tmp, tmp_len);
+ concat_name[tmp_len] = '/';
+ strcpy (concat_name + tmp_len + 1, wrapper);
+
+ if (check_executable (concat_name))
+ return concat_name;
+ XFREE (concat_name);
+ return NULL;
+}
+
+char *
+chase_symlinks (const char *pathspec)
+{
+#ifndef S_ISLNK
+ return xstrdup (pathspec);
+#else
+ char buf[LT_PATHMAX];
+ struct stat s;
+ char *tmp_pathspec = xstrdup (pathspec);
+ char *p;
+ int has_symlinks = 0;
+ while (strlen (tmp_pathspec) && !has_symlinks)
+ {
+ lt_debugprintf (__FILE__, __LINE__,
+ "checking path component for symlinks: %s\n",
+ tmp_pathspec);
+ if (lstat (tmp_pathspec, &s) == 0)
+ {
+ if (S_ISLNK (s.st_mode) != 0)
+ {
+ has_symlinks = 1;
+ break;
+ }
+
+ /* search backwards for last DIR_SEPARATOR */
+ p = tmp_pathspec + strlen (tmp_pathspec) - 1;
+ while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+ p--;
+ if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+ {
+ /* no more DIR_SEPARATORS left */
+ break;
+ }
+ *p = '\0';
+ }
+ else
+ {
+ lt_fatal (__FILE__, __LINE__,
+ "error accessing file \"%s\": %s",
+ tmp_pathspec, nonnull (strerror (errno)));
+ }
+ }
+ XFREE (tmp_pathspec);
+
+ if (!has_symlinks)
+ {
+ return xstrdup (pathspec);
+ }
+
+ tmp_pathspec = realpath (pathspec, buf);
+ if (tmp_pathspec == 0)
+ {
+ lt_fatal (__FILE__, __LINE__,
+ "could not follow symlinks for %s", pathspec);
+ }
+ return xstrdup (tmp_pathspec);
+#endif
+}
+
+char *
+strendzap (char *str, const char *pat)
+{
+ size_t len, patlen;
+
+ assert (str != NULL);
+ assert (pat != NULL);
+
+ len = strlen (str);
+ patlen = strlen (pat);
+
+ if (patlen <= len)
+ {
+ str += len - patlen;
+ if (strcmp (str, pat) == 0)
+ *str = '\0';
+ }
+ return str;
+}
+
+void
+lt_debugprintf (const char *file, int line, const char *fmt, ...)
+{
+ va_list args;
+ if (lt_debug)
+ {
+ (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
+ va_start (args, fmt);
+ (void) vfprintf (stderr, fmt, args);
+ va_end (args);
+ }
+}
+
+static void
+lt_error_core (int exit_status, const char *file,
+ int line, const char *mode,
+ const char *message, va_list ap)
+{
+ fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
+ vfprintf (stderr, message, ap);
+ fprintf (stderr, ".\n");
+
+ if (exit_status >= 0)
+ exit (exit_status);
+}
+
+void
+lt_fatal (const char *file, int line, const char *message, ...)
+{
+ va_list ap;
+ va_start (ap, message);
+ lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
+ va_end (ap);
+}
+
+static const char *
+nonnull (const char *s)
+{
+ return s ? s : "(null)";
+}
+
+static const char *
+nonempty (const char *s)
+{
+ return (s && !*s) ? "(empty)" : nonnull (s);
+}
+
+void
+lt_setenv (const char *name, const char *value)
+{
+ lt_debugprintf (__FILE__, __LINE__,
+ "(lt_setenv) setting '%s' to '%s'\n",
+ nonnull (name), nonnull (value));
+ {
+#ifdef HAVE_SETENV
+ /* always make a copy, for consistency with !HAVE_SETENV */
+ char *str = xstrdup (value);
+ setenv (name, str, 1);
+#else
+ int len = strlen (name) + 1 + strlen (value) + 1;
+ char *str = XMALLOC (char, len);
+ sprintf (str, "%s=%s", name, value);
+ if (putenv (str) != EXIT_SUCCESS)
+ {
+ XFREE (str);
+ }
+#endif
+ }
+}
+
+char *
+lt_extend_str (const char *orig_value, const char *add, int to_end)
+{
+ char *new_value;
+ if (orig_value && *orig_value)
+ {
+ int orig_value_len = strlen (orig_value);
+ int add_len = strlen (add);
+ new_value = XMALLOC (char, add_len + orig_value_len + 1);
+ if (to_end)
+ {
+ strcpy (new_value, orig_value);
+ strcpy (new_value + orig_value_len, add);
+ }
+ else
+ {
+ strcpy (new_value, add);
+ strcpy (new_value + add_len, orig_value);
+ }
+ }
+ else
+ {
+ new_value = xstrdup (add);
+ }
+ return new_value;
+}
+
+void
+lt_update_exe_path (const char *name, const char *value)
+{
+ lt_debugprintf (__FILE__, __LINE__,
+ "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
+ nonnull (name), nonnull (value));
+
+ if (name && *name && value && *value)
+ {
+ char *new_value = lt_extend_str (getenv (name), value, 0);
+ /* some systems can't cope with a ':'-terminated path #' */
+ int len = strlen (new_value);
+ while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
+ {
+ new_value[len-1] = '\0';
+ }
+ lt_setenv (name, new_value);
+ XFREE (new_value);
+ }
+}
+
+void
+lt_update_lib_path (const char *name, const char *value)
+{
+ lt_debugprintf (__FILE__, __LINE__,
+ "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
+ nonnull (name), nonnull (value));
+
+ if (name && *name && value && *value)
+ {
+ char *new_value = lt_extend_str (getenv (name), value, 0);
+ lt_setenv (name, new_value);
+ XFREE (new_value);
+ }
+}
+
+EOF
+ case $host_os in
+ mingw*)
+ cat <<"EOF"
+
+/* Prepares an argument vector before calling spawn().
+ Note that spawn() does not by itself call the command interpreter
+ (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
+ ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+ GetVersionEx(&v);
+ v.dwPlatformId == VER_PLATFORM_WIN32_NT;
+ }) ? "cmd.exe" : "command.com").
+ Instead it simply concatenates the arguments, separated by ' ', and calls
+ CreateProcess(). We must quote the arguments since Win32 CreateProcess()
+ interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
+ special way:
+ - Space and tab are interpreted as delimiters. They are not treated as
+ delimiters if they are surrounded by double quotes: "...".
+ - Unescaped double quotes are removed from the input. Their only effect is
+ that within double quotes, space and tab are treated like normal
+ characters.
+ - Backslashes not followed by double quotes are not special.
+ - But 2*n+1 backslashes followed by a double quote become
+ n backslashes followed by a double quote (n >= 0):
+ \" -> "
+ \\\" -> \"
+ \\\\\" -> \\"
+ */
+#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+char **
+prepare_spawn (char **argv)
+{
+ size_t argc;
+ char **new_argv;
+ size_t i;
+
+ /* Count number of arguments. */
+ for (argc = 0; argv[argc] != NULL; argc++)
+ ;
+
+ /* Allocate new argument vector. */
+ new_argv = XMALLOC (char *, argc + 1);
+
+ /* Put quoted arguments into the new argument vector. */
+ for (i = 0; i < argc; i++)
+ {
+ const char *string = argv[i];
+
+ if (string[0] == '\0')
+ new_argv[i] = xstrdup ("\"\"");
+ else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
+ {
+ int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
+ size_t length;
+ unsigned int backslashes;
+ const char *s;
+ char *quoted_string;
+ char *p;
+
+ length = 0;
+ backslashes = 0;
+ if (quote_around)
+ length++;
+ for (s = string; *s != '\0'; s++)
+ {
+ char c = *s;
+ if (c == '"')
+ length += backslashes + 1;
+ length++;
+ if (c == '\\')
+ backslashes++;
+ else
+ backslashes = 0;
+ }
+ if (quote_around)
+ length += backslashes + 1;
+
+ quoted_string = XMALLOC (char, length + 1);
+
+ p = quoted_string;
+ backslashes = 0;
+ if (quote_around)
+ *p++ = '"';
+ for (s = string; *s != '\0'; s++)
+ {
+ char c = *s;
+ if (c == '"')
+ {
+ unsigned int j;
+ for (j = backslashes + 1; j > 0; j--)
+ *p++ = '\\';
+ }
+ *p++ = c;
+ if (c == '\\')
+ backslashes++;
+ else
+ backslashes = 0;
+ }
+ if (quote_around)
+ {
+ unsigned int j;
+ for (j = backslashes; j > 0; j--)
+ *p++ = '\\';
+ *p++ = '"';
+ }
+ *p = '\0';
+
+ new_argv[i] = quoted_string;
+ }
+ else
+ new_argv[i] = (char *) string;
+ }
+ new_argv[argc] = NULL;
+
+ return new_argv;
+}
+EOF
+ ;;
+ esac
+
+ cat <<"EOF"
+void lt_dump_script (FILE* f)
+{
+EOF
+ func_emit_wrapper yes |
+ $SED -n -e '
+s/^\(.\{79\}\)\(..*\)/\1\
+\2/
+h
+s/\([\\"]\)/\\\1/g
+s/$/\\n/
+s/\([^\n]*\).*/ fputs ("\1", f);/p
+g
+D'
+ cat <<"EOF"
+}
+EOF
+}
+# end: func_emit_cwrapperexe_src
+
+# func_win32_import_lib_p ARG
+# True if ARG is an import lib, as indicated by $file_magic_cmd
+func_win32_import_lib_p ()
+{
+ $opt_debug
+ case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
+ *import*) : ;;
+ *) false ;;
+ esac
+}
+
+# func_mode_link arg...
+func_mode_link ()
+{
+ $opt_debug
+ case $host in
+ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+ # It is impossible to link a dll without this setting, and
+ # we shouldn't force the makefile maintainer to figure out
+ # which system we are compiling for in order to pass an extra
+ # flag for every libtool invocation.
+ # allow_undefined=no
+
+ # FIXME: Unfortunately, there are problems with the above when trying
+ # to make a dll which has undefined symbols, in which case not
+ # even a static library is built. For now, we need to specify
+ # -no-undefined on the libtool link line when we can be certain
+ # that all symbols are satisfied, otherwise we get a static library.
+ allow_undefined=yes
+ ;;
+ *)
+ allow_undefined=yes
+ ;;
+ esac
+ libtool_args=$nonopt
+ base_compile="$nonopt $@"
+ compile_command=$nonopt
+ finalize_command=$nonopt
+
+ compile_rpath=
+ finalize_rpath=
+ compile_shlibpath=
+ finalize_shlibpath=
+ convenience=
+ old_convenience=
+ deplibs=
+ old_deplibs=
+ compiler_flags=
+ linker_flags=
+ dllsearchpath=
+ lib_search_path=`pwd`
+ inst_prefix_dir=
+ new_inherited_linker_flags=
+
+ avoid_version=no
+ bindir=
+ dlfiles=
+ dlprefiles=
+ dlself=no
+ export_dynamic=no
+ export_symbols=
+ export_symbols_regex=
+ generated=
+ libobjs=
+ ltlibs=
+ module=no
+ no_install=no
+ objs=
+ non_pic_objects=
+ precious_files_regex=
+ prefer_static_libs=no
+ preload=no
+ prev=
+ prevarg=
+ release=
+ rpath=
+ xrpath=
+ perm_rpath=
+ temp_rpath=
+ thread_safe=no
+ vinfo=
+ vinfo_number=no
+ weak_libs=
+ single_module="${wl}-single_module"
+ func_infer_tag $base_compile
+
+ # We need to know -static, to get the right output filenames.
+ for arg
+ do
+ case $arg in
+ -shared)
+ test "$build_libtool_libs" != yes && \
+ func_fatal_configuration "can not build a shared library"
+ build_old_libs=no
+ break
+ ;;
+ -all-static | -static | -static-libtool-libs)
+ case $arg in
+ -all-static)
+ if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
+ func_warning "complete static linking is impossible in this configuration"
+ fi
+ if test -n "$link_static_flag"; then
+ dlopen_self=$dlopen_self_static
+ fi
+ prefer_static_libs=yes
+ ;;
+ -static)
+ if test -z "$pic_flag" && test -n "$link_static_flag"; then
+ dlopen_self=$dlopen_self_static
+ fi
+ prefer_static_libs=built
+ ;;
+ -static-libtool-libs)
+ if test -z "$pic_flag" && test -n "$link_static_flag"; then
+ dlopen_self=$dlopen_self_static
+ fi
+ prefer_static_libs=yes
+ ;;
+ esac
+ build_libtool_libs=no
+ build_old_libs=yes
+ break
+ ;;
+ esac
+ done
+
+ # See if our shared archives depend on static archives.
+ test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+ # Go through the arguments, transforming them on the way.
+ while test "$#" -gt 0; do
+ arg="$1"
+ shift
+ func_quote_for_eval "$arg"
+ qarg=$func_quote_for_eval_unquoted_result
+ func_append libtool_args " $func_quote_for_eval_result"
+
+ # If the previous option needs an argument, assign it.
+ if test -n "$prev"; then
+ case $prev in
+ output)
+ func_append compile_command " @OUTPUT@"
+ func_append finalize_command " @OUTPUT@"
+ ;;
+ esac
+
+ case $prev in
+ bindir)
+ bindir="$arg"
+ prev=
+ continue
+ ;;
+ dlfiles|dlprefiles)
+ if test "$preload" = no; then
+ # Add the symbol object into the linking commands.
+ func_append compile_command " @SYMFILE@"
+ func_append finalize_command " @SYMFILE@"
+ preload=yes
+ fi
+ case $arg in
+ *.la | *.lo) ;; # We handle these cases below.
+ force)
+ if test "$dlself" = no; then
+ dlself=needless
+ export_dynamic=yes
+ fi
+ prev=
+ continue
+ ;;
+ self)
+ if test "$prev" = dlprefiles; then
+ dlself=yes
+ elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
+ dlself=yes
+ else
+ dlself=needless
+ export_dynamic=yes
+ fi
+ prev=
+ continue
+ ;;
+ *)
+ if test "$prev" = dlfiles; then
+ func_append dlfiles " $arg"
+ else
+ func_append dlprefiles " $arg"
+ fi
+ prev=
+ continue
+ ;;
+ esac
+ ;;
+ expsyms)
+ export_symbols="$arg"
+ test -f "$arg" \
+ || func_fatal_error "symbol file \`$arg' does not exist"
+ prev=
+ continue
+ ;;
+ expsyms_regex)
+ export_symbols_regex="$arg"
+ prev=
+ continue
+ ;;
+ framework)
+ case $host in
+ *-*-darwin*)
+ case "$deplibs " in
+ *" $qarg.ltframework "*) ;;
+ *) func_append deplibs " $qarg.ltframework" # this is fixed later
+ ;;
+ esac
+ ;;
+ esac
+ prev=
+ continue
+ ;;
+ inst_prefix)
+ inst_prefix_dir="$arg"
+ prev=
+ continue
+ ;;
+ objectlist)
+ if test -f "$arg"; then
+ save_arg=$arg
+ moreargs=
+ for fil in `cat "$save_arg"`
+ do
+# func_append moreargs " $fil"
+ arg=$fil
+ # A libtool-controlled object.
+
+ # Check to see that this really is a libtool object.
+ if func_lalib_unsafe_p "$arg"; then
+ pic_object=
+ non_pic_object=
+
+ # Read the .lo file
+ func_source "$arg"
+
+ if test -z "$pic_object" ||
+ test -z "$non_pic_object" ||
+ test "$pic_object" = none &&
+ test "$non_pic_object" = none; then
+ func_fatal_error "cannot find name of object for \`$arg'"
+ fi
+
+ # Extract subdirectory from the argument.
+ func_dirname "$arg" "/" ""
+ xdir="$func_dirname_result"
+
+ if test "$pic_object" != none; then
+ # Prepend the subdirectory the object is found in.
+ pic_object="$xdir$pic_object"
+
+ if test "$prev" = dlfiles; then
+ if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+ func_append dlfiles " $pic_object"
+ prev=
+ continue
+ else
+ # If libtool objects are unsupported, then we need to preload.
+ prev=dlprefiles
+ fi
+ fi
+
+ # CHECK ME: I think I busted this. -Ossama
+ if test "$prev" = dlprefiles; then
+ # Preload the old-style object.
+ func_append dlprefiles " $pic_object"
+ prev=
+ fi
+
+ # A PIC object.
+ func_append libobjs " $pic_object"
+ arg="$pic_object"
+ fi
+
+ # Non-PIC object.
+ if test "$non_pic_object" != none; then
+ # Prepend the subdirectory the object is found in.
+ non_pic_object="$xdir$non_pic_object"
+
+ # A standard non-PIC object
+ func_append non_pic_objects " $non_pic_object"
+ if test -z "$pic_object" || test "$pic_object" = none ; then
+ arg="$non_pic_object"
+ fi
+ else
+ # If the PIC object exists, use it instead.
+ # $xdir was prepended to $pic_object above.
+ non_pic_object="$pic_object"
+ func_append non_pic_objects " $non_pic_object"
+ fi
+ else
+ # Only an error if not doing a dry-run.
+ if $opt_dry_run; then
+ # Extract subdirectory from the argument.
+ func_dirname "$arg" "/" ""
+ xdir="$func_dirname_result"
+
+ func_lo2o "$arg"
+ pic_object=$xdir$objdir/$func_lo2o_result
+ non_pic_object=$xdir$func_lo2o_result
+ func_append libobjs " $pic_object"
+ func_append non_pic_objects " $non_pic_object"
+ else
+ func_fatal_error "\`$arg' is not a valid libtool object"
+ fi
+ fi
+ done
+ else
+ func_fatal_error "link input file \`$arg' does not exist"
+ fi
+ arg=$save_arg
+ prev=
+ continue
+ ;;
+ precious_regex)
+ precious_files_regex="$arg"
+ prev=
+ continue
+ ;;
+ release)
+ release="-$arg"
+ prev=
+ continue
+ ;;
+ rpath | xrpath)
+ # We need an absolute path.
+ case $arg in
+ [\\/]* | [A-Za-z]:[\\/]*) ;;
+ *)
+ func_fatal_error "only absolute run-paths are allowed"
+ ;;
+ esac
+ if test "$prev" = rpath; then
+ case "$rpath " in
+ *" $arg "*) ;;
+ *) func_append rpath " $arg" ;;
+ esac
+ else
+ case "$xrpath " in
+ *" $arg "*) ;;
+ *) func_append xrpath " $arg" ;;
+ esac
+ fi
+ prev=
+ continue
+ ;;
+ shrext)
+ shrext_cmds="$arg"
+ prev=
+ continue
+ ;;
+ weak)
+ func_append weak_libs " $arg"
+ prev=
+ continue
+ ;;
+ xcclinker)
+ func_append linker_flags " $qarg"
+ func_append compiler_flags " $qarg"
+ prev=
+ func_append compile_command " $qarg"
+ func_append finalize_command " $qarg"
+ continue
+ ;;
+ xcompiler)
+ func_append compiler_flags " $qarg"
+ prev=
+ func_append compile_command " $qarg"
+ func_append finalize_command " $qarg"
+ continue
+ ;;
+ xlinker)
+ func_append linker_flags " $qarg"
+ func_append compiler_flags " $wl$qarg"
+ prev=
+ func_append compile_command " $wl$qarg"
+ func_append finalize_command " $wl$qarg"
+ continue
+ ;;
+ *)
+ eval "$prev=\"\$arg\""
+ prev=
+ continue
+ ;;
+ esac
+ fi # test -n "$prev"
+
+ prevarg="$arg"
+
+ case $arg in
+ -all-static)
+ if test -n "$link_static_flag"; then
+ # See comment for -static flag below, for more details.
+ func_append compile_command " $link_static_flag"
+ func_append finalize_command " $link_static_flag"
+ fi
+ continue
+ ;;
+
+ -allow-undefined)
+ # FIXME: remove this flag sometime in the future.
+ func_fatal_error "\`-allow-undefined' must not be used because it is the default"
+ ;;
+
+ -avoid-version)
+ avoid_version=yes
+ continue
+ ;;
+
+ -bindir)
+ prev=bindir
+ continue
+ ;;
+
+ -dlopen)
+ prev=dlfiles
+ continue
+ ;;
+
+ -dlpreopen)
+ prev=dlprefiles
+ continue
+ ;;
+
+ -export-dynamic)
+ export_dynamic=yes
+ continue
+ ;;
+
+ -export-symbols | -export-symbols-regex)
+ if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+ func_fatal_error "more than one -exported-symbols argument is not allowed"
+ fi
+ if test "X$arg" = "X-export-symbols"; then
+ prev=expsyms
+ else
+ prev=expsyms_regex
+ fi
+ continue
+ ;;
+
+ -framework)
+ prev=framework
+ continue
+ ;;
+
+ -inst-prefix-dir)
+ prev=inst_prefix
+ continue
+ ;;
+
+ # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
+ # so, if we see these flags be careful not to treat them like -L
+ -L[A-Z][A-Z]*:*)
+ case $with_gcc/$host in
+ no/*-*-irix* | /*-*-irix*)
+ func_append compile_command " $arg"
+ func_append finalize_command " $arg"
+ ;;
+ esac
+ continue
+ ;;
+
+ -L*)
+ func_stripname "-L" '' "$arg"
+ if test -z "$func_stripname_result"; then
+ if test "$#" -gt 0; then
+ func_fatal_error "require no space between \`-L' and \`$1'"
+ else
+ func_fatal_error "need path for \`-L' option"
+ fi
+ fi
+ func_resolve_sysroot "$func_stripname_result"
+ dir=$func_resolve_sysroot_result
+ # We need an absolute path.
+ case $dir in
+ [\\/]* | [A-Za-z]:[\\/]*) ;;
+ *)
+ absdir=`cd "$dir" && pwd`
+ test -z "$absdir" && \
+ func_fatal_error "cannot determine absolute directory name of \`$dir'"
+ dir="$absdir"
+ ;;
+ esac
+ case "$deplibs " in
+ *" -L$dir "* | *" $arg "*)
+ # Will only happen for absolute or sysroot arguments
+ ;;
+ *)
+ # Preserve sysroot, but never include relative directories
+ case $dir in
+ [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
+ *) func_append deplibs " -L$dir" ;;
+ esac
+ func_append lib_search_path " $dir"
+ ;;
+ esac
+ case $host in
+ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+ testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
+ case :$dllsearchpath: in
+ *":$dir:"*) ;;
+ ::) dllsearchpath=$dir;;
+ *) func_append dllsearchpath ":$dir";;
+ esac
+ case :$dllsearchpath: in
+ *":$testbindir:"*) ;;
+ ::) dllsearchpath=$testbindir;;
+ *) func_append dllsearchpath ":$testbindir";;
+ esac
+ ;;
+ esac
+ continue
+ ;;
+
+ -l*)
+ if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
+ case $host in
+ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
+ # These systems don't actually have a C or math library (as such)
+ continue
+ ;;
+ *-*-os2*)
+ # These systems don't actually have a C library (as such)
+ test "X$arg" = "X-lc" && continue
+ ;;
+ *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+ # Do not include libc due to us having libc/libc_r.
+ test "X$arg" = "X-lc" && continue
+ ;;
+ *-*-rhapsody* | *-*-darwin1.[012])
+ # Rhapsody C and math libraries are in the System framework
+ func_append deplibs " System.ltframework"
+ continue
+ ;;
+ *-*-sco3.2v5* | *-*-sco5v6*)
+ # Causes problems with __ctype
+ test "X$arg" = "X-lc" && continue
+ ;;
+ *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+ # Compiler inserts libc in the correct place for threads to work
+ test "X$arg" = "X-lc" && continue
+ ;;
+ esac
+ elif test "X$arg" = "X-lc_r"; then
+ case $host in
+ *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+ # Do not include libc_r directly, use -pthread flag.
+ continue
+ ;;
+ esac
+ fi
+ func_append deplibs " $arg"
+ continue
+ ;;
+
+ -module)
+ module=yes
+ continue
+ ;;
+
+ # Tru64 UNIX uses -model [arg] to determine the layout of C++
+ # classes, name mangling, and exception handling.
+ # Darwin uses the -arch flag to determine output architecture.
+ -model|-arch|-isysroot|--sysroot)
+ func_append compiler_flags " $arg"
+ func_append compile_command " $arg"
+ func_append finalize_command " $arg"
+ prev=xcompiler
+ continue
+ ;;
+
+ -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+ func_append compiler_flags " $arg"
+ func_append compile_command " $arg"
+ func_append finalize_command " $arg"
+ case "$new_inherited_linker_flags " in
+ *" $arg "*) ;;
+ * ) func_append new_inherited_linker_flags " $arg" ;;
+ esac
+ continue
+ ;;
+
+ -multi_module)
+ single_module="${wl}-multi_module"
+ continue
+ ;;
+
+ -no-fast-install)
+ fast_install=no
+ continue
+ ;;
+
+ -no-install)
+ case $host in
+ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
+ # The PATH hackery in wrapper scripts is required on Windows
+ # and Darwin in order for the loader to find any dlls it needs.
+ func_warning "\`-no-install' is ignored for $host"
+ func_warning "assuming \`-no-fast-install' instead"
+ fast_install=no
+ ;;
+ *) no_install=yes ;;
+ esac
+ continue
+ ;;
+
+ -no-undefined)
+ allow_undefined=no
+ continue
+ ;;
+
+ -objectlist)
+ prev=objectlist
+ continue
+ ;;
+
+ -o) prev=output ;;
+
+ -precious-files-regex)
+ prev=precious_regex
+ continue
+ ;;
+
+ -release)
+ prev=release
+ continue
+ ;;
+
+ -rpath)
+ prev=rpath
+ continue
+ ;;
+
+ -R)
+ prev=xrpath
+ continue
+ ;;
+
+ -R*)
+ func_stripname '-R' '' "$arg"
+ dir=$func_stripname_result
+ # We need an absolute path.
+ case $dir in
+ [\\/]* | [A-Za-z]:[\\/]*) ;;
+ =*)
+ func_stripname '=' '' "$dir"
+ dir=$lt_sysroot$func_stripname_result
+ ;;
+ *)
+ func_fatal_error "only absolute run-paths are allowed"
+ ;;
+ esac
+ case "$xrpath " in
+ *" $dir "*) ;;
+ *) func_append xrpath " $dir" ;;
+ esac
+ continue
+ ;;
+
+ -shared)
+ # The effects of -shared are defined in a previous loop.
+ continue
+ ;;
+
+ -shrext)
+ prev=shrext
+ continue
+ ;;
+
+ -static | -static-libtool-libs)
+ # The effects of -static are defined in a previous loop.
+ # We used to do the same as -all-static on platforms that
+ # didn't have a PIC flag, but the assumption that the effects
+ # would be equivalent was wrong. It would break on at least
+ # Digital Unix and AIX.
+ continue
+ ;;
+
+ -thread-safe)
+ thread_safe=yes
+ continue
+ ;;
+
+ -version-info)
+ prev=vinfo
+ continue
+ ;;
+
+ -version-number)
+ prev=vinfo
+ vinfo_number=yes
+ continue
+ ;;
+
+ -weak)
+ prev=weak
+ continue
+ ;;
+
+ -Wc,*)
+ func_stripname '-Wc,' '' "$arg"
+ args=$func_stripname_result
+ arg=
+ save_ifs="$IFS"; IFS=','
+ for flag in $args; do
+ IFS="$save_ifs"
+ func_quote_for_eval "$flag"
+ func_append arg " $func_quote_for_eval_result"
+ func_append compiler_flags " $func_quote_for_eval_result"
+ done
+ IFS="$save_ifs"
+ func_stripname ' ' '' "$arg"
+ arg=$func_stripname_result
+ ;;
+
+ -Wl,*)
+ func_stripname '-Wl,' '' "$arg"
+ args=$func_stripname_result
+ arg=
+ save_ifs="$IFS"; IFS=','
+ for flag in $args; do
+ IFS="$save_ifs"
+ func_quote_for_eval "$flag"
+ func_append arg " $wl$func_quote_for_eval_result"
+ func_append compiler_flags " $wl$func_quote_for_eval_result"
+ func_append linker_flags " $func_quote_for_eval_result"
+ done
+ IFS="$save_ifs"
+ func_stripname ' ' '' "$arg"
+ arg=$func_stripname_result
+ ;;
+
+ -Xcompiler)
+ prev=xcompiler
+ continue
+ ;;
+
+ -Xlinker)
+ prev=xlinker
+ continue
+ ;;
+
+ -XCClinker)
+ prev=xcclinker
+ continue
+ ;;
+
+ # -msg_* for osf cc
+ -msg_*)
+ func_quote_for_eval "$arg"
+ arg="$func_quote_for_eval_result"
+ ;;
+
+ # Flags to be passed through unchanged, with rationale:
+ # -64, -mips[0-9] enable 64-bit mode for the SGI compiler
+ # -r[0-9][0-9]* specify processor for the SGI compiler
+ # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
+ # +DA*, +DD* enable 64-bit mode for the HP compiler
+ # -q* compiler args for the IBM compiler
+ # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
+ # -F/path path to uninstalled frameworks, gcc on darwin
+ # -p, -pg, --coverage, -fprofile-* profiling flags for GCC
+ # @file GCC response files
+ # -tp=* Portland pgcc target processor selection
+ # --sysroot=* for sysroot support
+ # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
+ -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
+ -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
+ -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
+ func_quote_for_eval "$arg"
+ arg="$func_quote_for_eval_result"
+ func_append compile_command " $arg"
+ func_append finalize_command " $arg"
+ func_append compiler_flags " $arg"
+ continue
+ ;;
+
+ # Some other compiler flag.
+ -* | +*)
+ func_quote_for_eval "$arg"
+ arg="$func_quote_for_eval_result"
+ ;;
+
+ *.$objext)
+ # A standard object.
+ func_append objs " $arg"
+ ;;
+
+ *.lo)
+ # A libtool-controlled object.
+
+ # Check to see that this really is a libtool object.
+ if func_lalib_unsafe_p "$arg"; then
+ pic_object=
+ non_pic_object=
+
+ # Read the .lo file
+ func_source "$arg"
+
+ if test -z "$pic_object" ||
+ test -z "$non_pic_object" ||
+ test "$pic_object" = none &&
+ test "$non_pic_object" = none; then
+ func_fatal_error "cannot find name of object for \`$arg'"
+ fi
+
+ # Extract subdirectory from the argument.
+ func_dirname "$arg" "/" ""
+ xdir="$func_dirname_result"
+
+ if test "$pic_object" != none; then
+ # Prepend the subdirectory the object is found in.
+ pic_object="$xdir$pic_object"
+
+ if test "$prev" = dlfiles; then
+ if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
+ func_append dlfiles " $pic_object"
+ prev=
+ continue
+ else
+ # If libtool objects are unsupported, then we need to preload.
+ prev=dlprefiles
+ fi
+ fi
+
+ # CHECK ME: I think I busted this. -Ossama
+ if test "$prev" = dlprefiles; then
+ # Preload the old-style object.
+ func_append dlprefiles " $pic_object"
+ prev=
+ fi
+
+ # A PIC object.
+ func_append libobjs " $pic_object"
+ arg="$pic_object"
+ fi
+
+ # Non-PIC object.
+ if test "$non_pic_object" != none; then
+ # Prepend the subdirectory the object is found in.
+ non_pic_object="$xdir$non_pic_object"
+
+ # A standard non-PIC object
+ func_append non_pic_objects " $non_pic_object"
+ if test -z "$pic_object" || test "$pic_object" = none ; then
+ arg="$non_pic_object"
+ fi
+ else
+ # If the PIC object exists, use it instead.
+ # $xdir was prepended to $pic_object above.
+ non_pic_object="$pic_object"
+ func_append non_pic_objects " $non_pic_object"
+ fi
+ else
+ # Only an error if not doing a dry-run.
+ if $opt_dry_run; then
+ # Extract subdirectory from the argument.
+ func_dirname "$arg" "/" ""
+ xdir="$func_dirname_result"
+
+ func_lo2o "$arg"
+ pic_object=$xdir$objdir/$func_lo2o_result
+ non_pic_object=$xdir$func_lo2o_result
+ func_append libobjs " $pic_object"
+ func_append non_pic_objects " $non_pic_object"
+ else
+ func_fatal_error "\`$arg' is not a valid libtool object"
+ fi
+ fi
+ ;;
+
+ *.$libext)
+ # An archive.
+ func_append deplibs " $arg"
+ func_append old_deplibs " $arg"
+ continue
+ ;;
+
+ *.la)
+ # A libtool-controlled library.
+
+ func_resolve_sysroot "$arg"
+ if test "$prev" = dlfiles; then
+ # This library was specified with -dlopen.
+ func_append dlfiles " $func_resolve_sysroot_result"
+ prev=
+ elif test "$prev" = dlprefiles; then
+ # The library was specified with -dlpreopen.
+ func_append dlprefiles " $func_resolve_sysroot_result"
+ prev=
+ else
+ func_append deplibs " $func_resolve_sysroot_result"
+ fi
+ continue
+ ;;
+
+ # Some other compiler argument.
+ *)
+ # Unknown arguments in both finalize_command and compile_command need
+ # to be aesthetically quoted because they are evaled later.
+ func_quote_for_eval "$arg"
+ arg="$func_quote_for_eval_result"
+ ;;
+ esac # arg
+
+ # Now actually substitute the argument into the commands.
+ if test -n "$arg"; then
+ func_append compile_command " $arg"
+ func_append finalize_command " $arg"
+ fi
+ done # argument parsing loop
+
+ test -n "$prev" && \
+ func_fatal_help "the \`$prevarg' option requires an argument"
+
+ if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
+ eval arg=\"$export_dynamic_flag_spec\"
+ func_append compile_command " $arg"
+ func_append finalize_command " $arg"
+ fi
+
+ oldlibs=
+ # calculate the name of the file, without its directory
+ func_basename "$output"
+ outputname="$func_basename_result"
+ libobjs_save="$libobjs"
+
+ if test -n "$shlibpath_var"; then
+ # get the directories listed in $shlibpath_var
+ eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
+ else
+ shlib_search_path=
+ fi
+ eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+ eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+
+ func_dirname "$output" "/" ""
+ output_objdir="$func_dirname_result$objdir"
+ func_to_tool_file "$output_objdir/"
+ tool_output_objdir=$func_to_tool_file_result
+ # Create the object directory.
+ func_mkdir_p "$output_objdir"
+
+ # Determine the type of output
+ case $output in
+ "")
+ func_fatal_help "you must specify an output file"
+ ;;
+ *.$libext) linkmode=oldlib ;;
+ *.lo | *.$objext) linkmode=obj ;;
+ *.la) linkmode=lib ;;
+ *) linkmode=prog ;; # Anything else should be a program.
+ esac
+
+ specialdeplibs=
+
+ libs=
+ # Find all interdependent deplibs by searching for libraries
+ # that are linked more than once (e.g. -la -lb -la)
+ for deplib in $deplibs; do
+ if $opt_preserve_dup_deps ; then
+ case "$libs " in
+ *" $deplib "*) func_append specialdeplibs " $deplib" ;;
+ esac
+ fi
+ func_append libs " $deplib"
+ done
+
+ if test "$linkmode" = lib; then
+ libs="$predeps $libs $compiler_lib_search_path $postdeps"
+
+ # Compute libraries that are listed more than once in $predeps
+ # $postdeps and mark them as special (i.e., whose duplicates are
+ # not to be eliminated).
+ pre_post_deps=
+ if $opt_duplicate_compiler_generated_deps; then
+ for pre_post_dep in $predeps $postdeps; do
+ case "$pre_post_deps " in
+ *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
+ esac
+ func_append pre_post_deps " $pre_post_dep"
+ done
+ fi
+ pre_post_deps=
+ fi
+
+ deplibs=
+ newdependency_libs=
+ newlib_search_path=
+ need_relink=no # whether we're linking any uninstalled libtool libraries
+ notinst_deplibs= # not-installed libtool libraries
+ notinst_path= # paths that contain not-installed libtool libraries
+
+ case $linkmode in
+ lib)
+ passes="conv dlpreopen link"
+ for file in $dlfiles $dlprefiles; do
+ case $file in
+ *.la) ;;
+ *)
+ func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
+ ;;
+ esac
+ done
+ ;;
+ prog)
+ compile_deplibs=
+ finalize_deplibs=
+ alldeplibs=no
+ newdlfiles=
+ newdlprefiles=
+ passes="conv scan dlopen dlpreopen link"
+ ;;
+ *) passes="conv"
+ ;;
+ esac
+
+ for pass in $passes; do
+ # The preopen pass in lib mode reverses $deplibs; put it back here
+ # so that -L comes before libs that need it for instance...
+ if test "$linkmode,$pass" = "lib,link"; then
+ ## FIXME: Find the place where the list is rebuilt in the wrong
+ ## order, and fix it there properly
+ tmp_deplibs=
+ for deplib in $deplibs; do
+ tmp_deplibs="$deplib $tmp_deplibs"
+ done
+ deplibs="$tmp_deplibs"
+ fi
+
+ if test "$linkmode,$pass" = "lib,link" ||
+ test "$linkmode,$pass" = "prog,scan"; then
+ libs="$deplibs"
+ deplibs=
+ fi
+ if test "$linkmode" = prog; then
+ case $pass in
+ dlopen) libs="$dlfiles" ;;
+ dlpreopen) libs="$dlprefiles" ;;
+ link)
+ libs="$deplibs %DEPLIBS%"
+ test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+ ;;
+ esac
+ fi
+ if test "$linkmode,$pass" = "lib,dlpreopen"; then
+ # Collect and forward deplibs of preopened libtool libs
+ for lib in $dlprefiles; do
+ # Ignore non-libtool-libs
+ dependency_libs=
+ func_resolve_sysroot "$lib"
+ case $lib in
+ *.la) func_source "$func_resolve_sysroot_result" ;;
+ esac
+
+ # Collect preopened libtool deplibs, except any this library
+ # has declared as weak libs
+ for deplib in $dependency_libs; do
+ func_basename "$deplib"
+ deplib_base=$func_basename_result
+ case " $weak_libs " in
+ *" $deplib_base "*) ;;
+ *) func_append deplibs " $deplib" ;;
+ esac
+ done
+ done
+ libs="$dlprefiles"
+ fi
+ if test "$pass" = dlopen; then
+ # Collect dlpreopened libraries
+ save_deplibs="$deplibs"
+ deplibs=
+ fi
+
+ for deplib in $libs; do
+ lib=
+ found=no
+ case $deplib in
+ -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+ if test "$linkmode,$pass" = "prog,link"; then
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ else
+ func_append compiler_flags " $deplib"
+ if test "$linkmode" = lib ; then
+ case "$new_inherited_linker_flags " in
+ *" $deplib "*) ;;
+ * ) func_append new_inherited_linker_flags " $deplib" ;;
+ esac
+ fi
+ fi
+ continue
+ ;;
+ -l*)
+ if test "$linkmode" != lib && test "$linkmode" != prog; then
+ func_warning "\`-l' is ignored for archives/objects"
+ continue
+ fi
+ func_stripname '-l' '' "$deplib"
+ name=$func_stripname_result
+ if test "$linkmode" = lib; then
+ searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
+ else
+ searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
+ fi
+ for searchdir in $searchdirs; do
+ for search_ext in .la $std_shrext .so .a; do
+ # Search the libtool library
+ lib="$searchdir/lib${name}${search_ext}"
+ if test -f "$lib"; then
+ if test "$search_ext" = ".la"; then
+ found=yes
+ else
+ found=no
+ fi
+ break 2
+ fi
+ done
+ done
+ if test "$found" != yes; then
+ # deplib doesn't seem to be a libtool library
+ if test "$linkmode,$pass" = "prog,link"; then
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ else
+ deplibs="$deplib $deplibs"
+ test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+ fi
+ continue
+ else # deplib is a libtool library
+ # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
+ # We need to do some special things here, and not later.
+ if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+ case " $predeps $postdeps " in
+ *" $deplib "*)
+ if func_lalib_p "$lib"; then
+ library_names=
+ old_library=
+ func_source "$lib"
+ for l in $old_library $library_names; do
+ ll="$l"
+ done
+ if test "X$ll" = "X$old_library" ; then # only static version available
+ found=no
+ func_dirname "$lib" "" "."
+ ladir="$func_dirname_result"
+ lib=$ladir/$old_library
+ if test "$linkmode,$pass" = "prog,link"; then
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ else
+ deplibs="$deplib $deplibs"
+ test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
+ fi
+ continue
+ fi
+ fi
+ ;;
+ *) ;;
+ esac
+ fi
+ fi
+ ;; # -l
+ *.ltframework)
+ if test "$linkmode,$pass" = "prog,link"; then
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ else
+ deplibs="$deplib $deplibs"
+ if test "$linkmode" = lib ; then
+ case "$new_inherited_linker_flags " in
+ *" $deplib "*) ;;
+ * ) func_append new_inherited_linker_flags " $deplib" ;;
+ esac
+ fi
+ fi
+ continue
+ ;;
+ -L*)
+ case $linkmode in
+ lib)
+ deplibs="$deplib $deplibs"
+ test "$pass" = conv && continue
+ newdependency_libs="$deplib $newdependency_libs"
+ func_stripname '-L' '' "$deplib"
+ func_resolve_sysroot "$func_stripname_result"
+ func_append newlib_search_path " $func_resolve_sysroot_result"
+ ;;
+ prog)
+ if test "$pass" = conv; then
+ deplibs="$deplib $deplibs"
+ continue
+ fi
+ if test "$pass" = scan; then
+ deplibs="$deplib $deplibs"
+ else
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ fi
+ func_stripname '-L' '' "$deplib"
+ func_resolve_sysroot "$func_stripname_result"
+ func_append newlib_search_path " $func_resolve_sysroot_result"
+ ;;
+ *)
+ func_warning "\`-L' is ignored for archives/objects"
+ ;;
+ esac # linkmode
+ continue
+ ;; # -L
+ -R*)
+ if test "$pass" = link; then
+ func_stripname '-R' '' "$deplib"
+ func_resolve_sysroot "$func_stripname_result"
+ dir=$func_resolve_sysroot_result
+ # Make sure the xrpath contains only unique directories.
+ case "$xrpath " in
+ *" $dir "*) ;;
+ *) func_append xrpath " $dir" ;;
+ esac
+ fi
+ deplibs="$deplib $deplibs"
+ continue
+ ;;
+ *.la)
+ func_resolve_sysroot "$deplib"
+ lib=$func_resolve_sysroot_result
+ ;;
+ *.$libext)
+ if test "$pass" = conv; then
+ deplibs="$deplib $deplibs"
+ continue
+ fi
+ case $linkmode in
+ lib)
+ # Linking convenience modules into shared libraries is allowed,
+ # but linking other static libraries is non-portable.
+ case " $dlpreconveniencelibs " in
+ *" $deplib "*) ;;
+ *)
+ valid_a_lib=no
+ case $deplibs_check_method in
+ match_pattern*)
+ set dummy $deplibs_check_method; shift
+ match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+ if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
+ | $EGREP "$match_pattern_regex" > /dev/null; then
+ valid_a_lib=yes
+ fi
+ ;;
+ pass_all)
+ valid_a_lib=yes
+ ;;
+ esac
+ if test "$valid_a_lib" != yes; then
+ echo
+ $ECHO "*** Warning: Trying to link with static lib archive $deplib."
+ echo "*** I have the capability to make that library automatically link in when"
+ echo "*** you link to this library. But I can only do this if you have a"
+ echo "*** shared version of the library, which you do not appear to have"
+ echo "*** because the file extensions .$libext of this argument makes me believe"
+ echo "*** that it is just a static archive that I should not use here."
+ else
+ echo
+ $ECHO "*** Warning: Linking the shared library $output against the"
+ $ECHO "*** static library $deplib is not portable!"
+ deplibs="$deplib $deplibs"
+ fi
+ ;;
+ esac
+ continue
+ ;;
+ prog)
+ if test "$pass" != link; then
+ deplibs="$deplib $deplibs"
+ else
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ fi
+ continue
+ ;;
+ esac # linkmode
+ ;; # *.$libext
+ *.lo | *.$objext)
+ if test "$pass" = conv; then
+ deplibs="$deplib $deplibs"
+ elif test "$linkmode" = prog; then
+ if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
+ # If there is no dlopen support or we're linking statically,
+ # we need to preload.
+ func_append newdlprefiles " $deplib"
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ else
+ func_append newdlfiles " $deplib"
+ fi
+ fi
+ continue
+ ;;
+ %DEPLIBS%)
+ alldeplibs=yes
+ continue
+ ;;
+ esac # case $deplib
+
+ if test "$found" = yes || test -f "$lib"; then :
+ else
+ func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
+ fi
+
+ # Check to see that this really is a libtool archive.
+ func_lalib_unsafe_p "$lib" \
+ || func_fatal_error "\`$lib' is not a valid libtool archive"
+
+ func_dirname "$lib" "" "."
+ ladir="$func_dirname_result"
+
+ dlname=
+ dlopen=
+ dlpreopen=
+ libdir=
+ library_names=
+ old_library=
+ inherited_linker_flags=
+ # If the library was installed with an old release of libtool,
+ # it will not redefine variables installed, or shouldnotlink
+ installed=yes
+ shouldnotlink=no
+ avoidtemprpath=
+
+
+ # Read the .la file
+ func_source "$lib"
+
+ # Convert "-framework foo" to "foo.ltframework"
+ if test -n "$inherited_linker_flags"; then
+ tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
+ for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
+ case " $new_inherited_linker_flags " in
+ *" $tmp_inherited_linker_flag "*) ;;
+ *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
+ esac
+ done
+ fi
+ dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+ if test "$linkmode,$pass" = "lib,link" ||
+ test "$linkmode,$pass" = "prog,scan" ||
+ { test "$linkmode" != prog && test "$linkmode" != lib; }; then
+ test -n "$dlopen" && func_append dlfiles " $dlopen"
+ test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
+ fi
+
+ if test "$pass" = conv; then
+ # Only check for convenience libraries
+ deplibs="$lib $deplibs"
+ if test -z "$libdir"; then
+ if test -z "$old_library"; then
+ func_fatal_error "cannot find name of link library for \`$lib'"
+ fi
+ # It is a libtool convenience library, so add in its objects.
+ func_append convenience " $ladir/$objdir/$old_library"
+ func_append old_convenience " $ladir/$objdir/$old_library"
+ tmp_libs=
+ for deplib in $dependency_libs; do
+ deplibs="$deplib $deplibs"
+ if $opt_preserve_dup_deps ; then
+ case "$tmp_libs " in
+ *" $deplib "*) func_append specialdeplibs " $deplib" ;;
+ esac
+ fi
+ func_append tmp_libs " $deplib"
+ done
+ elif test "$linkmode" != prog && test "$linkmode" != lib; then
+ func_fatal_error "\`$lib' is not a convenience library"
+ fi
+ continue
+ fi # $pass = conv
+
+
+ # Get the name of the library we link against.
+ linklib=
+ if test -n "$old_library" &&
+ { test "$prefer_static_libs" = yes ||
+ test "$prefer_static_libs,$installed" = "built,no"; }; then
+ linklib=$old_library
+ else
+ for l in $old_library $library_names; do
+ linklib="$l"
+ done
+ fi
+ if test -z "$linklib"; then
+ func_fatal_error "cannot find name of link library for \`$lib'"
+ fi
+
+ # This library was specified with -dlopen.
+ if test "$pass" = dlopen; then
+ if test -z "$libdir"; then
+ func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
+ fi
+ if test -z "$dlname" ||
+ test "$dlopen_support" != yes ||
+ test "$build_libtool_libs" = no; then
+ # If there is no dlname, no dlopen support or we're linking
+ # statically, we need to preload. We also need to preload any
+ # dependent libraries so libltdl's deplib preloader doesn't
+ # bomb out in the load deplibs phase.
+ func_append dlprefiles " $lib $dependency_libs"
+ else
+ func_append newdlfiles " $lib"
+ fi
+ continue
+ fi # $pass = dlopen
+
+ # We need an absolute path.
+ case $ladir in
+ [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
+ *)
+ abs_ladir=`cd "$ladir" && pwd`
+ if test -z "$abs_ladir"; then
+ func_warning "cannot determine absolute directory name of \`$ladir'"
+ func_warning "passing it literally to the linker, although it might fail"
+ abs_ladir="$ladir"
+ fi
+ ;;
+ esac
+ func_basename "$lib"
+ laname="$func_basename_result"
+
+ # Find the relevant object directory and library name.
+ if test "X$installed" = Xyes; then
+ if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+ func_warning "library \`$lib' was moved."
+ dir="$ladir"
+ absdir="$abs_ladir"
+ libdir="$abs_ladir"
+ else
+ dir="$lt_sysroot$libdir"
+ absdir="$lt_sysroot$libdir"
+ fi
+ test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
+ else
+ if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+ dir="$ladir"
+ absdir="$abs_ladir"
+ # Remove this search path later
+ func_append notinst_path " $abs_ladir"
+ else
+ dir="$ladir/$objdir"
+ absdir="$abs_ladir/$objdir"
+ # Remove this search path later
+ func_append notinst_path " $abs_ladir"
+ fi
+ fi # $installed = yes
+ func_stripname 'lib' '.la' "$laname"
+ name=$func_stripname_result
+
+ # This library was specified with -dlpreopen.
+ if test "$pass" = dlpreopen; then
+ if test -z "$libdir" && test "$linkmode" = prog; then
+ func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
+ fi
+ case "$host" in
+ # special handling for platforms with PE-DLLs.
+ *cygwin* | *mingw* | *cegcc* )
+ # Linker will automatically link against shared library if both
+ # static and shared are present. Therefore, ensure we extract
+ # symbols from the import library if a shared library is present
+ # (otherwise, the dlopen module name will be incorrect). We do
+ # this by putting the import library name into $newdlprefiles.
+ # We recover the dlopen module name by 'saving' the la file
+ # name in a special purpose variable, and (later) extracting the
+ # dlname from the la file.
+ if test -n "$dlname"; then
+ func_tr_sh "$dir/$linklib"
+ eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
+ func_append newdlprefiles " $dir/$linklib"
+ else
+ func_append newdlprefiles " $dir/$old_library"
+ # Keep a list of preopened convenience libraries to check
+ # that they are being used correctly in the link pass.
+ test -z "$libdir" && \
+ func_append dlpreconveniencelibs " $dir/$old_library"
+ fi
+ ;;
+ * )
+ # Prefer using a static library (so that no silly _DYNAMIC symbols
+ # are required to link).
+ if test -n "$old_library"; then
+ func_append newdlprefiles " $dir/$old_library"
+ # Keep a list of preopened convenience libraries to check
+ # that they are being used correctly in the link pass.
+ test -z "$libdir" && \
+ func_append dlpreconveniencelibs " $dir/$old_library"
+ # Otherwise, use the dlname, so that lt_dlopen finds it.
+ elif test -n "$dlname"; then
+ func_append newdlprefiles " $dir/$dlname"
+ else
+ func_append newdlprefiles " $dir/$linklib"
+ fi
+ ;;
+ esac
+ fi # $pass = dlpreopen
+
+ if test -z "$libdir"; then
+ # Link the convenience library
+ if test "$linkmode" = lib; then
+ deplibs="$dir/$old_library $deplibs"
+ elif test "$linkmode,$pass" = "prog,link"; then
+ compile_deplibs="$dir/$old_library $compile_deplibs"
+ finalize_deplibs="$dir/$old_library $finalize_deplibs"
+ else
+ deplibs="$lib $deplibs" # used for prog,scan pass
+ fi
+ continue
+ fi
+
+
+ if test "$linkmode" = prog && test "$pass" != link; then
+ func_append newlib_search_path " $ladir"
+ deplibs="$lib $deplibs"
+
+ linkalldeplibs=no
+ if test "$link_all_deplibs" != no || test -z "$library_names" ||
+ test "$build_libtool_libs" = no; then
+ linkalldeplibs=yes
+ fi
+
+ tmp_libs=
+ for deplib in $dependency_libs; do
+ case $deplib in
+ -L*) func_stripname '-L' '' "$deplib"
+ func_resolve_sysroot "$func_stripname_result"
+ func_append newlib_search_path " $func_resolve_sysroot_result"
+ ;;
+ esac
+ # Need to link against all dependency_libs?
+ if test "$linkalldeplibs" = yes; then
+ deplibs="$deplib $deplibs"
+ else
+ # Need to hardcode shared library paths
+ # or/and link against static libraries
+ newdependency_libs="$deplib $newdependency_libs"
+ fi
+ if $opt_preserve_dup_deps ; then
+ case "$tmp_libs " in
+ *" $deplib "*) func_append specialdeplibs " $deplib" ;;
+ esac
+ fi
+ func_append tmp_libs " $deplib"
+ done # for deplib
+ continue
+ fi # $linkmode = prog...
+
+ if test "$linkmode,$pass" = "prog,link"; then
+ if test -n "$library_names" &&
+ { { test "$prefer_static_libs" = no ||
+ test "$prefer_static_libs,$installed" = "built,yes"; } ||
+ test -z "$old_library"; }; then
+ # We need to hardcode the library path
+ if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
+ # Make sure the rpath contains only unique directories.
+ case "$temp_rpath:" in
+ *"$absdir:"*) ;;
+ *) func_append temp_rpath "$absdir:" ;;
+ esac
+ fi
+
+ # Hardcode the library path.
+ # Skip directories that are in the system default run-time
+ # search path.
+ case " $sys_lib_dlsearch_path " in
+ *" $absdir "*) ;;
+ *)
+ case "$compile_rpath " in
+ *" $absdir "*) ;;
+ *) func_append compile_rpath " $absdir" ;;
+ esac
+ ;;
+ esac
+ case " $sys_lib_dlsearch_path " in
+ *" $libdir "*) ;;
+ *)
+ case "$finalize_rpath " in
+ *" $libdir "*) ;;
+ *) func_append finalize_rpath " $libdir" ;;
+ esac
+ ;;
+ esac
+ fi # $linkmode,$pass = prog,link...
+
+ if test "$alldeplibs" = yes &&
+ { test "$deplibs_check_method" = pass_all ||
+ { test "$build_libtool_libs" = yes &&
+ test -n "$library_names"; }; }; then
+ # We only need to search for static libraries
+ continue
+ fi
+ fi
+
+ link_static=no # Whether the deplib will be linked statically
+ use_static_libs=$prefer_static_libs
+ if test "$use_static_libs" = built && test "$installed" = yes; then
+ use_static_libs=no
+ fi
+ if test -n "$library_names" &&
+ { test "$use_static_libs" = no || test -z "$old_library"; }; then
+ case $host in
+ *cygwin* | *mingw* | *cegcc*)
+ # No point in relinking DLLs because paths are not encoded
+ func_append notinst_deplibs " $lib"
+ need_relink=no
+ ;;
+ *)
+ if test "$installed" = no; then
+ func_append notinst_deplibs " $lib"
+ need_relink=yes
+ fi
+ ;;
+ esac
+ # This is a shared library
+
+ # Warn about portability, can't link against -module's on some
+ # systems (darwin). Don't bleat about dlopened modules though!
+ dlopenmodule=""
+ for dlpremoduletest in $dlprefiles; do
+ if test "X$dlpremoduletest" = "X$lib"; then
+ dlopenmodule="$dlpremoduletest"
+ break
+ fi
+ done
+ if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
+ echo
+ if test "$linkmode" = prog; then
+ $ECHO "*** Warning: Linking the executable $output against the loadable module"
+ else
+ $ECHO "*** Warning: Linking the shared library $output against the loadable module"
+ fi
+ $ECHO "*** $linklib is not portable!"
+ fi
+ if test "$linkmode" = lib &&
+ test "$hardcode_into_libs" = yes; then
+ # Hardcode the library path.
+ # Skip directories that are in the system default run-time
+ # search path.
+ case " $sys_lib_dlsearch_path " in
+ *" $absdir "*) ;;
+ *)
+ case "$compile_rpath " in
+ *" $absdir "*) ;;
+ *) func_append compile_rpath " $absdir" ;;
+ esac
+ ;;
+ esac
+ case " $sys_lib_dlsearch_path " in
+ *" $libdir "*) ;;
+ *)
+ case "$finalize_rpath " in
+ *" $libdir "*) ;;
+ *) func_append finalize_rpath " $libdir" ;;
+ esac
+ ;;
+ esac
+ fi
+
+ if test -n "$old_archive_from_expsyms_cmds"; then
+ # figure out the soname
+ set dummy $library_names
+ shift
+ realname="$1"
+ shift
+ libname=`eval "\\$ECHO \"$libname_spec\""`
+ # use dlname if we got it. it's perfectly good, no?
+ if test -n "$dlname"; then
+ soname="$dlname"
+ elif test -n "$soname_spec"; then
+ # bleh windows
+ case $host in
+ *cygwin* | mingw* | *cegcc*)
+ func_arith $current - $age
+ major=$func_arith_result
+ versuffix="-$major"
+ ;;
+ esac
+ eval soname=\"$soname_spec\"
+ else
+ soname="$realname"
+ fi
+
+ # Make a new name for the extract_expsyms_cmds to use
+ soroot="$soname"
+ func_basename "$soroot"
+ soname="$func_basename_result"
+ func_stripname 'lib' '.dll' "$soname"
+ newlib=libimp-$func_stripname_result.a
+
+ # If the library has no export list, then create one now
+ if test -f "$output_objdir/$soname-def"; then :
+ else
+ func_verbose "extracting exported symbol list from \`$soname'"
+ func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
+ fi
+
+ # Create $newlib
+ if test -f "$output_objdir/$newlib"; then :; else
+ func_verbose "generating import library for \`$soname'"
+ func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
+ fi
+ # make sure the library variables are pointing to the new library
+ dir=$output_objdir
+ linklib=$newlib
+ fi # test -n "$old_archive_from_expsyms_cmds"
+
+ if test "$linkmode" = prog || test "$opt_mode" != relink; then
+ add_shlibpath=
+ add_dir=
+ add=
+ lib_linked=yes
+ case $hardcode_action in
+ immediate | unsupported)
+ if test "$hardcode_direct" = no; then
+ add="$dir/$linklib"
+ case $host in
+ *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
+ *-*-sysv4*uw2*) add_dir="-L$dir" ;;
+ *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
+ *-*-unixware7*) add_dir="-L$dir" ;;
+ *-*-darwin* )
+ # if the lib is a (non-dlopened) module then we can not
+ # link against it, someone is ignoring the earlier warnings
+ if /usr/bin/file -L $add 2> /dev/null |
+ $GREP ": [^:]* bundle" >/dev/null ; then
+ if test "X$dlopenmodule" != "X$lib"; then
+ $ECHO "*** Warning: lib $linklib is a module, not a shared library"
+ if test -z "$old_library" ; then
+ echo
+ echo "*** And there doesn't seem to be a static archive available"
+ echo "*** The link will probably fail, sorry"
+ else
+ add="$dir/$old_library"
+ fi
+ elif test -n "$old_library"; then
+ add="$dir/$old_library"
+ fi
+ fi
+ esac
+ elif test "$hardcode_minus_L" = no; then
+ case $host in
+ *-*-sunos*) add_shlibpath="$dir" ;;
+ esac
+ add_dir="-L$dir"
+ add="-l$name"
+ elif test "$hardcode_shlibpath_var" = no; then
+ add_shlibpath="$dir"
+ add="-l$name"
+ else
+ lib_linked=no
+ fi
+ ;;
+ relink)
+ if test "$hardcode_direct" = yes &&
+ test "$hardcode_direct_absolute" = no; then
+ add="$dir/$linklib"
+ elif test "$hardcode_minus_L" = yes; then
+ add_dir="-L$absdir"
+ # Try looking first in the location we're being installed to.
+ if test -n "$inst_prefix_dir"; then
+ case $libdir in
+ [\\/]*)
+ func_append add_dir " -L$inst_prefix_dir$libdir"
+ ;;
+ esac
+ fi
+ add="-l$name"
+ elif test "$hardcode_shlibpath_var" = yes; then
+ add_shlibpath="$dir"
+ add="-l$name"
+ else
+ lib_linked=no
+ fi
+ ;;
+ *) lib_linked=no ;;
+ esac
+
+ if test "$lib_linked" != yes; then
+ func_fatal_configuration "unsupported hardcode properties"
+ fi
+
+ if test -n "$add_shlibpath"; then
+ case :$compile_shlibpath: in
+ *":$add_shlibpath:"*) ;;
+ *) func_append compile_shlibpath "$add_shlibpath:" ;;
+ esac
+ fi
+ if test "$linkmode" = prog; then
+ test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
+ test -n "$add" && compile_deplibs="$add $compile_deplibs"
+ else
+ test -n "$add_dir" && deplibs="$add_dir $deplibs"
+ test -n "$add" && deplibs="$add $deplibs"
+ if test "$hardcode_direct" != yes &&
+ test "$hardcode_minus_L" != yes &&
+ test "$hardcode_shlibpath_var" = yes; then
+ case :$finalize_shlibpath: in
+ *":$libdir:"*) ;;
+ *) func_append finalize_shlibpath "$libdir:" ;;
+ esac
+ fi
+ fi
+ fi
+
+ if test "$linkmode" = prog || test "$opt_mode" = relink; then
+ add_shlibpath=
+ add_dir=
+ add=
+ # Finalize command for both is simple: just hardcode it.
+ if test "$hardcode_direct" = yes &&
+ test "$hardcode_direct_absolute" = no; then
+ add="$libdir/$linklib"
+ elif test "$hardcode_minus_L" = yes; then
+ add_dir="-L$libdir"
+ add="-l$name"
+ elif test "$hardcode_shlibpath_var" = yes; then
+ case :$finalize_shlibpath: in
+ *":$libdir:"*) ;;
+ *) func_append finalize_shlibpath "$libdir:" ;;
+ esac
+ add="-l$name"
+ elif test "$hardcode_automatic" = yes; then
+ if test -n "$inst_prefix_dir" &&
+ test -f "$inst_prefix_dir$libdir/$linklib" ; then
+ add="$inst_prefix_dir$libdir/$linklib"
+ else
+ add="$libdir/$linklib"
+ fi
+ else
+ # We cannot seem to hardcode it, guess we'll fake it.
+ add_dir="-L$libdir"
+ # Try looking first in the location we're being installed to.
+ if test -n "$inst_prefix_dir"; then
+ case $libdir in
+ [\\/]*)
+ func_append add_dir " -L$inst_prefix_dir$libdir"
+ ;;
+ esac
+ fi
+ add="-l$name"
+ fi
+
+ if test "$linkmode" = prog; then
+ test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
+ test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
+ else
+ test -n "$add_dir" && deplibs="$add_dir $deplibs"
+ test -n "$add" && deplibs="$add $deplibs"
+ fi
+ fi
+ elif test "$linkmode" = prog; then
+ # Here we assume that one of hardcode_direct or hardcode_minus_L
+ # is not unsupported. This is valid on all known static and
+ # shared platforms.
+ if test "$hardcode_direct" != unsupported; then
+ test -n "$old_library" && linklib="$old_library"
+ compile_deplibs="$dir/$linklib $compile_deplibs"
+ finalize_deplibs="$dir/$linklib $finalize_deplibs"
+ else
+ compile_deplibs="-l$name -L$dir $compile_deplibs"
+ finalize_deplibs="-l$name -L$dir $finalize_deplibs"
+ fi
+ elif test "$build_libtool_libs" = yes; then
+ # Not a shared library
+ if test "$deplibs_check_method" != pass_all; then
+ # We're trying link a shared library against a static one
+ # but the system doesn't support it.
+
+ # Just print a warning and add the library to dependency_libs so
+ # that the program can be linked against the static library.
+ echo
+ $ECHO "*** Warning: This system can not link to static lib archive $lib."
+ echo "*** I have the capability to make that library automatically link in when"
+ echo "*** you link to this library. But I can only do this if you have a"
+ echo "*** shared version of the library, which you do not appear to have."
+ if test "$module" = yes; then
+ echo "*** But as you try to build a module library, libtool will still create "
+ echo "*** a static module, that should work as long as the dlopening application"
+ echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
+ if test -z "$global_symbol_pipe"; then
+ echo
+ echo "*** However, this would only work if libtool was able to extract symbol"
+ echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+ echo "*** not find such a program. So, this module is probably useless."
+ echo "*** \`nm' from GNU binutils and a full rebuild may help."
+ fi
+ if test "$build_old_libs" = no; then
+ build_libtool_libs=module
+ build_old_libs=yes
+ else
+ build_libtool_libs=no
+ fi
+ fi
+ else
+ deplibs="$dir/$old_library $deplibs"
+ link_static=yes
+ fi
+ fi # link shared/static library?
+
+ if test "$linkmode" = lib; then
+ if test -n "$dependency_libs" &&
+ { test "$hardcode_into_libs" != yes ||
+ test "$build_old_libs" = yes ||
+ test "$link_static" = yes; }; then
+ # Extract -R from dependency_libs
+ temp_deplibs=
+ for libdir in $dependency_libs; do
+ case $libdir in
+ -R*) func_stripname '-R' '' "$libdir"
+ temp_xrpath=$func_stripname_result
+ case " $xrpath " in
+ *" $temp_xrpath "*) ;;
+ *) func_append xrpath " $temp_xrpath";;
+ esac;;
+ *) func_append temp_deplibs " $libdir";;
+ esac
+ done
+ dependency_libs="$temp_deplibs"
+ fi
+
+ func_append newlib_search_path " $absdir"
+ # Link against this library
+ test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+ # ... and its dependency_libs
+ tmp_libs=
+ for deplib in $dependency_libs; do
+ newdependency_libs="$deplib $newdependency_libs"
+ case $deplib in
+ -L*) func_stripname '-L' '' "$deplib"
+ func_resolve_sysroot "$func_stripname_result";;
+ *) func_resolve_sysroot "$deplib" ;;
+ esac
+ if $opt_preserve_dup_deps ; then
+ case "$tmp_libs " in
+ *" $func_resolve_sysroot_result "*)
+ func_append specialdeplibs " $func_resolve_sysroot_result" ;;
+ esac
+ fi
+ func_append tmp_libs " $func_resolve_sysroot_result"
+ done
+
+ if test "$link_all_deplibs" != no; then
+ # Add the search paths of all dependency libraries
+ for deplib in $dependency_libs; do
+ path=
+ case $deplib in
+ -L*) path="$deplib" ;;
+ *.la)
+ func_resolve_sysroot "$deplib"
+ deplib=$func_resolve_sysroot_result
+ func_dirname "$deplib" "" "."
+ dir=$func_dirname_result
+ # We need an absolute path.
+ case $dir in
+ [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
+ *)
+ absdir=`cd "$dir" && pwd`
+ if test -z "$absdir"; then
+ func_warning "cannot determine absolute directory name of \`$dir'"
+ absdir="$dir"
+ fi
+ ;;
+ esac
+ if $GREP "^installed=no" $deplib > /dev/null; then
+ case $host in
+ *-*-darwin*)
+ depdepl=
+ eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
+ if test -n "$deplibrary_names" ; then
+ for tmp in $deplibrary_names ; do
+ depdepl=$tmp
+ done
+ if test -f "$absdir/$objdir/$depdepl" ; then
+ depdepl="$absdir/$objdir/$depdepl"
+ darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
+ if test -z "$darwin_install_name"; then
+ darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
+ fi
+ func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
+ func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
+ path=
+ fi
+ fi
+ ;;
+ *)
+ path="-L$absdir/$objdir"
+ ;;
+ esac
+ else
+ eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
+ test -z "$libdir" && \
+ func_fatal_error "\`$deplib' is not a valid libtool archive"
+ test "$absdir" != "$libdir" && \
+ func_warning "\`$deplib' seems to be moved"
+
+ path="-L$absdir"
+ fi
+ ;;
+ esac
+ case " $deplibs " in
+ *" $path "*) ;;
+ *) deplibs="$path $deplibs" ;;
+ esac
+ done
+ fi # link_all_deplibs != no
+ fi # linkmode = lib
+ done # for deplib in $libs
+ if test "$pass" = link; then
+ if test "$linkmode" = "prog"; then
+ compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
+ finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
+ else
+ compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+ fi
+ fi
+ dependency_libs="$newdependency_libs"
+ if test "$pass" = dlpreopen; then
+ # Link the dlpreopened libraries before other libraries
+ for deplib in $save_deplibs; do
+ deplibs="$deplib $deplibs"
+ done
+ fi
+ if test "$pass" != dlopen; then
+ if test "$pass" != conv; then
+ # Make sure lib_search_path contains only unique directories.
+ lib_search_path=
+ for dir in $newlib_search_path; do
+ case "$lib_search_path " in
+ *" $dir "*) ;;
+ *) func_append lib_search_path " $dir" ;;
+ esac
+ done
+ newlib_search_path=
+ fi
+
+ if test "$linkmode,$pass" != "prog,link"; then
+ vars="deplibs"
+ else
+ vars="compile_deplibs finalize_deplibs"
+ fi
+ for var in $vars dependency_libs; do
+ # Add libraries to $var in reverse order
+ eval tmp_libs=\"\$$var\"
+ new_libs=
+ for deplib in $tmp_libs; do
+ # FIXME: Pedantically, this is the right thing to do, so
+ # that some nasty dependency loop isn't accidentally
+ # broken:
+ #new_libs="$deplib $new_libs"
+ # Pragmatically, this seems to cause very few problems in
+ # practice:
+ case $deplib in
+ -L*) new_libs="$deplib $new_libs" ;;
+ -R*) ;;
+ *)
+ # And here is the reason: when a library appears more
+ # than once as an explicit dependence of a library, or
+ # is implicitly linked in more than once by the
+ # compiler, it is considered special, and multiple
+ # occurrences thereof are not removed. Compare this
+ # with having the same library being listed as a
+ # dependency of multiple other libraries: in this case,
+ # we know (pedantically, we assume) the library does not
+ # need to be listed more than once, so we keep only the
+ # last copy. This is not always right, but it is rare
+ # enough that we require users that really mean to play
+ # such unportable linking tricks to link the library
+ # using -Wl,-lname, so that libtool does not consider it
+ # for duplicate removal.
+ case " $specialdeplibs " in
+ *" $deplib "*) new_libs="$deplib $new_libs" ;;
+ *)
+ case " $new_libs " in
+ *" $deplib "*) ;;
+ *) new_libs="$deplib $new_libs" ;;
+ esac
+ ;;
+ esac
+ ;;
+ esac
+ done
+ tmp_libs=
+ for deplib in $new_libs; do
+ case $deplib in
+ -L*)
+ case " $tmp_libs " in
+ *" $deplib "*) ;;
+ *) func_append tmp_libs " $deplib" ;;
+ esac
+ ;;
+ *) func_append tmp_libs " $deplib" ;;
+ esac
+ done
+ eval $var=\"$tmp_libs\"
+ done # for var
+ fi
+ # Last step: remove runtime libs from dependency_libs
+ # (they stay in deplibs)
+ tmp_libs=
+ for i in $dependency_libs ; do
+ case " $predeps $postdeps $compiler_lib_search_path " in
+ *" $i "*)
+ i=""
+ ;;
+ esac
+ if test -n "$i" ; then
+ func_append tmp_libs " $i"
+ fi
+ done
+ dependency_libs=$tmp_libs
+ done # for pass
+ if test "$linkmode" = prog; then
+ dlfiles="$newdlfiles"
+ fi
+ if test "$linkmode" = prog || test "$linkmode" = lib; then
+ dlprefiles="$newdlprefiles"
+ fi
+
+ case $linkmode in
+ oldlib)
+ if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+ func_warning "\`-dlopen' is ignored for archives"
+ fi
+
+ case " $deplibs" in
+ *\ -l* | *\ -L*)
+ func_warning "\`-l' and \`-L' are ignored for archives" ;;
+ esac
+
+ test -n "$rpath" && \
+ func_warning "\`-rpath' is ignored for archives"
+
+ test -n "$xrpath" && \
+ func_warning "\`-R' is ignored for archives"
+
+ test -n "$vinfo" && \
+ func_warning "\`-version-info/-version-number' is ignored for archives"
+
+ test -n "$release" && \
+ func_warning "\`-release' is ignored for archives"
+
+ test -n "$export_symbols$export_symbols_regex" && \
+ func_warning "\`-export-symbols' is ignored for archives"
+
+ # Now set the variables for building old libraries.
+ build_libtool_libs=no
+ oldlibs="$output"
+ func_append objs "$old_deplibs"
+ ;;
+
+ lib)
+ # Make sure we only generate libraries of the form `libNAME.la'.
+ case $outputname in
+ lib*)
+ func_stripname 'lib' '.la' "$outputname"
+ name=$func_stripname_result
+ eval shared_ext=\"$shrext_cmds\"
+ eval libname=\"$libname_spec\"
+ ;;
+ *)
+ test "$module" = no && \
+ func_fatal_help "libtool library \`$output' must begin with \`lib'"
+
+ if test "$need_lib_prefix" != no; then
+ # Add the "lib" prefix for modules if required
+ func_stripname '' '.la' "$outputname"
+ name=$func_stripname_result
+ eval shared_ext=\"$shrext_cmds\"
+ eval libname=\"$libname_spec\"
+ else
+ func_stripname '' '.la' "$outputname"
+ libname=$func_stripname_result
+ fi
+ ;;
+ esac
+
+ if test -n "$objs"; then
+ if test "$deplibs_check_method" != pass_all; then
+ func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
+ else
+ echo
+ $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
+ $ECHO "*** objects $objs is not portable!"
+ func_append libobjs " $objs"
+ fi
+ fi
+
+ test "$dlself" != no && \
+ func_warning "\`-dlopen self' is ignored for libtool libraries"
+
+ set dummy $rpath
+ shift
+ test "$#" -gt 1 && \
+ func_warning "ignoring multiple \`-rpath's for a libtool library"
+
+ install_libdir="$1"
+
+ oldlibs=
+ if test -z "$rpath"; then
+ if test "$build_libtool_libs" = yes; then
+ # Building a libtool convenience library.
+ # Some compilers have problems with a `.al' extension so
+ # convenience libraries should have the same extension an
+ # archive normally would.
+ oldlibs="$output_objdir/$libname.$libext $oldlibs"
+ build_libtool_libs=convenience
+ build_old_libs=yes
+ fi
+
+ test -n "$vinfo" && \
+ func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
+
+ test -n "$release" && \
+ func_warning "\`-release' is ignored for convenience libraries"
+ else
+
+ # Parse the version information argument.
+ save_ifs="$IFS"; IFS=':'
+ set dummy $vinfo 0 0 0
+ shift
+ IFS="$save_ifs"
+
+ test -n "$7" && \
+ func_fatal_help "too many parameters to \`-version-info'"
+
+ # convert absolute version numbers to libtool ages
+ # this retains compatibility with .la files and attempts
+ # to make the code below a bit more comprehensible
+
+ case $vinfo_number in
+ yes)
+ number_major="$1"
+ number_minor="$2"
+ number_revision="$3"
+ #
+ # There are really only two kinds -- those that
+ # use the current revision as the major version
+ # and those that subtract age and use age as
+ # a minor version. But, then there is irix
+ # which has an extra 1 added just for fun
+ #
+ case $version_type in
+ # correct linux to gnu/linux during the next big refactor
+ darwin|linux|osf|windows|none)
+ func_arith $number_major + $number_minor
+ current=$func_arith_result
+ age="$number_minor"
+ revision="$number_revision"
+ ;;
+ freebsd-aout|freebsd-elf|qnx|sunos)
+ current="$number_major"
+ revision="$number_minor"
+ age="0"
+ ;;
+ irix|nonstopux)
+ func_arith $number_major + $number_minor
+ current=$func_arith_result
+ age="$number_minor"
+ revision="$number_minor"
+ lt_irix_increment=no
+ ;;
+ *)
+ func_fatal_configuration "$modename: unknown library version type \`$version_type'"
+ ;;
+ esac
+ ;;
+ no)
+ current="$1"
+ revision="$2"
+ age="$3"
+ ;;
+ esac
+
+ # Check that each of the things are valid numbers.
+ case $current in
+ 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+ *)
+ func_error "CURRENT \`$current' must be a nonnegative integer"
+ func_fatal_error "\`$vinfo' is not valid version information"
+ ;;
+ esac
+
+ case $revision in
+ 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+ *)
+ func_error "REVISION \`$revision' must be a nonnegative integer"
+ func_fatal_error "\`$vinfo' is not valid version information"
+ ;;
+ esac
+
+ case $age in
+ 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
+ *)
+ func_error "AGE \`$age' must be a nonnegative integer"
+ func_fatal_error "\`$vinfo' is not valid version information"
+ ;;
+ esac
+
+ if test "$age" -gt "$current"; then
+ func_error "AGE \`$age' is greater than the current interface number \`$current'"
+ func_fatal_error "\`$vinfo' is not valid version information"
+ fi
+
+ # Calculate the version variables.
+ major=
+ versuffix=
+ verstring=
+ case $version_type in
+ none) ;;
+
+ darwin)
+ # Like Linux, but with the current version available in
+ # verstring for coding it into the library header
+ func_arith $current - $age
+ major=.$func_arith_result
+ versuffix="$major.$age.$revision"
+ # Darwin ld doesn't like 0 for these options...
+ func_arith $current + 1
+ minor_current=$func_arith_result
+ xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
+ verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+ ;;
+
+ freebsd-aout)
+ major=".$current"
+ versuffix=".$current.$revision";
+ ;;
+
+ freebsd-elf)
+ major=".$current"
+ versuffix=".$current"
+ ;;
+
+ irix | nonstopux)
+ if test "X$lt_irix_increment" = "Xno"; then
+ func_arith $current - $age
+ else
+ func_arith $current - $age + 1
+ fi
+ major=$func_arith_result
+
+ case $version_type in
+ nonstopux) verstring_prefix=nonstopux ;;
+ *) verstring_prefix=sgi ;;
+ esac
+ verstring="$verstring_prefix$major.$revision"
+
+ # Add in all the interfaces that we are compatible with.
+ loop=$revision
+ while test "$loop" -ne 0; do
+ func_arith $revision - $loop
+ iface=$func_arith_result
+ func_arith $loop - 1
+ loop=$func_arith_result
+ verstring="$verstring_prefix$major.$iface:$verstring"
+ done
+
+ # Before this point, $major must not contain `.'.
+ major=.$major
+ versuffix="$major.$revision"
+ ;;
+
+ linux) # correct to gnu/linux during the next big refactor
+ func_arith $current - $age
+ major=.$func_arith_result
+ versuffix="$major.$age.$revision"
+ ;;
+
+ osf)
+ func_arith $current - $age
+ major=.$func_arith_result
+ versuffix=".$current.$age.$revision"
+ verstring="$current.$age.$revision"
+
+ # Add in all the interfaces that we are compatible with.
+ loop=$age
+ while test "$loop" -ne 0; do
+ func_arith $current - $loop
+ iface=$func_arith_result
+ func_arith $loop - 1
+ loop=$func_arith_result
+ verstring="$verstring:${iface}.0"
+ done
+
+ # Make executables depend on our current version.
+ func_append verstring ":${current}.0"
+ ;;
+
+ qnx)
+ major=".$current"
+ versuffix=".$current"
+ ;;
+
+ sunos)
+ major=".$current"
+ versuffix=".$current.$revision"
+ ;;
+
+ windows)
+ # Use '-' rather than '.', since we only want one
+ # extension on DOS 8.3 filesystems.
+ func_arith $current - $age
+ major=$func_arith_result
+ versuffix="-$major"
+ ;;
+
+ *)
+ func_fatal_configuration "unknown library version type \`$version_type'"
+ ;;
+ esac
+
+ # Clear the version info if we defaulted, and they specified a release.
+ if test -z "$vinfo" && test -n "$release"; then
+ major=
+ case $version_type in
+ darwin)
+ # we can't check for "0.0" in archive_cmds due to quoting
+ # problems, so we reset it completely
+ verstring=
+ ;;
+ *)
+ verstring="0.0"
+ ;;
+ esac
+ if test "$need_version" = no; then
+ versuffix=
+ else
+ versuffix=".0.0"
+ fi
+ fi
+
+ # Remove version info from name if versioning should be avoided
+ if test "$avoid_version" = yes && test "$need_version" = no; then
+ major=
+ versuffix=
+ verstring=""
+ fi
+
+ # Check to see if the archive will have undefined symbols.
+ if test "$allow_undefined" = yes; then
+ if test "$allow_undefined_flag" = unsupported; then
+ func_warning "undefined symbols not allowed in $host shared libraries"
+ build_libtool_libs=no
+ build_old_libs=yes
+ fi
+ else
+ # Don't allow undefined symbols.
+ allow_undefined_flag="$no_undefined_flag"
+ fi
+
+ fi
+
+ func_generate_dlsyms "$libname" "$libname" "yes"
+ func_append libobjs " $symfileobj"
+ test "X$libobjs" = "X " && libobjs=
+
+ if test "$opt_mode" != relink; then
+ # Remove our outputs, but don't remove object files since they
+ # may have been created when compiling PIC objects.
+ removelist=
+ tempremovelist=`$ECHO "$output_objdir/*"`
+ for p in $tempremovelist; do
+ case $p in
+ *.$objext | *.gcno)
+ ;;
+ $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
+ if test "X$precious_files_regex" != "X"; then
+ if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
+ then
+ continue
+ fi
+ fi
+ func_append removelist " $p"
+ ;;
+ *) ;;
+ esac
+ done
+ test -n "$removelist" && \
+ func_show_eval "${RM}r \$removelist"
+ fi
+
+ # Now set the variables for building old libraries.
+ if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
+ func_append oldlibs " $output_objdir/$libname.$libext"
+
+ # Transform .lo files to .o files.
+ oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
+ fi
+
+ # Eliminate all temporary directories.
+ #for path in $notinst_path; do
+ # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
+ # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
+ # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
+ #done
+
+ if test -n "$xrpath"; then
+ # If the user specified any rpath flags, then add them.
+ temp_xrpath=
+ for libdir in $xrpath; do
+ func_replace_sysroot "$libdir"
+ func_append temp_xrpath " -R$func_replace_sysroot_result"
+ case "$finalize_rpath " in
+ *" $libdir "*) ;;
+ *) func_append finalize_rpath " $libdir" ;;
+ esac
+ done
+ if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
+ dependency_libs="$temp_xrpath $dependency_libs"
+ fi
+ fi
+
+ # Make sure dlfiles contains only unique files that won't be dlpreopened
+ old_dlfiles="$dlfiles"
+ dlfiles=
+ for lib in $old_dlfiles; do
+ case " $dlprefiles $dlfiles " in
+ *" $lib "*) ;;
+ *) func_append dlfiles " $lib" ;;
+ esac
+ done
+
+ # Make sure dlprefiles contains only unique files
+ old_dlprefiles="$dlprefiles"
+ dlprefiles=
+ for lib in $old_dlprefiles; do
+ case "$dlprefiles " in
+ *" $lib "*) ;;
+ *) func_append dlprefiles " $lib" ;;
+ esac
+ done
+
+ if test "$build_libtool_libs" = yes; then
+ if test -n "$rpath"; then
+ case $host in
+ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
+ # these systems don't actually have a c library (as such)!
+ ;;
+ *-*-rhapsody* | *-*-darwin1.[012])
+ # Rhapsody C library is in the System framework
+ func_append deplibs " System.ltframework"
+ ;;
+ *-*-netbsd*)
+ # Don't link with libc until the a.out ld.so is fixed.
+ ;;
+ *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+ # Do not include libc due to us having libc/libc_r.
+ ;;
+ *-*-sco3.2v5* | *-*-sco5v6*)
+ # Causes problems with __ctype
+ ;;
+ *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+ # Compiler inserts libc in the correct place for threads to work
+ ;;
+ *)
+ # Add libc to deplibs on all other systems if necessary.
+ if test "$build_libtool_need_lc" = "yes"; then
+ func_append deplibs " -lc"
+ fi
+ ;;
+ esac
+ fi
+
+ # Transform deplibs into only deplibs that can be linked in shared.
+ name_save=$name
+ libname_save=$libname
+ release_save=$release
+ versuffix_save=$versuffix
+ major_save=$major
+ # I'm not sure if I'm treating the release correctly. I think
+ # release should show up in the -l (ie -lgmp5) so we don't want to
+ # add it in twice. Is that correct?
+ release=""
+ versuffix=""
+ major=""
+ newdeplibs=
+ droppeddeps=no
+ case $deplibs_check_method in
+ pass_all)
+ # Don't check for shared/static. Everything works.
+ # This might be a little naive. We might want to check
+ # whether the library exists or not. But this is on
+ # osf3 & osf4 and I'm not really sure... Just
+ # implementing what was already the behavior.
+ newdeplibs=$deplibs
+ ;;
+ test_compile)
+ # This code stresses the "libraries are programs" paradigm to its
+ # limits. Maybe even breaks it. We compile a program, linking it
+ # against the deplibs as a proxy for the library. Then we can check
+ # whether they linked in statically or dynamically with ldd.
+ $opt_dry_run || $RM conftest.c
+ cat > conftest.c <<EOF
+ int main() { return 0; }
+EOF
+ $opt_dry_run || $RM conftest
+ if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
+ ldd_output=`ldd conftest`
+ for i in $deplibs; do
+ case $i in
+ -l*)
+ func_stripname -l '' "$i"
+ name=$func_stripname_result
+ if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+ case " $predeps $postdeps " in
+ *" $i "*)
+ func_append newdeplibs " $i"
+ i=""
+ ;;
+ esac
+ fi
+ if test -n "$i" ; then
+ libname=`eval "\\$ECHO \"$libname_spec\""`
+ deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+ set dummy $deplib_matches; shift
+ deplib_match=$1
+ if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+ func_append newdeplibs " $i"
+ else
+ droppeddeps=yes
+ echo
+ $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+ 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 I believe you do not have"
+ echo "*** because a test_compile did reveal that the linker did not use it for"
+ echo "*** its dynamic dependency list that programs get resolved with at runtime."
+ fi
+ fi
+ ;;
+ *)
+ func_append newdeplibs " $i"
+ ;;
+ esac
+ done
+ else
+ # Error occurred in the first compile. Let's try to salvage
+ # the situation: Compile a separate program for each library.
+ for i in $deplibs; do
+ case $i in
+ -l*)
+ func_stripname -l '' "$i"
+ name=$func_stripname_result
+ $opt_dry_run || $RM conftest
+ if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
+ ldd_output=`ldd conftest`
+ if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+ case " $predeps $postdeps " in
+ *" $i "*)
+ func_append newdeplibs " $i"
+ i=""
+ ;;
+ esac
+ fi
+ if test -n "$i" ; then
+ libname=`eval "\\$ECHO \"$libname_spec\""`
+ deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+ set dummy $deplib_matches; shift
+ deplib_match=$1
+ if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
+ func_append newdeplibs " $i"
+ else
+ droppeddeps=yes
+ echo
+ $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+ 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 a test_compile did reveal that the linker did not use this one"
+ echo "*** as a dynamic dependency that programs can get resolved with at runtime."
+ fi
+ fi
+ else
+ droppeddeps=yes
+ echo
+ $ECHO "*** Warning! Library $i is needed by this library but I was not able to"
+ echo "*** make it link in! You will probably need to install it or some"
+ echo "*** library that it depends on before this library will be fully"
+ echo "*** functional. Installing it before continuing would be even better."
+ fi
+ ;;
+ *)
+ func_append newdeplibs " $i"
+ ;;
+ esac
+ done
+ fi
+ ;;
+ file_magic*)
+ set dummy $deplibs_check_method; shift
+ file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+ for a_deplib in $deplibs; do
+ case $a_deplib in
+ -l*)
+ func_stripname -l '' "$a_deplib"
+ name=$func_stripname_result
+ if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+ case " $predeps $postdeps " in
+ *" $a_deplib "*)
+ func_append newdeplibs " $a_deplib"
+ a_deplib=""
+ ;;
+ esac
+ fi
+ if test -n "$a_deplib" ; then
+ libname=`eval "\\$ECHO \"$libname_spec\""`
+ if test -n "$file_magic_glob"; then
+ libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
+ else
+ libnameglob=$libname
+ fi
+ test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
+ for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+ if test "$want_nocaseglob" = yes; then
+ shopt -s nocaseglob
+ potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+ $nocaseglob
+ else
+ potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
+ fi
+ for potent_lib in $potential_libs; do
+ # Follow soft links.
+ if ls -lLd "$potent_lib" 2>/dev/null |
+ $GREP " -> " >/dev/null; then
+ continue
+ fi
+ # The statement above tries to avoid entering an
+ # endless loop below, in case of cyclic links.
+ # We might still enter an endless loop, since a link
+ # loop can be closed while we follow links,
+ # but so what?
+ potlib="$potent_lib"
+ while test -h "$potlib" 2>/dev/null; do
+ potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
+ case $potliblink in
+ [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
+ *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
+ esac
+ done
+ if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
+ $SED -e 10q |
+ $EGREP "$file_magic_regex" > /dev/null; then
+ func_append newdeplibs " $a_deplib"
+ a_deplib=""
+ break 2
+ fi
+ done
+ done
+ fi
+ if test -n "$a_deplib" ; then
+ droppeddeps=yes
+ echo
+ $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+ echo "*** I have the capability to make that library automatically link in when"
+ echo "*** you link to this library. But I can only do this if you have a"
+ echo "*** shared version of the library, which you do not appear to have"
+ echo "*** because I did check the linker path looking for a file starting"
+ if test -z "$potlib" ; then
+ $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
+ else
+ $ECHO "*** with $libname and none of the candidates passed a file format test"
+ $ECHO "*** using a file magic. Last file checked: $potlib"
+ fi
+ fi
+ ;;
+ *)
+ # Add a -L argument.
+ func_append newdeplibs " $a_deplib"
+ ;;
+ esac
+ done # Gone through all deplibs.
+ ;;
+ match_pattern*)
+ set dummy $deplibs_check_method; shift
+ match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
+ for a_deplib in $deplibs; do
+ case $a_deplib in
+ -l*)
+ func_stripname -l '' "$a_deplib"
+ name=$func_stripname_result
+ if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+ case " $predeps $postdeps " in
+ *" $a_deplib "*)
+ func_append newdeplibs " $a_deplib"
+ a_deplib=""
+ ;;
+ esac
+ fi
+ if test -n "$a_deplib" ; then
+ libname=`eval "\\$ECHO \"$libname_spec\""`
+ for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+ potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
+ for potent_lib in $potential_libs; do
+ potlib="$potent_lib" # see symlink-check above in file_magic test
+ if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
+ $EGREP "$match_pattern_regex" > /dev/null; then
+ func_append newdeplibs " $a_deplib"
+ a_deplib=""
+ break 2
+ fi
+ done
+ done
+ fi
+ if test -n "$a_deplib" ; then
+ droppeddeps=yes
+ echo
+ $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+ echo "*** I have the capability to make that library automatically link in when"
+ echo "*** you link to this library. But I can only do this if you have a"
+ echo "*** shared version of the library, which you do not appear to have"
+ echo "*** because I did check the linker path looking for a file starting"
+ if test -z "$potlib" ; then
+ $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
+ else
+ $ECHO "*** with $libname and none of the candidates passed a file format test"
+ $ECHO "*** using a regex pattern. Last file checked: $potlib"
+ fi
+ fi
+ ;;
+ *)
+ # Add a -L argument.
+ func_append newdeplibs " $a_deplib"
+ ;;
+ esac
+ done # Gone through all deplibs.
+ ;;
+ none | unknown | *)
+ newdeplibs=""
+ tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
+ if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
+ for i in $predeps $postdeps ; do
+ # can't use Xsed below, because $i might contain '/'
+ tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
+ done
+ fi
+ case $tmp_deplibs in
+ *[!\ \ ]*)
+ echo
+ if test "X$deplibs_check_method" = "Xnone"; then
+ echo "*** Warning: inter-library dependencies are not supported in this platform."
+ else
+ echo "*** Warning: inter-library dependencies are not known to be supported."
+ fi
+ echo "*** All declared inter-library dependencies are being dropped."
+ droppeddeps=yes
+ ;;
+ esac
+ ;;
+ esac
+ versuffix=$versuffix_save
+ major=$major_save
+ release=$release_save
+ libname=$libname_save
+ name=$name_save
+
+ case $host in
+ *-*-rhapsody* | *-*-darwin1.[012])
+ # On Rhapsody replace the C library with the System framework
+ newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
+ ;;
+ esac
+
+ if test "$droppeddeps" = yes; then
+ if test "$module" = yes; then
+ echo
+ echo "*** Warning: libtool could not satisfy all declared inter-library"
+ $ECHO "*** dependencies of module $libname. Therefore, libtool will create"
+ echo "*** a static module, that should work as long as the dlopening"
+ echo "*** application is linked with the -dlopen flag."
+ if test -z "$global_symbol_pipe"; then
+ echo
+ echo "*** However, this would only work if libtool was able to extract symbol"
+ echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
+ echo "*** not find such a program. So, this module is probably useless."
+ echo "*** \`nm' from GNU binutils and a full rebuild may help."
+ fi
+ if test "$build_old_libs" = no; then
+ oldlibs="$output_objdir/$libname.$libext"
+ build_libtool_libs=module
+ build_old_libs=yes
+ else
+ build_libtool_libs=no
+ fi
+ else
+ echo "*** The inter-library dependencies that have been dropped here will be"
+ echo "*** automatically added whenever a program is linked with this library"
+ echo "*** or is declared to -dlopen it."
+
+ if test "$allow_undefined" = no; then
+ echo
+ echo "*** Since this library must not contain undefined symbols,"
+ echo "*** because either the platform does not support them or"
+ echo "*** it was explicitly requested with -no-undefined,"
+ echo "*** libtool will only create a static version of it."
+ if test "$build_old_libs" = no; then
+ oldlibs="$output_objdir/$libname.$libext"
+ build_libtool_libs=module
+ build_old_libs=yes
+ else
+ build_libtool_libs=no
+ fi
+ fi
+ fi
+ fi
+ # Done checking deplibs!
+ deplibs=$newdeplibs
+ fi
+ # Time to change all our "foo.ltframework" stuff back to "-framework foo"
+ case $host in
+ *-*-darwin*)
+ newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+ new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+ deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+ ;;
+ esac
+
+ # move library search paths that coincide with paths to not yet
+ # installed libraries to the beginning of the library search list
+ new_libs=
+ for path in $notinst_path; do
+ case " $new_libs " in
+ *" -L$path/$objdir "*) ;;
+ *)
+ case " $deplibs " in
+ *" -L$path/$objdir "*)
+ func_append new_libs " -L$path/$objdir" ;;
+ esac
+ ;;
+ esac
+ done
+ for deplib in $deplibs; do
+ case $deplib in
+ -L*)
+ case " $new_libs " in
+ *" $deplib "*) ;;
+ *) func_append new_libs " $deplib" ;;
+ esac
+ ;;
+ *) func_append new_libs " $deplib" ;;
+ esac
+ done
+ deplibs="$new_libs"
+
+ # All the library-specific variables (install_libdir is set above).
+ library_names=
+ old_library=
+ dlname=
+
+ # Test again, we may have decided not to build it any more
+ if test "$build_libtool_libs" = yes; then
+ # Remove ${wl} instances when linking with ld.
+ # FIXME: should test the right _cmds variable.
+ case $archive_cmds in
+ *\$LD\ *) wl= ;;
+ esac
+ if test "$hardcode_into_libs" = yes; then
+ # Hardcode the library paths
+ hardcode_libdirs=
+ dep_rpath=
+ rpath="$finalize_rpath"
+ test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
+ for libdir in $rpath; do
+ if test -n "$hardcode_libdir_flag_spec"; then
+ if test -n "$hardcode_libdir_separator"; then
+ func_replace_sysroot "$libdir"
+ libdir=$func_replace_sysroot_result
+ if test -z "$hardcode_libdirs"; then
+ hardcode_libdirs="$libdir"
+ else
+ # Just accumulate the unique libdirs.
+ case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+ *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+ ;;
+ *)
+ func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+ ;;
+ esac
+ fi
+ else
+ eval flag=\"$hardcode_libdir_flag_spec\"
+ func_append dep_rpath " $flag"
+ fi
+ elif test -n "$runpath_var"; then
+ case "$perm_rpath " in
+ *" $libdir "*) ;;
+ *) func_append perm_rpath " $libdir" ;;
+ esac
+ fi
+ done
+ # Substitute the hardcoded libdirs into the rpath.
+ if test -n "$hardcode_libdir_separator" &&
+ test -n "$hardcode_libdirs"; then
+ libdir="$hardcode_libdirs"
+ eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
+ fi
+ if test -n "$runpath_var" && test -n "$perm_rpath"; then
+ # We should set the runpath_var.
+ rpath=
+ for dir in $perm_rpath; do
+ func_append rpath "$dir:"
+ done
+ eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+ fi
+ test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
+ fi
+
+ shlibpath="$finalize_shlibpath"
+ test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
+ if test -n "$shlibpath"; then
+ eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+ fi
+
+ # Get the real and link names of the library.
+ eval shared_ext=\"$shrext_cmds\"
+ eval library_names=\"$library_names_spec\"
+ set dummy $library_names
+ shift
+ realname="$1"
+ shift
+
+ if test -n "$soname_spec"; then
+ eval soname=\"$soname_spec\"
+ else
+ soname="$realname"
+ fi
+ if test -z "$dlname"; then
+ dlname=$soname
+ fi
+
+ lib="$output_objdir/$realname"
+ linknames=
+ for link
+ do
+ func_append linknames " $link"
+ done
+
+ # Use standard objects if they are pic
+ test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+ test "X$libobjs" = "X " && libobjs=
+
+ delfiles=
+ if test -n "$export_symbols" && test -n "$include_expsyms"; then
+ $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
+ export_symbols="$output_objdir/$libname.uexp"
+ func_append delfiles " $export_symbols"
+ fi
+
+ orig_export_symbols=
+ case $host_os in
+ cygwin* | mingw* | cegcc*)
+ if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
+ # exporting using user supplied symfile
+ if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
+ # and it's NOT already a .def file. Must figure out
+ # which of the given symbols are data symbols and tag
+ # them as such. So, trigger use of export_symbols_cmds.
+ # export_symbols gets reassigned inside the "prepare
+ # the list of exported symbols" if statement, so the
+ # include_expsyms logic still works.
+ orig_export_symbols="$export_symbols"
+ export_symbols=
+ always_export_symbols=yes
+ fi
+ fi
+ ;;
+ esac
+
+ # Prepare the list of exported symbols
+ if test -z "$export_symbols"; then
+ if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
+ func_verbose "generating symbol list for \`$libname.la'"
+ export_symbols="$output_objdir/$libname.exp"
+ $opt_dry_run || $RM $export_symbols
+ cmds=$export_symbols_cmds
+ save_ifs="$IFS"; IFS='~'
+ for cmd1 in $cmds; do
+ IFS="$save_ifs"
+ # Take the normal branch if the nm_file_list_spec branch
+ # doesn't work or if tool conversion is not needed.
+ case $nm_file_list_spec~$to_tool_file_cmd in
+ *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
+ try_normal_branch=yes
+ eval cmd=\"$cmd1\"
+ func_len " $cmd"
+ len=$func_len_result
+ ;;
+ *)
+ try_normal_branch=no
+ ;;
+ esac
+ if test "$try_normal_branch" = yes \
+ && { test "$len" -lt "$max_cmd_len" \
+ || test "$max_cmd_len" -le -1; }
+ then
+ func_show_eval "$cmd" 'exit $?'
+ skipped_export=false
+ elif test -n "$nm_file_list_spec"; then
+ func_basename "$output"
+ output_la=$func_basename_result
+ save_libobjs=$libobjs
+ save_output=$output
+ output=${output_objdir}/${output_la}.nm
+ func_to_tool_file "$output"
+ libobjs=$nm_file_list_spec$func_to_tool_file_result
+ func_append delfiles " $output"
+ func_verbose "creating $NM input file list: $output"
+ for obj in $save_libobjs; do
+ func_to_tool_file "$obj"
+ $ECHO "$func_to_tool_file_result"
+ done > "$output"
+ eval cmd=\"$cmd1\"
+ func_show_eval "$cmd" 'exit $?'
+ output=$save_output
+ libobjs=$save_libobjs
+ skipped_export=false
+ else
+ # The command line is too long to execute in one step.
+ func_verbose "using reloadable object file for export list..."
+ skipped_export=:
+ # Break out early, otherwise skipped_export may be
+ # set to false by a later but shorter cmd.
+ break
+ fi
+ done
+ IFS="$save_ifs"
+ if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
+ func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+ func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+ fi
+ fi
+ fi
+
+ if test -n "$export_symbols" && test -n "$include_expsyms"; then
+ tmp_export_symbols="$export_symbols"
+ test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
+ $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+ fi
+
+ if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
+ # The given exports_symbols file has to be filtered, so filter it.
+ func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
+ # FIXME: $output_objdir/$libname.filter potentially contains lots of
+ # 's' commands which not all seds can handle. GNU sed should be fine
+ # though. Also, the filter scales superlinearly with the number of
+ # global variables. join(1) would be nice here, but unfortunately
+ # isn't a blessed tool.
+ $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+ func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+ export_symbols=$output_objdir/$libname.def
+ $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+ fi
+
+ tmp_deplibs=
+ for test_deplib in $deplibs; do
+ case " $convenience " in
+ *" $test_deplib "*) ;;
+ *)
+ func_append tmp_deplibs " $test_deplib"
+ ;;
+ esac
+ done
+ deplibs="$tmp_deplibs"
+
+ if test -n "$convenience"; then
+ if test -n "$whole_archive_flag_spec" &&
+ test "$compiler_needs_object" = yes &&
+ test -z "$libobjs"; then
+ # extract the archives, so we have objects to list.
+ # TODO: could optimize this to just extract one archive.
+ whole_archive_flag_spec=
+ fi
+ if test -n "$whole_archive_flag_spec"; then
+ save_libobjs=$libobjs
+ eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+ test "X$libobjs" = "X " && libobjs=
+ else
+ gentop="$output_objdir/${outputname}x"
+ func_append generated " $gentop"
+
+ func_extract_archives $gentop $convenience
+ func_append libobjs " $func_extract_archives_result"
+ test "X$libobjs" = "X " && libobjs=
+ fi
+ fi
+
+ if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
+ eval flag=\"$thread_safe_flag_spec\"
+ func_append linker_flags " $flag"
+ fi
+
+ # Make a backup of the uninstalled library when relinking
+ if test "$opt_mode" = relink; then
+ $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
+ fi
+
+ # Do each of the archive commands.
+ if test "$module" = yes && test -n "$module_cmds" ; then
+ if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+ eval test_cmds=\"$module_expsym_cmds\"
+ cmds=$module_expsym_cmds
+ else
+ eval test_cmds=\"$module_cmds\"
+ cmds=$module_cmds
+ fi
+ else
+ if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+ eval test_cmds=\"$archive_expsym_cmds\"
+ cmds=$archive_expsym_cmds
+ else
+ eval test_cmds=\"$archive_cmds\"
+ cmds=$archive_cmds
+ fi
+ fi
+
+ if test "X$skipped_export" != "X:" &&
+ func_len " $test_cmds" &&
+ len=$func_len_result &&
+ test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+ :
+ else
+ # The command line is too long to link in one step, link piecewise
+ # or, if using GNU ld and skipped_export is not :, use a linker
+ # script.
+
+ # Save the value of $output and $libobjs because we want to
+ # use them later. If we have whole_archive_flag_spec, we
+ # want to use save_libobjs as it was before
+ # whole_archive_flag_spec was expanded, because we can't
+ # assume the linker understands whole_archive_flag_spec.
+ # This may have to be revisited, in case too many
+ # convenience libraries get linked in and end up exceeding
+ # the spec.
+ if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
+ save_libobjs=$libobjs
+ fi
+ save_output=$output
+ func_basename "$output"
+ output_la=$func_basename_result
+
+ # Clear the reloadable object creation command queue and
+ # initialize k to one.
+ test_cmds=
+ concat_cmds=
+ objlist=
+ last_robj=
+ k=1
+
+ if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
+ output=${output_objdir}/${output_la}.lnkscript
+ func_verbose "creating GNU ld script: $output"
+ echo 'INPUT (' > $output
+ for obj in $save_libobjs
+ do
+ func_to_tool_file "$obj"
+ $ECHO "$func_to_tool_file_result" >> $output
+ done
+ echo ')' >> $output
+ func_append delfiles " $output"
+ func_to_tool_file "$output"
+ output=$func_to_tool_file_result
+ elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
+ output=${output_objdir}/${output_la}.lnk
+ func_verbose "creating linker input file list: $output"
+ : > $output
+ set x $save_libobjs
+ shift
+ firstobj=
+ if test "$compiler_needs_object" = yes; then
+ firstobj="$1 "
+ shift
+ fi
+ for obj
+ do
+ func_to_tool_file "$obj"
+ $ECHO "$func_to_tool_file_result" >> $output
+ done
+ func_append delfiles " $output"
+ func_to_tool_file "$output"
+ output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
+ else
+ if test -n "$save_libobjs"; then
+ func_verbose "creating reloadable object files..."
+ output=$output_objdir/$output_la-${k}.$objext
+ eval test_cmds=\"$reload_cmds\"
+ func_len " $test_cmds"
+ len0=$func_len_result
+ len=$len0
+
+ # Loop over the list of objects to be linked.
+ for obj in $save_libobjs
+ do
+ func_len " $obj"
+ func_arith $len + $func_len_result
+ len=$func_arith_result
+ if test "X$objlist" = X ||
+ test "$len" -lt "$max_cmd_len"; then
+ func_append objlist " $obj"
+ else
+ # The command $test_cmds is almost too long, add a
+ # command to the queue.
+ if test "$k" -eq 1 ; then
+ # The first file doesn't have a previous command to add.
+ reload_objs=$objlist
+ eval concat_cmds=\"$reload_cmds\"
+ else
+ # All subsequent reloadable object files will link in
+ # the last one created.
+ reload_objs="$objlist $last_robj"
+ eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
+ fi
+ last_robj=$output_objdir/$output_la-${k}.$objext
+ func_arith $k + 1
+ k=$func_arith_result
+ output=$output_objdir/$output_la-${k}.$objext
+ objlist=" $obj"
+ func_len " $last_robj"
+ func_arith $len0 + $func_len_result
+ len=$func_arith_result
+ fi
+ done
+ # Handle the remaining objects by creating one last
+ # reloadable object file. All subsequent reloadable object
+ # files will link in the last one created.
+ test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+ reload_objs="$objlist $last_robj"
+ eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
+ if test -n "$last_robj"; then
+ eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
+ fi
+ func_append delfiles " $output"
+
+ else
+ output=
+ fi
+
+ if ${skipped_export-false}; then
+ func_verbose "generating symbol list for \`$libname.la'"
+ export_symbols="$output_objdir/$libname.exp"
+ $opt_dry_run || $RM $export_symbols
+ libobjs=$output
+ # Append the command to create the export file.
+ test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+ eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
+ if test -n "$last_robj"; then
+ eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+ fi
+ fi
+
+ test -n "$save_libobjs" &&
+ func_verbose "creating a temporary reloadable object file: $output"
+
+ # Loop through the commands generated above and execute them.
+ save_ifs="$IFS"; IFS='~'
+ for cmd in $concat_cmds; do
+ IFS="$save_ifs"
+ $opt_silent || {
+ func_quote_for_expand "$cmd"
+ eval "func_echo $func_quote_for_expand_result"
+ }
+ $opt_dry_run || eval "$cmd" || {
+ lt_exit=$?
+
+ # Restore the uninstalled library and exit
+ if test "$opt_mode" = relink; then
+ ( cd "$output_objdir" && \
+ $RM "${realname}T" && \
+ $MV "${realname}U" "$realname" )
+ fi
+
+ exit $lt_exit
+ }
+ done
+ IFS="$save_ifs"
+
+ if test -n "$export_symbols_regex" && ${skipped_export-false}; then
+ func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+ func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+ fi
+ fi
+
+ if ${skipped_export-false}; then
+ if test -n "$export_symbols" && test -n "$include_expsyms"; then
+ tmp_export_symbols="$export_symbols"
+ test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
+ $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+ fi
+
+ if test -n "$orig_export_symbols"; then
+ # The given exports_symbols file has to be filtered, so filter it.
+ func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
+ # FIXME: $output_objdir/$libname.filter potentially contains lots of
+ # 's' commands which not all seds can handle. GNU sed should be fine
+ # though. Also, the filter scales superlinearly with the number of
+ # global variables. join(1) would be nice here, but unfortunately
+ # isn't a blessed tool.
+ $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+ func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+ export_symbols=$output_objdir/$libname.def
+ $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+ fi
+ fi
+
+ libobjs=$output
+ # Restore the value of output.
+ output=$save_output
+
+ if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
+ eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+ test "X$libobjs" = "X " && libobjs=
+ fi
+ # Expand the library linking commands again to reset the
+ # value of $libobjs for piecewise linking.
+
+ # Do each of the archive commands.
+ if test "$module" = yes && test -n "$module_cmds" ; then
+ if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+ cmds=$module_expsym_cmds
+ else
+ cmds=$module_cmds
+ fi
+ else
+ if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+ cmds=$archive_expsym_cmds
+ else
+ cmds=$archive_cmds
+ fi
+ fi
+ fi
+
+ if test -n "$delfiles"; then
+ # Append the command to remove temporary files to $cmds.
+ eval cmds=\"\$cmds~\$RM $delfiles\"
+ fi
+
+ # Add any objects from preloaded convenience libraries
+ if test -n "$dlprefiles"; then
+ gentop="$output_objdir/${outputname}x"
+ func_append generated " $gentop"
+
+ func_extract_archives $gentop $dlprefiles
+ func_append libobjs " $func_extract_archives_result"
+ test "X$libobjs" = "X " && libobjs=
+ fi
+
+ save_ifs="$IFS"; IFS='~'
+ for cmd in $cmds; do
+ IFS="$save_ifs"
+ eval cmd=\"$cmd\"
+ $opt_silent || {
+ func_quote_for_expand "$cmd"
+ eval "func_echo $func_quote_for_expand_result"
+ }
+ $opt_dry_run || eval "$cmd" || {
+ lt_exit=$?
+
+ # Restore the uninstalled library and exit
+ if test "$opt_mode" = relink; then
+ ( cd "$output_objdir" && \
+ $RM "${realname}T" && \
+ $MV "${realname}U" "$realname" )
+ fi
+
+ exit $lt_exit
+ }
+ done
+ IFS="$save_ifs"
+
+ # Restore the uninstalled library and exit
+ if test "$opt_mode" = relink; then
+ $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
+
+ if test -n "$convenience"; then
+ if test -z "$whole_archive_flag_spec"; then
+ func_show_eval '${RM}r "$gentop"'
+ fi
+ fi
+
+ exit $EXIT_SUCCESS
+ fi
+
+ # Create links to the real library.
+ for linkname in $linknames; do
+ if test "$realname" != "$linkname"; then
+ func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
+ fi
+ done
+
+ # If -module or -export-dynamic was specified, set the dlname.
+ if test "$module" = yes || test "$export_dynamic" = yes; then
+ # On all known operating systems, these are identical.
+ dlname="$soname"
+ fi
+ fi
+ ;;
+
+ obj)
+ if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
+ func_warning "\`-dlopen' is ignored for objects"
+ fi
+
+ case " $deplibs" in
+ *\ -l* | *\ -L*)
+ func_warning "\`-l' and \`-L' are ignored for objects" ;;
+ esac
+
+ test -n "$rpath" && \
+ func_warning "\`-rpath' is ignored for objects"
+
+ test -n "$xrpath" && \
+ func_warning "\`-R' is ignored for objects"
+
+ test -n "$vinfo" && \
+ func_warning "\`-version-info' is ignored for objects"
+
+ test -n "$release" && \
+ func_warning "\`-release' is ignored for objects"
+
+ case $output in
+ *.lo)
+ test -n "$objs$old_deplibs" && \
+ func_fatal_error "cannot build library object \`$output' from non-libtool objects"
+
+ libobj=$output
+ func_lo2o "$libobj"
+ obj=$func_lo2o_result
+ ;;
+ *)
+ libobj=
+ obj="$output"
+ ;;
+ esac
+
+ # Delete the old objects.
+ $opt_dry_run || $RM $obj $libobj
+
+ # Objects from convenience libraries. This assumes
+ # single-version convenience libraries. Whenever we create
+ # different ones for PIC/non-PIC, this we'll have to duplicate
+ # the extraction.
+ reload_conv_objs=
+ gentop=
+ # reload_cmds runs $LD directly, so let us get rid of
+ # -Wl from whole_archive_flag_spec and hope we can get by with
+ # turning comma into space..
+ wl=
+
+ if test -n "$convenience"; then
+ if test -n "$whole_archive_flag_spec"; then
+ eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
+ reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+ else
+ gentop="$output_objdir/${obj}x"
+ func_append generated " $gentop"
+
+ func_extract_archives $gentop $convenience
+ reload_conv_objs="$reload_objs $func_extract_archives_result"
+ fi
+ fi
+
+ # If we're not building shared, we need to use non_pic_objs
+ test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
+
+ # Create the old-style object.
+ reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
+
+ output="$obj"
+ func_execute_cmds "$reload_cmds" 'exit $?'
+
+ # Exit if we aren't doing a library object file.
+ if test -z "$libobj"; then
+ if test -n "$gentop"; then
+ func_show_eval '${RM}r "$gentop"'
+ fi
+
+ exit $EXIT_SUCCESS
+ fi
+
+ if test "$build_libtool_libs" != yes; then
+ if test -n "$gentop"; then
+ func_show_eval '${RM}r "$gentop"'
+ fi
+
+ # Create an invalid libtool object if no PIC, so that we don't
+ # accidentally link it into a program.
+ # $show "echo timestamp > $libobj"
+ # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
+ exit $EXIT_SUCCESS
+ fi
+
+ if test -n "$pic_flag" || test "$pic_mode" != default; then
+ # Only do commands if we really have different PIC objects.
+ reload_objs="$libobjs $reload_conv_objs"
+ output="$libobj"
+ func_execute_cmds "$reload_cmds" 'exit $?'
+ fi
+
+ if test -n "$gentop"; then
+ func_show_eval '${RM}r "$gentop"'
+ fi
+
+ exit $EXIT_SUCCESS
+ ;;
+
+ prog)
+ case $host in
+ *cygwin*) func_stripname '' '.exe' "$output"
+ output=$func_stripname_result.exe;;
+ esac
+ test -n "$vinfo" && \
+ func_warning "\`-version-info' is ignored for programs"
+
+ test -n "$release" && \
+ func_warning "\`-release' is ignored for programs"
+
+ test "$preload" = yes \
+ && test "$dlopen_support" = unknown \
+ && test "$dlopen_self" = unknown \
+ && test "$dlopen_self_static" = unknown && \
+ func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
+
+ case $host in
+ *-*-rhapsody* | *-*-darwin1.[012])
+ # On Rhapsody replace the C library is the System framework
+ compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
+ finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
+ ;;
+ esac
+
+ case $host in
+ *-*-darwin*)
+ # Don't allow lazy linking, it breaks C++ global constructors
+ # But is supposedly fixed on 10.4 or later (yay!).
+ if test "$tagname" = CXX ; then
+ case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
+ 10.[0123])
+ func_append compile_command " ${wl}-bind_at_load"
+ func_append finalize_command " ${wl}-bind_at_load"
+ ;;
+ esac
+ fi
+ # Time to change all our "foo.ltframework" stuff back to "-framework foo"
+ compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+ finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
+ ;;
+ esac
+
+
+ # move library search paths that coincide with paths to not yet
+ # installed libraries to the beginning of the library search list
+ new_libs=
+ for path in $notinst_path; do
+ case " $new_libs " in
+ *" -L$path/$objdir "*) ;;
+ *)
+ case " $compile_deplibs " in
+ *" -L$path/$objdir "*)
+ func_append new_libs " -L$path/$objdir" ;;
+ esac
+ ;;
+ esac
+ done
+ for deplib in $compile_deplibs; do
+ case $deplib in
+ -L*)
+ case " $new_libs " in
+ *" $deplib "*) ;;
+ *) func_append new_libs " $deplib" ;;
+ esac
+ ;;
+ *) func_append new_libs " $deplib" ;;
+ esac
+ done
+ compile_deplibs="$new_libs"
+
+
+ func_append compile_command " $compile_deplibs"
+ func_append finalize_command " $finalize_deplibs"
+
+ if test -n "$rpath$xrpath"; then
+ # If the user specified any rpath flags, then add them.
+ for libdir in $rpath $xrpath; do
+ # This is the magic to use -rpath.
+ case "$finalize_rpath " in
+ *" $libdir "*) ;;
+ *) func_append finalize_rpath " $libdir" ;;
+ esac
+ done
+ fi
+
+ # Now hardcode the library paths
+ rpath=
+ hardcode_libdirs=
+ for libdir in $compile_rpath $finalize_rpath; do
+ if test -n "$hardcode_libdir_flag_spec"; then
+ if test -n "$hardcode_libdir_separator"; then
+ if test -z "$hardcode_libdirs"; then
+ hardcode_libdirs="$libdir"
+ else
+ # Just accumulate the unique libdirs.
+ case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+ *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+ ;;
+ *)
+ func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+ ;;
+ esac
+ fi
+ else
+ eval flag=\"$hardcode_libdir_flag_spec\"
+ func_append rpath " $flag"
+ fi
+ elif test -n "$runpath_var"; then
+ case "$perm_rpath " in
+ *" $libdir "*) ;;
+ *) func_append perm_rpath " $libdir" ;;
+ esac
+ fi
+ case $host in
+ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+ testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
+ case :$dllsearchpath: in
+ *":$libdir:"*) ;;
+ ::) dllsearchpath=$libdir;;
+ *) func_append dllsearchpath ":$libdir";;
+ esac
+ case :$dllsearchpath: in
+ *":$testbindir:"*) ;;
+ ::) dllsearchpath=$testbindir;;
+ *) func_append dllsearchpath ":$testbindir";;
+ esac
+ ;;
+ esac
+ done
+ # Substitute the hardcoded libdirs into the rpath.
+ if test -n "$hardcode_libdir_separator" &&
+ test -n "$hardcode_libdirs"; then
+ libdir="$hardcode_libdirs"
+ eval rpath=\" $hardcode_libdir_flag_spec\"
+ fi
+ compile_rpath="$rpath"
+
+ rpath=
+ hardcode_libdirs=
+ for libdir in $finalize_rpath; do
+ if test -n "$hardcode_libdir_flag_spec"; then
+ if test -n "$hardcode_libdir_separator"; then
+ if test -z "$hardcode_libdirs"; then
+ hardcode_libdirs="$libdir"
+ else
+ # Just accumulate the unique libdirs.
+ case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+ *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+ ;;
+ *)
+ func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+ ;;
+ esac
+ fi
+ else
+ eval flag=\"$hardcode_libdir_flag_spec\"
+ func_append rpath " $flag"
+ fi
+ elif test -n "$runpath_var"; then
+ case "$finalize_perm_rpath " in
+ *" $libdir "*) ;;
+ *) func_append finalize_perm_rpath " $libdir" ;;
+ esac
+ fi
+ done
+ # Substitute the hardcoded libdirs into the rpath.
+ if test -n "$hardcode_libdir_separator" &&
+ test -n "$hardcode_libdirs"; then
+ libdir="$hardcode_libdirs"
+ eval rpath=\" $hardcode_libdir_flag_spec\"
+ fi
+ finalize_rpath="$rpath"
+
+ if test -n "$libobjs" && test "$build_old_libs" = yes; then
+ # Transform all the library objects into standard objects.
+ compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+ finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+ fi
+
+ func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
+
+ # template prelinking step
+ if test -n "$prelink_cmds"; then
+ func_execute_cmds "$prelink_cmds" 'exit $?'
+ fi
+
+ wrappers_required=yes
+ case $host in
+ *cegcc* | *mingw32ce*)
+ # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
+ wrappers_required=no
+ ;;
+ *cygwin* | *mingw* )
+ if test "$build_libtool_libs" != yes; then
+ wrappers_required=no
+ fi
+ ;;
+ *)
+ if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
+ wrappers_required=no
+ fi
+ ;;
+ esac
+ if test "$wrappers_required" = no; then
+ # Replace the output file specification.
+ compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+ link_command="$compile_command$compile_rpath"
+
+ # We have no uninstalled library dependencies, so finalize right now.
+ exit_status=0
+ func_show_eval "$link_command" 'exit_status=$?'
+
+ if test -n "$postlink_cmds"; then
+ func_to_tool_file "$output"
+ postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+ func_execute_cmds "$postlink_cmds" 'exit $?'
+ fi
+
+ # Delete the generated files.
+ if test -f "$output_objdir/${outputname}S.${objext}"; then
+ func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
+ fi
+
+ exit $exit_status
+ fi
+
+ if test -n "$compile_shlibpath$finalize_shlibpath"; then
+ compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+ fi
+ if test -n "$finalize_shlibpath"; then
+ finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+ fi
+
+ compile_var=
+ finalize_var=
+ if test -n "$runpath_var"; then
+ if test -n "$perm_rpath"; then
+ # We should set the runpath_var.
+ rpath=
+ for dir in $perm_rpath; do
+ func_append rpath "$dir:"
+ done
+ compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+ fi
+ if test -n "$finalize_perm_rpath"; then
+ # We should set the runpath_var.
+ rpath=
+ for dir in $finalize_perm_rpath; do
+ func_append rpath "$dir:"
+ done
+ finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+ fi
+ fi
+
+ if test "$no_install" = yes; then
+ # We don't need to create a wrapper script.
+ link_command="$compile_var$compile_command$compile_rpath"
+ # Replace the output file specification.
+ link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+ # Delete the old output file.
+ $opt_dry_run || $RM $output
+ # Link the executable and exit
+ func_show_eval "$link_command" 'exit $?'
+
+ if test -n "$postlink_cmds"; then
+ func_to_tool_file "$output"
+ postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+ func_execute_cmds "$postlink_cmds" 'exit $?'
+ fi
+
+ exit $EXIT_SUCCESS
+ fi
+
+ if test "$hardcode_action" = relink; then
+ # Fast installation is not supported
+ link_command="$compile_var$compile_command$compile_rpath"
+ relink_command="$finalize_var$finalize_command$finalize_rpath"
+
+ func_warning "this platform does not like uninstalled shared libraries"
+ func_warning "\`$output' will be relinked during installation"
+ else
+ if test "$fast_install" != no; then
+ link_command="$finalize_var$compile_command$finalize_rpath"
+ if test "$fast_install" = yes; then
+ relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
+ else
+ # fast_install is set to needless
+ relink_command=
+ fi
+ else
+ link_command="$compile_var$compile_command$compile_rpath"
+ relink_command="$finalize_var$finalize_command$finalize_rpath"
+ fi
+ fi
+
+ # Replace the output file specification.
+ link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+
+ # Delete the old output files.
+ $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+ func_show_eval "$link_command" 'exit $?'
+
+ if test -n "$postlink_cmds"; then
+ func_to_tool_file "$output_objdir/$outputname"
+ postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+ func_execute_cmds "$postlink_cmds" 'exit $?'
+ fi
+
+ # Now create the wrapper script.
+ func_verbose "creating $output"
+
+ # Quote the relink command for shipping.
+ if test -n "$relink_command"; then
+ # Preserve any variables that may affect compiler behavior
+ for var in $variables_saved_for_relink; do
+ if eval test -z \"\${$var+set}\"; then
+ relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+ elif eval var_value=\$$var; test -z "$var_value"; then
+ relink_command="$var=; export $var; $relink_command"
+ else
+ func_quote_for_eval "$var_value"
+ relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+ fi
+ done
+ relink_command="(cd `pwd`; $relink_command)"
+ relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+ fi
+
+ # Only actually do things if not in dry run mode.
+ $opt_dry_run || {
+ # win32 will think the script is a binary if it has
+ # a .exe suffix, so we strip it off here.
+ case $output in
+ *.exe) func_stripname '' '.exe' "$output"
+ output=$func_stripname_result ;;
+ esac
+ # test for cygwin because mv fails w/o .exe extensions
+ case $host in
+ *cygwin*)
+ exeext=.exe
+ func_stripname '' '.exe' "$outputname"
+ outputname=$func_stripname_result ;;
+ *) exeext= ;;
+ esac
+ case $host in
+ *cygwin* | *mingw* )
+ func_dirname_and_basename "$output" "" "."
+ output_name=$func_basename_result
+ output_path=$func_dirname_result
+ cwrappersource="$output_path/$objdir/lt-$output_name.c"
+ cwrapper="$output_path/$output_name.exe"
+ $RM $cwrappersource $cwrapper
+ trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+
+ func_emit_cwrapperexe_src > $cwrappersource
+
+ # The wrapper executable is built using the $host compiler,
+ # because it contains $host paths and files. If cross-
+ # compiling, it, like the target executable, must be
+ # executed on the $host or under an emulation environment.
+ $opt_dry_run || {
+ $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
+ $STRIP $cwrapper
+ }
+
+ # Now, create the wrapper script for func_source use:
+ func_ltwrapper_scriptname $cwrapper
+ $RM $func_ltwrapper_scriptname_result
+ trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
+ $opt_dry_run || {
+ # note: this script will not be executed, so do not chmod.
+ if test "x$build" = "x$host" ; then
+ $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
+ else
+ func_emit_wrapper no > $func_ltwrapper_scriptname_result
+ fi
+ }
+ ;;
+ * )
+ $RM $output
+ trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
+
+ func_emit_wrapper no > $output
+ chmod +x $output
+ ;;
+ esac
+ }
+ exit $EXIT_SUCCESS
+ ;;
+ esac
+
+ # See if we need to build an old-fashioned archive.
+ for oldlib in $oldlibs; do
+
+ if test "$build_libtool_libs" = convenience; then
+ oldobjs="$libobjs_save $symfileobj"
+ addlibs="$convenience"
+ build_libtool_libs=no
+ else
+ if test "$build_libtool_libs" = module; then
+ oldobjs="$libobjs_save"
+ build_libtool_libs=no
+ else
+ oldobjs="$old_deplibs $non_pic_objects"
+ if test "$preload" = yes && test -f "$symfileobj"; then
+ func_append oldobjs " $symfileobj"
+ fi
+ fi
+ addlibs="$old_convenience"
+ fi
+
+ if test -n "$addlibs"; then
+ gentop="$output_objdir/${outputname}x"
+ func_append generated " $gentop"
+
+ func_extract_archives $gentop $addlibs
+ func_append oldobjs " $func_extract_archives_result"
+ fi
+
+ # Do each command in the archive commands.
+ if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
+ cmds=$old_archive_from_new_cmds
+ else
+
+ # Add any objects from preloaded convenience libraries
+ if test -n "$dlprefiles"; then
+ gentop="$output_objdir/${outputname}x"
+ func_append generated " $gentop"
+
+ func_extract_archives $gentop $dlprefiles
+ func_append oldobjs " $func_extract_archives_result"
+ fi
+
+ # POSIX demands no paths to be encoded in archives. We have
+ # to avoid creating archives with duplicate basenames if we
+ # might have to extract them afterwards, e.g., when creating a
+ # static archive out of a convenience library, or when linking
+ # the entirety of a libtool archive into another (currently
+ # not supported by libtool).
+ if (for obj in $oldobjs
+ do
+ func_basename "$obj"
+ $ECHO "$func_basename_result"
+ done | sort | sort -uc >/dev/null 2>&1); then
+ :
+ else
+ echo "copying selected object files to avoid basename conflicts..."
+ gentop="$output_objdir/${outputname}x"
+ func_append generated " $gentop"
+ func_mkdir_p "$gentop"
+ save_oldobjs=$oldobjs
+ oldobjs=
+ counter=1
+ for obj in $save_oldobjs
+ do
+ func_basename "$obj"
+ objbase="$func_basename_result"
+ case " $oldobjs " in
+ " ") oldobjs=$obj ;;
+ *[\ /]"$objbase "*)
+ while :; do
+ # Make sure we don't pick an alternate name that also
+ # overlaps.
+ newobj=lt$counter-$objbase
+ func_arith $counter + 1
+ counter=$func_arith_result
+ case " $oldobjs " in
+ *[\ /]"$newobj "*) ;;
+ *) if test ! -f "$gentop/$newobj"; then break; fi ;;
+ esac
+ done
+ func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+ func_append oldobjs " $gentop/$newobj"
+ ;;
+ *) func_append oldobjs " $obj" ;;
+ esac
+ done
+ fi
+ func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+ tool_oldlib=$func_to_tool_file_result
+ eval cmds=\"$old_archive_cmds\"
+
+ func_len " $cmds"
+ len=$func_len_result
+ if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+ cmds=$old_archive_cmds
+ elif test -n "$archiver_list_spec"; then
+ func_verbose "using command file archive linking..."
+ for obj in $oldobjs
+ do
+ func_to_tool_file "$obj"
+ $ECHO "$func_to_tool_file_result"
+ done > $output_objdir/$libname.libcmd
+ func_to_tool_file "$output_objdir/$libname.libcmd"
+ oldobjs=" $archiver_list_spec$func_to_tool_file_result"
+ cmds=$old_archive_cmds
+ else
+ # the command line is too long to link in one step, link in parts
+ func_verbose "using piecewise archive linking..."
+ save_RANLIB=$RANLIB
+ RANLIB=:
+ objlist=
+ concat_cmds=
+ save_oldobjs=$oldobjs
+ oldobjs=
+ # Is there a better way of finding the last object in the list?
+ for obj in $save_oldobjs
+ do
+ last_oldobj=$obj
+ done
+ eval test_cmds=\"$old_archive_cmds\"
+ func_len " $test_cmds"
+ len0=$func_len_result
+ len=$len0
+ for obj in $save_oldobjs
+ do
+ func_len " $obj"
+ func_arith $len + $func_len_result
+ len=$func_arith_result
+ func_append objlist " $obj"
+ if test "$len" -lt "$max_cmd_len"; then
+ :
+ else
+ # the above command should be used before it gets too long
+ oldobjs=$objlist
+ if test "$obj" = "$last_oldobj" ; then
+ RANLIB=$save_RANLIB
+ fi
+ test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+ eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
+ objlist=
+ len=$len0
+ fi
+ done
+ RANLIB=$save_RANLIB
+ oldobjs=$objlist
+ if test "X$oldobjs" = "X" ; then
+ eval cmds=\"\$concat_cmds\"
+ else
+ eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+ fi
+ fi
+ fi
+ func_execute_cmds "$cmds" 'exit $?'
+ done
+
+ test -n "$generated" && \
+ func_show_eval "${RM}r$generated"
+
+ # Now create the libtool archive.
+ case $output in
+ *.la)
+ old_library=
+ test "$build_old_libs" = yes && old_library="$libname.$libext"
+ func_verbose "creating $output"
+
+ # Preserve any variables that may affect compiler behavior
+ for var in $variables_saved_for_relink; do
+ if eval test -z \"\${$var+set}\"; then
+ relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+ elif eval var_value=\$$var; test -z "$var_value"; then
+ relink_command="$var=; export $var; $relink_command"
+ else
+ func_quote_for_eval "$var_value"
+ relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+ fi
+ done
+ # Quote the link command for shipping.
+ relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+ relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+ if test "$hardcode_automatic" = yes ; then
+ relink_command=
+ fi
+
+ # Only create the output if not a dry run.
+ $opt_dry_run || {
+ for installed in no yes; do
+ if test "$installed" = yes; then
+ if test -z "$install_libdir"; then
+ break
+ fi
+ output="$output_objdir/$outputname"i
+ # Replace all uninstalled libtool libraries with the installed ones
+ newdependency_libs=
+ for deplib in $dependency_libs; do
+ case $deplib in
+ *.la)
+ func_basename "$deplib"
+ name="$func_basename_result"
+ func_resolve_sysroot "$deplib"
+ eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
+ test -z "$libdir" && \
+ func_fatal_error "\`$deplib' is not a valid libtool archive"
+ func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
+ ;;
+ -L*)
+ func_stripname -L '' "$deplib"
+ func_replace_sysroot "$func_stripname_result"
+ func_append newdependency_libs " -L$func_replace_sysroot_result"
+ ;;
+ -R*)
+ func_stripname -R '' "$deplib"
+ func_replace_sysroot "$func_stripname_result"
+ func_append newdependency_libs " -R$func_replace_sysroot_result"
+ ;;
+ *) func_append newdependency_libs " $deplib" ;;
+ esac
+ done
+ dependency_libs="$newdependency_libs"
+ newdlfiles=
+
+ for lib in $dlfiles; do
+ case $lib in
+ *.la)
+ func_basename "$lib"
+ name="$func_basename_result"
+ eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+ test -z "$libdir" && \
+ func_fatal_error "\`$lib' is not a valid libtool archive"
+ func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
+ ;;
+ *) func_append newdlfiles " $lib" ;;
+ esac
+ done
+ dlfiles="$newdlfiles"
+ newdlprefiles=
+ for lib in $dlprefiles; do
+ case $lib in
+ *.la)
+ # Only pass preopened files to the pseudo-archive (for
+ # eventual linking with the app. that links it) if we
+ # didn't already link the preopened objects directly into
+ # the library:
+ func_basename "$lib"
+ name="$func_basename_result"
+ eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
+ test -z "$libdir" && \
+ func_fatal_error "\`$lib' is not a valid libtool archive"
+ func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
+ ;;
+ esac
+ done
+ dlprefiles="$newdlprefiles"
+ else
+ newdlfiles=
+ for lib in $dlfiles; do
+ case $lib in
+ [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+ *) abs=`pwd`"/$lib" ;;
+ esac
+ func_append newdlfiles " $abs"
+ done
+ dlfiles="$newdlfiles"
+ newdlprefiles=
+ for lib in $dlprefiles; do
+ case $lib in
+ [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
+ *) abs=`pwd`"/$lib" ;;
+ esac
+ func_append newdlprefiles " $abs"
+ done
+ dlprefiles="$newdlprefiles"
+ fi
+ $RM $output
+ # place dlname in correct position for cygwin
+ # In fact, it would be nice if we could use this code for all target
+ # systems that can't hard-code library paths into their executables
+ # and that have no shared library path variable independent of PATH,
+ # but it turns out we can't easily determine that from inspecting
+ # libtool variables, so we have to hard-code the OSs to which it
+ # applies here; at the moment, that means platforms that use the PE
+ # object format with DLL files. See the long comment at the top of
+ # tests/bindir.at for full details.
+ tdlname=$dlname
+ case $host,$output,$installed,$module,$dlname in
+ *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
+ # If a -bindir argument was supplied, place the dll there.
+ if test "x$bindir" != x ;
+ then
+ func_relative_path "$install_libdir" "$bindir"
+ tdlname=$func_relative_path_result$dlname
+ else
+ # Otherwise fall back on heuristic.
+ tdlname=../bin/$dlname
+ fi
+ ;;
+ esac
+ $ECHO > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$tdlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Linker flags that can not go in dependency_libs.
+inherited_linker_flags='$new_inherited_linker_flags'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Names of additional weak libraries provided by this library
+weak_library_names='$weak_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=$module
+
+# Files to dlopen/dlpreopen
+dlopen='$dlfiles'
+dlpreopen='$dlprefiles'
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'"
+ if test "$installed" = no && test "$need_relink" = yes; then
+ $ECHO >> $output "\
+relink_command=\"$relink_command\""
+ fi
+ done
+ }
+
+ # Do a symbolic link so that the libtool archive can be found in
+ # LD_LIBRARY_PATH before the program is installed.
+ func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
+ ;;
+ esac
+ exit $EXIT_SUCCESS
+}
+
+{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
+ func_mode_link ${1+"$@"}
+
+
+# func_mode_uninstall arg...
+func_mode_uninstall ()
+{
+ $opt_debug
+ RM="$nonopt"
+ files=
+ rmforce=
+ exit_status=0
+
+ # This variable tells wrapper scripts just to set variables rather
+ # than running their programs.
+ libtool_install_magic="$magic"
+
+ for arg
+ do
+ case $arg in
+ -f) func_append RM " $arg"; rmforce=yes ;;
+ -*) func_append RM " $arg" ;;
+ *) func_append files " $arg" ;;
+ esac
+ done
+
+ test -z "$RM" && \
+ func_fatal_help "you must specify an RM program"
+
+ rmdirs=
+
+ for file in $files; do
+ func_dirname "$file" "" "."
+ dir="$func_dirname_result"
+ if test "X$dir" = X.; then
+ odir="$objdir"
+ else
+ odir="$dir/$objdir"
+ fi
+ func_basename "$file"
+ name="$func_basename_result"
+ test "$opt_mode" = uninstall && odir="$dir"
+
+ # Remember odir for removal later, being careful to avoid duplicates
+ if test "$opt_mode" = clean; then
+ case " $rmdirs " in
+ *" $odir "*) ;;
+ *) func_append rmdirs " $odir" ;;
+ esac
+ fi
+
+ # Don't error if the file doesn't exist and rm -f was used.
+ if { test -L "$file"; } >/dev/null 2>&1 ||
+ { test -h "$file"; } >/dev/null 2>&1 ||
+ test -f "$file"; then
+ :
+ elif test -d "$file"; then
+ exit_status=1
+ continue
+ elif test "$rmforce" = yes; then
+ continue
+ fi
+
+ rmfiles="$file"
+
+ case $name in
+ *.la)
+ # Possibly a libtool archive, so verify it.
+ if func_lalib_p "$file"; then
+ func_source $dir/$name
+
+ # Delete the libtool libraries and symlinks.
+ for n in $library_names; do
+ func_append rmfiles " $odir/$n"
+ done
+ test -n "$old_library" && func_append rmfiles " $odir/$old_library"
+
+ case "$opt_mode" in
+ clean)
+ case " $library_names " in
+ *" $dlname "*) ;;
+ *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
+ esac
+ test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
+ ;;
+ uninstall)
+ if test -n "$library_names"; then
+ # Do each command in the postuninstall commands.
+ func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
+ fi
+
+ if test -n "$old_library"; then
+ # Do each command in the old_postuninstall commands.
+ func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
+ fi
+ # FIXME: should reinstall the best remaining shared library.
+ ;;
+ esac
+ fi
+ ;;
+
+ *.lo)
+ # Possibly a libtool object, so verify it.
+ if func_lalib_p "$file"; then
+
+ # Read the .lo file
+ func_source $dir/$name
+
+ # Add PIC object to the list of files to remove.
+ if test -n "$pic_object" &&
+ test "$pic_object" != none; then
+ func_append rmfiles " $dir/$pic_object"
+ fi
+
+ # Add non-PIC object to the list of files to remove.
+ if test -n "$non_pic_object" &&
+ test "$non_pic_object" != none; then
+ func_append rmfiles " $dir/$non_pic_object"
+ fi
+ fi
+ ;;
+
+ *)
+ if test "$opt_mode" = clean ; then
+ noexename=$name
+ case $file in
+ *.exe)
+ func_stripname '' '.exe' "$file"
+ file=$func_stripname_result
+ func_stripname '' '.exe' "$name"
+ noexename=$func_stripname_result
+ # $file with .exe has already been added to rmfiles,
+ # add $file without .exe
+ func_append rmfiles " $file"
+ ;;
+ esac
+ # Do a test to see if this is a libtool program.
+ if func_ltwrapper_p "$file"; then
+ if func_ltwrapper_executable_p "$file"; then
+ func_ltwrapper_scriptname "$file"
+ relink_command=
+ func_source $func_ltwrapper_scriptname_result
+ func_append rmfiles " $func_ltwrapper_scriptname_result"
+ else
+ relink_command=
+ func_source $dir/$noexename
+ fi
+
+ # note $name still contains .exe if it was in $file originally
+ # as does the version of $file that was added into $rmfiles
+ func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
+ if test "$fast_install" = yes && test -n "$relink_command"; then
+ func_append rmfiles " $odir/lt-$name"
+ fi
+ if test "X$noexename" != "X$name" ; then
+ func_append rmfiles " $odir/lt-${noexename}.c"
+ fi
+ fi
+ fi
+ ;;
+ esac
+ func_show_eval "$RM $rmfiles" 'exit_status=1'
+ done
+
+ # Try to remove the ${objdir}s in the directories where we deleted files
+ for dir in $rmdirs; do
+ if test -d "$dir"; then
+ func_show_eval "rmdir $dir >/dev/null 2>&1"
+ fi
+ done
+
+ exit $exit_status
+}
+
+{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
+ func_mode_uninstall ${1+"$@"}
+
+test -z "$opt_mode" && {
+ help="$generic_help"
+ func_fatal_help "you must specify a MODE"
+}
+
+test -z "$exec_cmd" && \
+ func_fatal_help "invalid operation mode \`$opt_mode'"
+
+if test -n "$exec_cmd"; then
+ eval exec "$exec_cmd"
+ exit $EXIT_FAILURE
+fi
+
+exit $exit_status
+
+
+# The TAGs below are defined such that we never get into a situation
+# in which we disable both kinds of libraries. Given conflicting
+# choices, we go for a static library, that is the most portable,
+# since we can't tell whether shared libraries were disabled because
+# the user asked for that or because the platform doesn't support
+# them. This is particularly important on AIX, because we don't
+# support having both static and shared libraries enabled at the same
+# time on that platform, so we default to a shared-only configuration.
+# If a disable-shared tag is given, we'll fallback to a static-only
+# configuration. But we'll never go from static-only to shared-only.
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
+build_libtool_libs=no
+build_old_libs=yes
+# ### END LIBTOOL TAG CONFIG: disable-shared
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-static
+build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+# ### END LIBTOOL TAG CONFIG: disable-static
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:
+# vi:sw=2
+
--- /dev/null
+dnl @synopsis AC_PYTHON_DEVEL([version])
+dnl
+dnl Note: Defines as a precious variable "PYTHON_VERSION". Don't
+dnl override it in your configure.ac.
+dnl
+dnl This macro checks for Python and tries to get the include path to
+dnl 'Python.h'. It provides the $(PYTHON_CPPFLAGS) and
+dnl $(PYTHON_LDFLAGS) output variables. It also exports
+dnl $(PYTHON_EXTRA_LIBS) and $(PYTHON_EXTRA_LDFLAGS) for embedding
+dnl Python in your code.
+dnl
+dnl You can search for some particular version of Python by passing a
+dnl parameter to this macro, for example ">= '2.3.1'", or "== '2.4'".
+dnl Please note that you *have* to pass also an operator along with the
+dnl version to match, and pay special attention to the single quotes
+dnl surrounding the version number. Don't use "PYTHON_VERSION" for
+dnl this: that environment variable is declared as precious and thus
+dnl reserved for the end-user.
+dnl
+dnl This macro should work for all versions of Python >= 2.1.0. As an
+dnl end user, you can disable the check for the python version by
+dnl setting the PYTHON_NOVERSIONCHECK environment variable to something
+dnl else than the empty string.
+dnl
+dnl If you need to use this macro for an older Python version, please
+dnl contact the authors. We're always open for feedback.
+dnl
+dnl @category InstalledPackages
+dnl @author Sebastian Huber <sebastian-huber@web.de>
+dnl @author Alan W. Irwin <irwin@beluga.phys.uvic.ca>
+dnl @author Rafael Laboissiere <laboissiere@psy.mpg.de>
+dnl @author Andrew Collier <colliera@nu.ac.za>
+dnl @author Matteo Settenvini <matteo@member.fsf.org>
+dnl @author Horst Knorr <hk_classes@knoda.org>
+dnl @version 2006-05-27
+dnl @license GPLWithACException
+
+AC_DEFUN([AC_PYTHON_DEVEL],[
+ #
+ # Allow the use of a (user set) custom python version
+ #
+ AC_ARG_VAR([PYTHON_VERSION],[The installed Python
+ version to use, for example '2.3'. This string
+ will be appended to the Python interpreter
+ canonical name.])
+
+ AC_PATH_PROG([PYTHON],[python[$PYTHON_VERSION]])
+ if test -z "$PYTHON"; then
+ AC_MSG_ERROR([Cannot find python$PYTHON_VERSION in your system path])
+ PYTHON_VERSION=""
+ fi
+
+ #
+ # Check for a version of Python >= 2.1.0
+ #
+ AC_MSG_CHECKING([for a version of Python >= '2.1.0'])
+ ac_supports_python_ver=`$PYTHON -c "import sys, string; \
+ ver = string.split(sys.version)[[0]]; \
+ print ver >= '2.1.0'"`
+ if test "$ac_supports_python_ver" != "True"; then
+ if test -z "$PYTHON_NOVERSIONCHECK"; then
+ AC_MSG_RESULT([no])
+ AC_MSG_FAILURE([
+This version of the AC@&t@_PYTHON_DEVEL macro
+doesn't work properly with versions of Python before
+2.1.0. You may need to re-run configure, setting the
+variables PYTHON_CPPFLAGS, PYTHON_LDFLAGS, PYTHON_SITE_PKG,
+PYTHON_EXTRA_LIBS and PYTHON_EXTRA_LDFLAGS by hand.
+Moreover, to disable this check, set PYTHON_NOVERSIONCHECK
+to something else than an empty string.
+])
+ else
+ AC_MSG_RESULT([skip at user request])
+ fi
+ else
+ AC_MSG_RESULT([yes])
+ fi
+
+ #
+ # if the macro parameter ``version'' is set, honour it
+ #
+ if test -n "$1"; then
+ AC_MSG_CHECKING([for a version of Python $1])
+ ac_supports_python_ver=`$PYTHON -c "import sys, string; \
+ ver = string.split(sys.version)[[0]]; \
+ print ver $1"`
+ if test "$ac_supports_python_ver" = "True"; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ AC_MSG_ERROR([this package requires Python $1.
+If you have it installed, but it isn't the default Python
+interpreter in your system path, please pass the PYTHON_VERSION
+variable to configure. See ``configure --help'' for reference.
+])
+ PYTHON_VERSION=""
+ fi
+ fi
+
+ #
+ # Check if you have distutils, else fail
+ #
+ AC_MSG_CHECKING([for the distutils Python package])
+ ac_distutils_result=`$PYTHON -c "import distutils" 2>&1`
+ if test -z "$ac_distutils_result"; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ AC_MSG_ERROR([cannot import Python module "distutils".
+Please check your Python installation. The error was:
+$ac_distutils_result])
+ PYTHON_VERSION=""
+ fi
+
+ #
+ # Check for Python include path
+ #
+ AC_MSG_CHECKING([for Python include path])
+ if test -z "$PYTHON_CPPFLAGS"; then
+ python_path=`$PYTHON -c "import distutils.sysconfig; \
+ print distutils.sysconfig.get_python_inc();"`
+ if test -n "${python_path}"; then
+ python_path="-I$python_path"
+ fi
+ PYTHON_CPPFLAGS=$python_path
+ fi
+ AC_MSG_RESULT([$PYTHON_CPPFLAGS])
+ AC_SUBST([PYTHON_CPPFLAGS])
+
+ #
+ # Check for Python library path
+ #
+ AC_MSG_CHECKING([for Python library path])
+ if test -z "$PYTHON_LDFLAGS"; then
+ # (makes two attempts to ensure we've got a version number
+ # from the interpreter)
+ py_version=`$PYTHON -c "from distutils.sysconfig import *; \
+ from string import join; \
+ print join(get_config_vars('VERSION'))"`
+ if test "$py_version" == "[None]"; then
+ if test -n "$PYTHON_VERSION"; then
+ py_version=$PYTHON_VERSION
+ else
+ py_version=`$PYTHON -c "import sys; \
+ print sys.version[[:3]]"`
+ fi
+ fi
+
+ PYTHON_LDFLAGS=`$PYTHON -c "from distutils.sysconfig import *; \
+ from string import join; \
+ print '-L' + get_python_lib(0,1), \
+ '-lpython';"`$py_version
+ fi
+ AC_MSG_RESULT([$PYTHON_LDFLAGS])
+ AC_SUBST([PYTHON_LDFLAGS])
+
+ #
+ # Check for site packages
+ #
+ AC_MSG_CHECKING([for Python site-packages path])
+ if test -z "$PYTHON_SITE_PKG"; then
+ PYTHON_SITE_PKG=`$PYTHON -c "import distutils.sysconfig; \
+ print distutils.sysconfig.get_python_lib(0,0);"`
+ fi
+ AC_MSG_RESULT([$PYTHON_SITE_PKG])
+ AC_SUBST([PYTHON_SITE_PKG])
+
+ #
+ # libraries which must be linked in when embedding
+ #
+ AC_MSG_CHECKING(python extra libraries)
+ if test -z "$PYTHON_EXTRA_LIBS"; then
+ PYTHON_EXTRA_LIBS=`$PYTHON -c "import distutils.sysconfig; \
+ conf = distutils.sysconfig.get_config_var; \
+ print conf('LOCALMODLIBS'), conf('LIBS')"`
+ fi
+ AC_MSG_RESULT([$PYTHON_EXTRA_LIBS])
+ AC_SUBST(PYTHON_EXTRA_LIBS)
+
+ #
+ # linking flags needed when embedding
+ #
+ AC_MSG_CHECKING(python extra linking flags)
+ if test -z "$PYTHON_EXTRA_LDFLAGS"; then
+ PYTHON_EXTRA_LDFLAGS=`$PYTHON -c "import distutils.sysconfig; \
+ conf = distutils.sysconfig.get_config_var; \
+ print conf('LINKFORSHARED')"`
+ fi
+ AC_MSG_RESULT([$PYTHON_EXTRA_LDFLAGS])
+ AC_SUBST(PYTHON_EXTRA_LDFLAGS)
+
+ #
+ # final check to see if everything compiles alright
+ #
+ AC_MSG_CHECKING([consistency of all components of python development environment])
+ AC_LANG_PUSH([C])
+ # save current global flags
+ LIBS="$ac_save_LIBS $PYTHON_LDFLAGS"
+ CPPFLAGS="$ac_save_CPPFLAGS $PYTHON_CPPFLAGS"
+ AC_TRY_LINK([
+ #include <Python.h>
+ ],[
+ Py_Initialize();
+ ],[pythonexists=yes],[pythonexists=no])
+
+ AC_MSG_RESULT([$pythonexists])
+
+ if test ! "$pythonexists" = "yes"; then
+ AC_MSG_ERROR([
+ Could not link test program to Python. Maybe the main Python library has been
+ installed in some non-standard library path. If so, pass it to configure,
+ via the LDFLAGS environment variable.
+ Example: ./configure LDFLAGS="-L/usr/non-standard-path/python/lib"
+ ============================================================================
+ ERROR!
+ You probably have to install the development version of the Python package
+ for your distribution. The exact name of this package varies among them.
+ ============================================================================
+ ])
+ PYTHON_VERSION=""
+ fi
+ AC_LANG_POP
+ # turn back to default flags
+ CPPFLAGS="$ac_save_CPPFLAGS"
+ LIBS="$ac_save_LIBS"
+
+ #
+ # all done!
+ #
+])
--- /dev/null
+# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+# 2006, 2007, 2008, 2009, 2010, 2011 Free Software
+# Foundation, Inc.
+# Written by Gordon Matzigkeit, 1996
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+m4_define([_LT_COPYING], [dnl
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+# 2006, 2007, 2008, 2009, 2010, 2011 Free Software
+# Foundation, Inc.
+# Written by Gordon Matzigkeit, 1996
+#
+# This file is part of GNU Libtool.
+#
+# GNU Libtool is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of
+# the License, or (at your option) any later version.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GNU Libtool; see the file COPYING. If not, a copy
+# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
+# obtained by writing to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+])
+
+# serial 57 LT_INIT
+
+
+# LT_PREREQ(VERSION)
+# ------------------
+# Complain and exit if this libtool version is less that VERSION.
+m4_defun([LT_PREREQ],
+[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
+ [m4_default([$3],
+ [m4_fatal([Libtool version $1 or higher is required],
+ 63)])],
+ [$2])])
+
+
+# _LT_CHECK_BUILDDIR
+# ------------------
+# Complain if the absolute build directory name contains unusual characters
+m4_defun([_LT_CHECK_BUILDDIR],
+[case `pwd` in
+ *\ * | *\ *)
+ AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;;
+esac
+])
+
+
+# LT_INIT([OPTIONS])
+# ------------------
+AC_DEFUN([LT_INIT],
+[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT
+AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
+AC_BEFORE([$0], [LT_LANG])dnl
+AC_BEFORE([$0], [LT_OUTPUT])dnl
+AC_BEFORE([$0], [LTDL_INIT])dnl
+m4_require([_LT_CHECK_BUILDDIR])dnl
+
+dnl Autoconf doesn't catch unexpanded LT_ macros by default:
+m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
+m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl
+dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
+dnl unless we require an AC_DEFUNed macro:
+AC_REQUIRE([LTOPTIONS_VERSION])dnl
+AC_REQUIRE([LTSUGAR_VERSION])dnl
+AC_REQUIRE([LTVERSION_VERSION])dnl
+AC_REQUIRE([LTOBSOLETE_VERSION])dnl
+m4_require([_LT_PROG_LTMAIN])dnl
+
+_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}])
+
+dnl Parse OPTIONS
+_LT_SET_OPTIONS([$0], [$1])
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ltmain"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+AC_SUBST(LIBTOOL)dnl
+
+_LT_SETUP
+
+# Only expand once:
+m4_define([LT_INIT])
+])# LT_INIT
+
+# Old names:
+AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT])
+AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_PROG_LIBTOOL], [])
+dnl AC_DEFUN([AM_PROG_LIBTOOL], [])
+
+
+# _LT_CC_BASENAME(CC)
+# -------------------
+# Calculate cc_basename. Skip known compiler wrappers and cross-prefix.
+m4_defun([_LT_CC_BASENAME],
+[for cc_temp in $1""; do
+ case $cc_temp in
+ compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
+ distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
+ \-*) ;;
+ *) break;;
+ esac
+done
+cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+])
+
+
+# _LT_FILEUTILS_DEFAULTS
+# ----------------------
+# It is okay to use these file commands and assume they have been set
+# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'.
+m4_defun([_LT_FILEUTILS_DEFAULTS],
+[: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+])# _LT_FILEUTILS_DEFAULTS
+
+
+# _LT_SETUP
+# ---------
+m4_defun([_LT_SETUP],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl
+AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl
+
+_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl
+dnl
+_LT_DECL([], [host_alias], [0], [The host system])dnl
+_LT_DECL([], [host], [0])dnl
+_LT_DECL([], [host_os], [0])dnl
+dnl
+_LT_DECL([], [build_alias], [0], [The build system])dnl
+_LT_DECL([], [build], [0])dnl
+_LT_DECL([], [build_os], [0])dnl
+dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([LT_PATH_LD])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+dnl
+AC_REQUIRE([AC_PROG_LN_S])dnl
+test -z "$LN_S" && LN_S="ln -s"
+_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
+dnl
+AC_REQUIRE([LT_CMD_MAX_LEN])dnl
+_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
+_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
+dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_CHECK_SHELL_FEATURES])dnl
+m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl
+m4_require([_LT_CMD_RELOAD])dnl
+m4_require([_LT_CHECK_MAGIC_METHOD])dnl
+m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl
+m4_require([_LT_CMD_OLD_ARCHIVE])dnl
+m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
+m4_require([_LT_WITH_SYSROOT])dnl
+
+_LT_CONFIG_LIBTOOL_INIT([
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}" ; then
+ setopt NO_GLOB_SUBST
+fi
+])
+if test -n "${ZSH_VERSION+set}" ; then
+ setopt NO_GLOB_SUBST
+fi
+
+_LT_CHECK_OBJDIR
+
+m4_require([_LT_TAG_COMPILER])dnl
+
+case $host_os in
+aix3*)
+ # AIX sometimes has problems with the GCC collect2 program. For some
+ # reason, if we set the COLLECT_NAMES environment variable, the problems
+ # vanish in a puff of smoke.
+ if test "X${COLLECT_NAMES+set}" != Xset; then
+ COLLECT_NAMES=
+ export COLLECT_NAMES
+ fi
+ ;;
+esac
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a `.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld="$lt_cv_prog_gnu_ld"
+
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+_LT_CC_BASENAME([$compiler])
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+ if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+ _LT_PATH_MAGIC
+ fi
+ ;;
+esac
+
+# Use C for the default configuration in the libtool script
+LT_SUPPORTED_TAG([CC])
+_LT_LANG_C_CONFIG
+_LT_LANG_DEFAULT_CONFIG
+_LT_CONFIG_COMMANDS
+])# _LT_SETUP
+
+
+# _LT_PREPARE_SED_QUOTE_VARS
+# --------------------------
+# Define a few sed substitution that help us do robust quoting.
+m4_defun([_LT_PREPARE_SED_QUOTE_VARS],
+[# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/\([["`$\\]]\)/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/\([["`\\]]\)/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+])
+
+# _LT_PROG_LTMAIN
+# ---------------
+# Note that this code is called both from `configure', and `config.status'
+# now that we use AC_CONFIG_COMMANDS to generate libtool. Notably,
+# `config.status' has no value for ac_aux_dir unless we are using Automake,
+# so we pass a copy along to make sure it has a sensible value anyway.
+m4_defun([_LT_PROG_LTMAIN],
+[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl
+_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
+ltmain="$ac_aux_dir/ltmain.sh"
+])# _LT_PROG_LTMAIN
+
+
+## ------------------------------------- ##
+## Accumulate code for creating libtool. ##
+## ------------------------------------- ##
+
+# So that we can recreate a full libtool script including additional
+# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
+# in macros and then make a single call at the end using the `libtool'
+# label.
+
+
+# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
+# ----------------------------------------
+# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL_INIT],
+[m4_ifval([$1],
+ [m4_append([_LT_OUTPUT_LIBTOOL_INIT],
+ [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_INIT])
+
+
+# _LT_CONFIG_LIBTOOL([COMMANDS])
+# ------------------------------
+# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL],
+[m4_ifval([$1],
+ [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
+ [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
+
+
+# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
+# -----------------------------------------------------
+m4_defun([_LT_CONFIG_SAVE_COMMANDS],
+[_LT_CONFIG_LIBTOOL([$1])
+_LT_CONFIG_LIBTOOL_INIT([$2])
+])
+
+
+# _LT_FORMAT_COMMENT([COMMENT])
+# -----------------------------
+# Add leading comment marks to the start of each line, and a trailing
+# full-stop to the whole comment if one is not present already.
+m4_define([_LT_FORMAT_COMMENT],
+[m4_ifval([$1], [
+m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])],
+ [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.])
+)])
+
+
+
+## ------------------------ ##
+## FIXME: Eliminate VARNAME ##
+## ------------------------ ##
+
+
+# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
+# -------------------------------------------------------------------
+# CONFIGNAME is the name given to the value in the libtool script.
+# VARNAME is the (base) name used in the configure script.
+# VALUE may be 0, 1 or 2 for a computed quote escaped value based on
+# VARNAME. Any other value will be used directly.
+m4_define([_LT_DECL],
+[lt_if_append_uniq([lt_decl_varnames], [$2], [, ],
+ [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
+ [m4_ifval([$1], [$1], [$2])])
+ lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
+ m4_ifval([$4],
+ [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
+ lt_dict_add_subkey([lt_decl_dict], [$2],
+ [tagged?], [m4_ifval([$5], [yes], [no])])])
+])
+
+
+# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
+# --------------------------------------------------------
+m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
+
+
+# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
+# ------------------------------------------------
+m4_define([lt_decl_tag_varnames],
+[_lt_decl_filter([tagged?], [yes], $@)])
+
+
+# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..])
+# ---------------------------------------------------------
+m4_define([_lt_decl_filter],
+[m4_case([$#],
+ [0], [m4_fatal([$0: too few arguments: $#])],
+ [1], [m4_fatal([$0: too few arguments: $#: $1])],
+ [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
+ [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
+ [lt_dict_filter([lt_decl_dict], $@)])[]dnl
+])
+
+
+# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
+# --------------------------------------------------
+m4_define([lt_decl_quote_varnames],
+[_lt_decl_filter([value], [1], $@)])
+
+
+# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
+# ---------------------------------------------------
+m4_define([lt_decl_dquote_varnames],
+[_lt_decl_filter([value], [2], $@)])
+
+
+# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
+# ---------------------------------------------------
+m4_define([lt_decl_varnames_tagged],
+[m4_assert([$# <= 2])dnl
+_$0(m4_quote(m4_default([$1], [[, ]])),
+ m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]),
+ m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))])
+m4_define([_lt_decl_varnames_tagged],
+[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])
+
+
+# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
+# ------------------------------------------------
+m4_define([lt_decl_all_varnames],
+[_$0(m4_quote(m4_default([$1], [[, ]])),
+ m4_if([$2], [],
+ m4_quote(lt_decl_varnames),
+ m4_quote(m4_shift($@))))[]dnl
+])
+m4_define([_lt_decl_all_varnames],
+[lt_join($@, lt_decl_varnames_tagged([$1],
+ lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
+])
+
+
+# _LT_CONFIG_STATUS_DECLARE([VARNAME])
+# ------------------------------------
+# Quote a variable value, and forward it to `config.status' so that its
+# declaration there will have the same value as in `configure'. VARNAME
+# must have a single quote delimited value for this to work.
+m4_define([_LT_CONFIG_STATUS_DECLARE],
+[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`'])
+
+
+# _LT_CONFIG_STATUS_DECLARATIONS
+# ------------------------------
+# We delimit libtool config variables with single quotes, so when
+# we write them to config.status, we have to be sure to quote all
+# embedded single quotes properly. In configure, this macro expands
+# each variable declared with _LT_DECL (and _LT_TAGDECL) into:
+#
+# <var>='`$ECHO "$<var>" | $SED "$delay_single_quote_subst"`'
+m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
+ [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
+
+
+# _LT_LIBTOOL_TAGS
+# ----------------
+# Output comment and list of tags supported by the script
+m4_defun([_LT_LIBTOOL_TAGS],
+[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
+available_tags="_LT_TAGS"dnl
+])
+
+
+# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
+# -----------------------------------
+# Extract the dictionary values for VARNAME (optionally with TAG) and
+# expand to a commented shell variable setting:
+#
+# # Some comment about what VAR is for.
+# visible_name=$lt_internal_name
+m4_define([_LT_LIBTOOL_DECLARE],
+[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
+ [description])))[]dnl
+m4_pushdef([_libtool_name],
+ m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
+m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
+ [0], [_libtool_name=[$]$1],
+ [1], [_libtool_name=$lt_[]$1],
+ [2], [_libtool_name=$lt_[]$1],
+ [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
+m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
+])
+
+
+# _LT_LIBTOOL_CONFIG_VARS
+# -----------------------
+# Produce commented declarations of non-tagged libtool config variables
+# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
+# script. Tagged libtool config variables (even for the LIBTOOL CONFIG
+# section) are produced by _LT_LIBTOOL_TAG_VARS.
+m4_defun([_LT_LIBTOOL_CONFIG_VARS],
+[m4_foreach([_lt_var],
+ m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
+ [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
+
+
+# _LT_LIBTOOL_TAG_VARS(TAG)
+# -------------------------
+m4_define([_LT_LIBTOOL_TAG_VARS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
+ [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
+
+
+# _LT_TAGVAR(VARNAME, [TAGNAME])
+# ------------------------------
+m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
+
+
+# _LT_CONFIG_COMMANDS
+# -------------------
+# Send accumulated output to $CONFIG_STATUS. Thanks to the lists of
+# variables for single and double quote escaping we saved from calls
+# to _LT_DECL, we can put quote escaped variables declarations
+# into `config.status', and then the shell code to quote escape them in
+# for loops in `config.status'. Finally, any additional code accumulated
+# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
+m4_defun([_LT_CONFIG_COMMANDS],
+[AC_PROVIDE_IFELSE([LT_OUTPUT],
+ dnl If the libtool generation code has been placed in $CONFIG_LT,
+ dnl instead of duplicating it all over again into config.status,
+ dnl then we will have config.status run $CONFIG_LT later, so it
+ dnl needs to know what name is stored there:
+ [AC_CONFIG_COMMANDS([libtool],
+ [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],
+ dnl If the libtool generation code is destined for config.status,
+ dnl expand the accumulated commands and init code now:
+ [AC_CONFIG_COMMANDS([libtool],
+ [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])
+])#_LT_CONFIG_COMMANDS
+
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],
+[
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+_LT_CONFIG_STATUS_DECLARATIONS
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+ eval 'cat <<_LTECHO_EOF
+\$[]1
+_LTECHO_EOF'
+}
+
+# Quote evaled strings.
+for var in lt_decl_all_varnames([[ \
+]], lt_decl_quote_varnames); do
+ case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+ *[[\\\\\\\`\\"\\\$]]*)
+ eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
+ ;;
+ *)
+ eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+ ;;
+ esac
+done
+
+# Double-quote double-evaled strings.
+for var in lt_decl_all_varnames([[ \
+]], lt_decl_dquote_varnames); do
+ case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+ *[[\\\\\\\`\\"\\\$]]*)
+ eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
+ ;;
+ *)
+ eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+ ;;
+ esac
+done
+
+_LT_OUTPUT_LIBTOOL_INIT
+])
+
+# _LT_GENERATED_FILE_INIT(FILE, [COMMENT])
+# ------------------------------------
+# Generate a child script FILE with all initialization necessary to
+# reuse the environment learned by the parent script, and make the
+# file executable. If COMMENT is supplied, it is inserted after the
+# `#!' sequence but before initialization text begins. After this
+# macro, additional text can be appended to FILE to form the body of
+# the child script. The macro ends with non-zero status if the
+# file could not be fully written (such as if the disk is full).
+m4_ifdef([AS_INIT_GENERATED],
+[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])],
+[m4_defun([_LT_GENERATED_FILE_INIT],
+[m4_require([AS_PREPARE])]dnl
+[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl
+[lt_write_fail=0
+cat >$1 <<_ASEOF || lt_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+$2
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$1 <<\_ASEOF || lt_write_fail=1
+AS_SHELL_SANITIZE
+_AS_PREPARE
+exec AS_MESSAGE_FD>&1
+_ASEOF
+test $lt_write_fail = 0 && chmod +x $1[]dnl
+m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT
+
+# LT_OUTPUT
+# ---------
+# This macro allows early generation of the libtool script (before
+# AC_OUTPUT is called), incase it is used in configure for compilation
+# tests.
+AC_DEFUN([LT_OUTPUT],
+[: ${CONFIG_LT=./config.lt}
+AC_MSG_NOTICE([creating $CONFIG_LT])
+_LT_GENERATED_FILE_INIT(["$CONFIG_LT"],
+[# Run this file to recreate a libtool stub with the current configuration.])
+
+cat >>"$CONFIG_LT" <<\_LTEOF
+lt_cl_silent=false
+exec AS_MESSAGE_LOG_FD>>config.log
+{
+ echo
+ AS_BOX([Running $as_me.])
+} >&AS_MESSAGE_LOG_FD
+
+lt_cl_help="\
+\`$as_me' creates a local libtool stub from the current configuration,
+for use in further configure time tests before the real libtool is
+generated.
+
+Usage: $[0] [[OPTIONS]]
+
+ -h, --help print this help, then exit
+ -V, --version print version number, then exit
+ -q, --quiet do not print progress messages
+ -d, --debug don't remove temporary files
+
+Report bugs to <bug-libtool@gnu.org>."
+
+lt_cl_version="\
+m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl
+m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
+configured by $[0], generated by m4_PACKAGE_STRING.
+
+Copyright (C) 2011 Free Software Foundation, Inc.
+This config.lt script is free software; the Free Software Foundation
+gives unlimited permision to copy, distribute and modify it."
+
+while test $[#] != 0
+do
+ case $[1] in
+ --version | --v* | -V )
+ echo "$lt_cl_version"; exit 0 ;;
+ --help | --h* | -h )
+ echo "$lt_cl_help"; exit 0 ;;
+ --debug | --d* | -d )
+ debug=: ;;
+ --quiet | --q* | --silent | --s* | -q )
+ lt_cl_silent=: ;;
+
+ -*) AC_MSG_ERROR([unrecognized option: $[1]
+Try \`$[0] --help' for more information.]) ;;
+
+ *) AC_MSG_ERROR([unrecognized argument: $[1]
+Try \`$[0] --help' for more information.]) ;;
+ esac
+ shift
+done
+
+if $lt_cl_silent; then
+ exec AS_MESSAGE_FD>/dev/null
+fi
+_LTEOF
+
+cat >>"$CONFIG_LT" <<_LTEOF
+_LT_OUTPUT_LIBTOOL_COMMANDS_INIT
+_LTEOF
+
+cat >>"$CONFIG_LT" <<\_LTEOF
+AC_MSG_NOTICE([creating $ofile])
+_LT_OUTPUT_LIBTOOL_COMMANDS
+AS_EXIT(0)
+_LTEOF
+chmod +x "$CONFIG_LT"
+
+# configure is writing to config.log, but config.lt does its own redirection,
+# appending to config.log, which fails on DOS, as config.log is still kept
+# open by configure. Here we exec the FD to /dev/null, effectively closing
+# config.log, so it can be properly (re)opened and appended to by config.lt.
+lt_cl_success=:
+test "$silent" = yes &&
+ lt_config_lt_args="$lt_config_lt_args --quiet"
+exec AS_MESSAGE_LOG_FD>/dev/null
+$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
+exec AS_MESSAGE_LOG_FD>>config.log
+$lt_cl_success || AS_EXIT(1)
+])# LT_OUTPUT
+
+
+# _LT_CONFIG(TAG)
+# ---------------
+# If TAG is the built-in tag, create an initial libtool script with a
+# default configuration from the untagged config vars. Otherwise add code
+# to config.status for appending the configuration named by TAG from the
+# matching tagged config vars.
+m4_defun([_LT_CONFIG],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+_LT_CONFIG_SAVE_COMMANDS([
+ m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
+ m4_if(_LT_TAG, [C], [
+ # See if we are running on zsh, and set the options which allow our
+ # commands through without removal of \ escapes.
+ if test -n "${ZSH_VERSION+set}" ; then
+ setopt NO_GLOB_SUBST
+ fi
+
+ cfgfile="${ofile}T"
+ trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+ $RM "$cfgfile"
+
+ cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+
+# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+_LT_COPYING
+_LT_LIBTOOL_TAGS
+
+# ### BEGIN LIBTOOL CONFIG
+_LT_LIBTOOL_CONFIG_VARS
+_LT_LIBTOOL_TAG_VARS
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+ case $host_os in
+ aix3*)
+ cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program. For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+ COLLECT_NAMES=
+ export COLLECT_NAMES
+fi
+_LT_EOF
+ ;;
+ esac
+
+ _LT_PROG_LTMAIN
+
+ # We use sed instead of cat because bash on DJGPP gets confused if
+ # if finds mixed CR/LF and LF-only lines. Since sed operates in
+ # text mode, it properly converts lines to CR/LF. This bash problem
+ # is reportedly fixed, but why not run on old versions too?
+ sed '$q' "$ltmain" >> "$cfgfile" \
+ || (rm -f "$cfgfile"; exit 1)
+
+ _LT_PROG_REPLACE_SHELLFNS
+
+ mv -f "$cfgfile" "$ofile" ||
+ (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+ chmod +x "$ofile"
+],
+[cat <<_LT_EOF >> "$ofile"
+
+dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
+dnl in a comment (ie after a #).
+# ### BEGIN LIBTOOL TAG CONFIG: $1
+_LT_LIBTOOL_TAG_VARS(_LT_TAG)
+# ### END LIBTOOL TAG CONFIG: $1
+_LT_EOF
+])dnl /m4_if
+],
+[m4_if([$1], [], [
+ PACKAGE='$PACKAGE'
+ VERSION='$VERSION'
+ TIMESTAMP='$TIMESTAMP'
+ RM='$RM'
+ ofile='$ofile'], [])
+])dnl /_LT_CONFIG_SAVE_COMMANDS
+])# _LT_CONFIG
+
+
+# LT_SUPPORTED_TAG(TAG)
+# ---------------------
+# Trace this macro to discover what tags are supported by the libtool
+# --tag option, using:
+# autoconf --trace 'LT_SUPPORTED_TAG:$1'
+AC_DEFUN([LT_SUPPORTED_TAG], [])
+
+
+# C support is built-in for now
+m4_define([_LT_LANG_C_enabled], [])
+m4_define([_LT_TAGS], [])
+
+
+# LT_LANG(LANG)
+# -------------
+# Enable libtool support for the given language if not already enabled.
+AC_DEFUN([LT_LANG],
+[AC_BEFORE([$0], [LT_OUTPUT])dnl
+m4_case([$1],
+ [C], [_LT_LANG(C)],
+ [C++], [_LT_LANG(CXX)],
+ [Go], [_LT_LANG(GO)],
+ [Java], [_LT_LANG(GCJ)],
+ [Fortran 77], [_LT_LANG(F77)],
+ [Fortran], [_LT_LANG(FC)],
+ [Windows Resource], [_LT_LANG(RC)],
+ [m4_ifdef([_LT_LANG_]$1[_CONFIG],
+ [_LT_LANG($1)],
+ [m4_fatal([$0: unsupported language: "$1"])])])dnl
+])# LT_LANG
+
+
+# _LT_LANG(LANGNAME)
+# ------------------
+m4_defun([_LT_LANG],
+[m4_ifdef([_LT_LANG_]$1[_enabled], [],
+ [LT_SUPPORTED_TAG([$1])dnl
+ m4_append([_LT_TAGS], [$1 ])dnl
+ m4_define([_LT_LANG_]$1[_enabled], [])dnl
+ _LT_LANG_$1_CONFIG($1)])dnl
+])# _LT_LANG
+
+
+m4_ifndef([AC_PROG_GO], [
+############################################################
+# NOTE: This macro has been submitted for inclusion into #
+# GNU Autoconf as AC_PROG_GO. When it is available in #
+# a released version of Autoconf we should remove this #
+# macro and use it instead. #
+############################################################
+m4_defun([AC_PROG_GO],
+[AC_LANG_PUSH(Go)dnl
+AC_ARG_VAR([GOC], [Go compiler command])dnl
+AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl
+_AC_ARG_VAR_LDFLAGS()dnl
+AC_CHECK_TOOL(GOC, gccgo)
+if test -z "$GOC"; then
+ if test -n "$ac_tool_prefix"; then
+ AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo])
+ fi
+fi
+if test -z "$GOC"; then
+ AC_CHECK_PROG(GOC, gccgo, gccgo, false)
+fi
+])#m4_defun
+])#m4_ifndef
+
+
+# _LT_LANG_DEFAULT_CONFIG
+# -----------------------
+m4_defun([_LT_LANG_DEFAULT_CONFIG],
+[AC_PROVIDE_IFELSE([AC_PROG_CXX],
+ [LT_LANG(CXX)],
+ [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_F77],
+ [LT_LANG(F77)],
+ [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_FC],
+ [LT_LANG(FC)],
+ [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])
+
+dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
+dnl pulling things in needlessly.
+AC_PROVIDE_IFELSE([AC_PROG_GCJ],
+ [LT_LANG(GCJ)],
+ [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
+ [LT_LANG(GCJ)],
+ [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
+ [LT_LANG(GCJ)],
+ [m4_ifdef([AC_PROG_GCJ],
+ [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
+ m4_ifdef([A][M_PROG_GCJ],
+ [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
+ m4_ifdef([LT_PROG_GCJ],
+ [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
+
+AC_PROVIDE_IFELSE([AC_PROG_GO],
+ [LT_LANG(GO)],
+ [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])
+
+AC_PROVIDE_IFELSE([LT_PROG_RC],
+ [LT_LANG(RC)],
+ [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
+])# _LT_LANG_DEFAULT_CONFIG
+
+# Obsolete macros:
+AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
+AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
+AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])
+AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])
+AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_CXX], [])
+dnl AC_DEFUN([AC_LIBTOOL_F77], [])
+dnl AC_DEFUN([AC_LIBTOOL_FC], [])
+dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])
+dnl AC_DEFUN([AC_LIBTOOL_RC], [])
+
+
+# _LT_TAG_COMPILER
+# ----------------
+m4_defun([_LT_TAG_COMPILER],
+[AC_REQUIRE([AC_PROG_CC])dnl
+
+_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl
+_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl
+_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
+_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+])# _LT_TAG_COMPILER
+
+
+# _LT_COMPILER_BOILERPLATE
+# ------------------------
+# Check for compiler boilerplate output or warnings with
+# the simple compiler test code.
+m4_defun([_LT_COMPILER_BOILERPLATE],
+[m4_require([_LT_DECL_SED])dnl
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+])# _LT_COMPILER_BOILERPLATE
+
+
+# _LT_LINKER_BOILERPLATE
+# ----------------------
+# Check for linker boilerplate output or warnings with
+# the simple link test code.
+m4_defun([_LT_LINKER_BOILERPLATE],
+[m4_require([_LT_DECL_SED])dnl
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+])# _LT_LINKER_BOILERPLATE
+
+# _LT_REQUIRED_DARWIN_CHECKS
+# -------------------------
+m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
+ case $host_os in
+ rhapsody* | darwin*)
+ AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])
+ AC_CHECK_TOOL([NMEDIT], [nmedit], [:])
+ AC_CHECK_TOOL([LIPO], [lipo], [:])
+ AC_CHECK_TOOL([OTOOL], [otool], [:])
+ AC_CHECK_TOOL([OTOOL64], [otool64], [:])
+ _LT_DECL([], [DSYMUTIL], [1],
+ [Tool to manipulate archived DWARF debug symbol files on Mac OS X])
+ _LT_DECL([], [NMEDIT], [1],
+ [Tool to change global to local symbols on Mac OS X])
+ _LT_DECL([], [LIPO], [1],
+ [Tool to manipulate fat objects and archives on Mac OS X])
+ _LT_DECL([], [OTOOL], [1],
+ [ldd/readelf like tool for Mach-O binaries on Mac OS X])
+ _LT_DECL([], [OTOOL64], [1],
+ [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])
+
+ AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
+ [lt_cv_apple_cc_single_mod=no
+ if test -z "${LT_MULTI_MODULE}"; then
+ # By default we will add the -single_module flag. You can override
+ # by either setting the environment variable LT_MULTI_MODULE
+ # non-empty at configure time, or by adding -multi_module to the
+ # link flags.
+ rm -rf libconftest.dylib*
+ echo "int foo(void){return 1;}" > conftest.c
+ echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD
+ $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+ -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+ _lt_result=$?
+ # If there is a non-empty error log, and "single_module"
+ # appears in it, assume the flag caused a linker warning
+ if test -s conftest.err && $GREP single_module conftest.err; then
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ # Otherwise, if the output was created with a 0 exit code from
+ # the compiler, it worked.
+ elif test -f libconftest.dylib && test $_lt_result -eq 0; then
+ lt_cv_apple_cc_single_mod=yes
+ else
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ fi
+ rm -rf libconftest.dylib*
+ rm -f conftest.*
+ fi])
+
+ AC_CACHE_CHECK([for -exported_symbols_list linker flag],
+ [lt_cv_ld_exported_symbols_list],
+ [lt_cv_ld_exported_symbols_list=no
+ save_LDFLAGS=$LDFLAGS
+ echo "_main" > conftest.sym
+ LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+ AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+ [lt_cv_ld_exported_symbols_list=yes],
+ [lt_cv_ld_exported_symbols_list=no])
+ LDFLAGS="$save_LDFLAGS"
+ ])
+
+ AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],
+ [lt_cv_ld_force_load=no
+ cat > conftest.c << _LT_EOF
+int forced_loaded() { return 2;}
+_LT_EOF
+ echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD
+ $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD
+ echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
+ $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
+ echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD
+ $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD
+ cat > conftest.c << _LT_EOF
+int main() { return 0;}
+_LT_EOF
+ echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD
+ $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
+ _lt_result=$?
+ if test -s conftest.err && $GREP force_load conftest.err; then
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
+ lt_cv_ld_force_load=yes
+ else
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ fi
+ rm -f conftest.err libconftest.a conftest conftest.c
+ rm -rf conftest.dSYM
+ ])
+ case $host_os in
+ rhapsody* | darwin1.[[012]])
+ _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
+ darwin1.*)
+ _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+ darwin*) # darwin 5.x on
+ # if running on 10.5 or later, the deployment target defaults
+ # to the OS version, if on x86, and 10.4, the deployment
+ # target defaults to 10.4. Don't you love it?
+ case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+ 10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)
+ _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+ 10.[[012]]*)
+ _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
+ 10.*)
+ _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
+ esac
+ ;;
+ esac
+ if test "$lt_cv_apple_cc_single_mod" = "yes"; then
+ _lt_dar_single_mod='$single_module'
+ fi
+ if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
+ _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
+ else
+ _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
+ fi
+ if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
+ _lt_dsymutil='~$DSYMUTIL $lib || :'
+ else
+ _lt_dsymutil=
+ fi
+ ;;
+ esac
+])
+
+
+# _LT_DARWIN_LINKER_FEATURES([TAG])
+# ---------------------------------
+# Checks for linker and compiler features on darwin
+m4_defun([_LT_DARWIN_LINKER_FEATURES],
+[
+ m4_require([_LT_REQUIRED_DARWIN_CHECKS])
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ _LT_TAGVAR(hardcode_direct, $1)=no
+ _LT_TAGVAR(hardcode_automatic, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+ if test "$lt_cv_ld_force_load" = "yes"; then
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+ m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],
+ [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes])
+ else
+ _LT_TAGVAR(whole_archive_flag_spec, $1)=''
+ fi
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"
+ case $cc_basename in
+ ifort*) _lt_dar_can_shared=yes ;;
+ *) _lt_dar_can_shared=$GCC ;;
+ esac
+ if test "$_lt_dar_can_shared" = "yes"; then
+ output_verbose_link_cmd=func_echo_all
+ _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
+ _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
+ _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
+ _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
+ m4_if([$1], [CXX],
+[ if test "$lt_cv_apple_cc_single_mod" != "yes"; then
+ _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
+ _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
+ fi
+],[])
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+])
+
+# _LT_SYS_MODULE_PATH_AIX([TAGNAME])
+# ----------------------------------
+# Links a minimal program and checks the executable
+# for the system default hardcoded library path. In most cases,
+# this is /usr/lib:/lib, but when the MPI compilers are used
+# the location of the communication and MPI libs are included too.
+# If we don't find anything, use the default library path according
+# to the aix ld manual.
+# Store the results from the different compilers for each TAGNAME.
+# Allow to override them for all tags through lt_cv_aix_libpath.
+m4_defun([_LT_SYS_MODULE_PATH_AIX],
+[m4_require([_LT_DECL_SED])dnl
+if test "${lt_cv_aix_libpath+set}" = set; then
+ aix_libpath=$lt_cv_aix_libpath
+else
+ AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],
+ [AC_LINK_IFELSE([AC_LANG_PROGRAM],[
+ lt_aix_libpath_sed='[
+ /Import File Strings/,/^$/ {
+ /^0/ {
+ s/^0 *\([^ ]*\) *$/\1/
+ p
+ }
+ }]'
+ _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ # Check for a 64-bit object if we didn't find anything.
+ if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
+ _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+ fi],[])
+ if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
+ _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib"
+ fi
+ ])
+ aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])
+fi
+])# _LT_SYS_MODULE_PATH_AIX
+
+
+# _LT_SHELL_INIT(ARG)
+# -------------------
+m4_define([_LT_SHELL_INIT],
+[m4_divert_text([M4SH-INIT], [$1
+])])# _LT_SHELL_INIT
+
+
+
+# _LT_PROG_ECHO_BACKSLASH
+# -----------------------
+# Find how we can fake an echo command that does not interpret backslash.
+# In particular, with Autoconf 2.60 or later we add some code to the start
+# of the generated configure script which will find a shell with a builtin
+# printf (which we can use as an echo command).
+m4_defun([_LT_PROG_ECHO_BACKSLASH],
+[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+AC_MSG_CHECKING([how to print strings])
+# Test print first, because it will be a builtin if present.
+if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
+ test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+ ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+ ECHO='printf %s\n'
+else
+ # Use this function as a fallback that always works.
+ func_fallback_echo ()
+ {
+ eval 'cat <<_LTECHO_EOF
+$[]1
+_LTECHO_EOF'
+ }
+ ECHO='func_fallback_echo'
+fi
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+ $ECHO "$*"
+}
+
+case "$ECHO" in
+ printf*) AC_MSG_RESULT([printf]) ;;
+ print*) AC_MSG_RESULT([print -r]) ;;
+ *) AC_MSG_RESULT([cat]) ;;
+esac
+
+m4_ifdef([_AS_DETECT_SUGGESTED],
+[_AS_DETECT_SUGGESTED([
+ test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || (
+ ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+ PATH=/empty FPATH=/empty; export PATH FPATH
+ test "X`printf %s $ECHO`" = "X$ECHO" \
+ || test "X`print -r -- $ECHO`" = "X$ECHO" )])])
+
+_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
+_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])
+])# _LT_PROG_ECHO_BACKSLASH
+
+
+# _LT_WITH_SYSROOT
+# ----------------
+AC_DEFUN([_LT_WITH_SYSROOT],
+[AC_MSG_CHECKING([for sysroot])
+AC_ARG_WITH([sysroot],
+[ --with-sysroot[=DIR] Search for dependent libraries within DIR
+ (or the compiler's sysroot if not specified).],
+[], [with_sysroot=no])
+
+dnl lt_sysroot will always be passed unquoted. We quote it here
+dnl in case the user passed a directory name.
+lt_sysroot=
+case ${with_sysroot} in #(
+ yes)
+ if test "$GCC" = yes; then
+ lt_sysroot=`$CC --print-sysroot 2>/dev/null`
+ fi
+ ;; #(
+ /*)
+ lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+ ;; #(
+ no|'')
+ ;; #(
+ *)
+ AC_MSG_RESULT([${with_sysroot}])
+ AC_MSG_ERROR([The sysroot must be an absolute path.])
+ ;;
+esac
+
+ AC_MSG_RESULT([${lt_sysroot:-no}])
+_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl
+[dependent libraries, and in which our libraries should be installed.])])
+
+# _LT_ENABLE_LOCK
+# ---------------
+m4_defun([_LT_ENABLE_LOCK],
+[AC_ARG_ENABLE([libtool-lock],
+ [AS_HELP_STRING([--disable-libtool-lock],
+ [avoid locking (might break parallel builds)])])
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+ # Find out which ABI we are using.
+ echo 'int i;' > conftest.$ac_ext
+ if AC_TRY_EVAL(ac_compile); then
+ case `/usr/bin/file conftest.$ac_objext` in
+ *ELF-32*)
+ HPUX_IA64_MODE="32"
+ ;;
+ *ELF-64*)
+ HPUX_IA64_MODE="64"
+ ;;
+ esac
+ fi
+ rm -rf conftest*
+ ;;
+*-*-irix6*)
+ # Find out which ABI we are using.
+ echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
+ if AC_TRY_EVAL(ac_compile); then
+ if test "$lt_cv_prog_gnu_ld" = yes; then
+ case `/usr/bin/file conftest.$ac_objext` in
+ *32-bit*)
+ LD="${LD-ld} -melf32bsmip"
+ ;;
+ *N32*)
+ LD="${LD-ld} -melf32bmipn32"
+ ;;
+ *64-bit*)
+ LD="${LD-ld} -melf64bmip"
+ ;;
+ esac
+ else
+ case `/usr/bin/file conftest.$ac_objext` in
+ *32-bit*)
+ LD="${LD-ld} -32"
+ ;;
+ *N32*)
+ LD="${LD-ld} -n32"
+ ;;
+ *64-bit*)
+ LD="${LD-ld} -64"
+ ;;
+ esac
+ fi
+ fi
+ rm -rf conftest*
+ ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+ # Find out which ABI we are using.
+ echo 'int i;' > conftest.$ac_ext
+ if AC_TRY_EVAL(ac_compile); then
+ case `/usr/bin/file conftest.o` in
+ *32-bit*)
+ case $host in
+ x86_64-*kfreebsd*-gnu)
+ LD="${LD-ld} -m elf_i386_fbsd"
+ ;;
+ x86_64-*linux*)
+ case `/usr/bin/file conftest.o` in
+ *x86-64*)
+ LD="${LD-ld} -m elf32_x86_64"
+ ;;
+ *)
+ LD="${LD-ld} -m elf_i386"
+ ;;
+ esac
+ ;;
+ powerpc64le-*)
+ LD="${LD-ld} -m elf32lppclinux"
+ ;;
+ powerpc64-*)
+ LD="${LD-ld} -m elf32ppclinux"
+ ;;
+ s390x-*linux*)
+ LD="${LD-ld} -m elf_s390"
+ ;;
+ sparc64-*linux*)
+ LD="${LD-ld} -m elf32_sparc"
+ ;;
+ esac
+ ;;
+ *64-bit*)
+ case $host in
+ x86_64-*kfreebsd*-gnu)
+ LD="${LD-ld} -m elf_x86_64_fbsd"
+ ;;
+ x86_64-*linux*)
+ LD="${LD-ld} -m elf_x86_64"
+ ;;
+ powerpcle-*)
+ LD="${LD-ld} -m elf64lppc"
+ ;;
+ powerpc-*)
+ LD="${LD-ld} -m elf64ppc"
+ ;;
+ s390*-*linux*|s390*-*tpf*)
+ LD="${LD-ld} -m elf64_s390"
+ ;;
+ sparc*-*linux*)
+ LD="${LD-ld} -m elf64_sparc"
+ ;;
+ esac
+ ;;
+ esac
+ fi
+ rm -rf conftest*
+ ;;
+
+*-*-sco3.2v5*)
+ # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+ SAVE_CFLAGS="$CFLAGS"
+ CFLAGS="$CFLAGS -belf"
+ AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
+ [AC_LANG_PUSH(C)
+ AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
+ AC_LANG_POP])
+ if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+ # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+ CFLAGS="$SAVE_CFLAGS"
+ fi
+ ;;
+*-*solaris*)
+ # Find out which ABI we are using.
+ echo 'int i;' > conftest.$ac_ext
+ if AC_TRY_EVAL(ac_compile); then
+ case `/usr/bin/file conftest.o` in
+ *64-bit*)
+ case $lt_cv_prog_gnu_ld in
+ yes*)
+ case $host in
+ i?86-*-solaris*)
+ LD="${LD-ld} -m elf_x86_64"
+ ;;
+ sparc*-*-solaris*)
+ LD="${LD-ld} -m elf64_sparc"
+ ;;
+ esac
+ # GNU ld 2.21 introduced _sol2 emulations. Use them if available.
+ if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
+ LD="${LD-ld}_sol2"
+ fi
+ ;;
+ *)
+ if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+ LD="${LD-ld} -64"
+ fi
+ ;;
+ esac
+ ;;
+ esac
+ fi
+ rm -rf conftest*
+ ;;
+esac
+
+need_locks="$enable_libtool_lock"
+])# _LT_ENABLE_LOCK
+
+
+# _LT_PROG_AR
+# -----------
+m4_defun([_LT_PROG_AR],
+[AC_CHECK_TOOLS(AR, [ar], false)
+: ${AR=ar}
+: ${AR_FLAGS=cru}
+_LT_DECL([], [AR], [1], [The archiver])
+_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])
+
+AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
+ [lt_cv_ar_at_file=no
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM],
+ [echo conftest.$ac_objext > conftest.lst
+ lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'
+ AC_TRY_EVAL([lt_ar_try])
+ if test "$ac_status" -eq 0; then
+ # Ensure the archiver fails upon bogus file names.
+ rm -f conftest.$ac_objext libconftest.a
+ AC_TRY_EVAL([lt_ar_try])
+ if test "$ac_status" -ne 0; then
+ lt_cv_ar_at_file=@
+ fi
+ fi
+ rm -f conftest.* libconftest.a
+ ])
+ ])
+
+if test "x$lt_cv_ar_at_file" = xno; then
+ archiver_list_spec=
+else
+ archiver_list_spec=$lt_cv_ar_at_file
+fi
+_LT_DECL([], [archiver_list_spec], [1],
+ [How to feed a file listing to the archiver])
+])# _LT_PROG_AR
+
+
+# _LT_CMD_OLD_ARCHIVE
+# -------------------
+m4_defun([_LT_CMD_OLD_ARCHIVE],
+[_LT_PROG_AR
+
+AC_CHECK_TOOL(STRIP, strip, :)
+test -z "$STRIP" && STRIP=:
+_LT_DECL([], [STRIP], [1], [A symbol stripping program])
+
+AC_CHECK_TOOL(RANLIB, ranlib, :)
+test -z "$RANLIB" && RANLIB=:
+_LT_DECL([], [RANLIB], [1],
+ [Commands used to install an old-style archive])
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+ case $host_os in
+ openbsd*)
+ old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
+ ;;
+ *)
+ old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
+ ;;
+ esac
+ old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
+fi
+
+case $host_os in
+ darwin*)
+ lock_old_archive_extraction=yes ;;
+ *)
+ lock_old_archive_extraction=no ;;
+esac
+_LT_DECL([], [old_postinstall_cmds], [2])
+_LT_DECL([], [old_postuninstall_cmds], [2])
+_LT_TAGDECL([], [old_archive_cmds], [2],
+ [Commands used to build an old-style archive])
+_LT_DECL([], [lock_old_archive_extraction], [0],
+ [Whether to use a lock for old archive extraction])
+])# _LT_CMD_OLD_ARCHIVE
+
+
+# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+# [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------------------
+# Check whether the given compiler option works
+AC_DEFUN([_LT_COMPILER_OPTION],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_SED])dnl
+AC_CACHE_CHECK([$1], [$2],
+ [$2=no
+ m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+ lt_compiler_flag="$3"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ # The option is referenced via a variable to avoid confusing sed.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+ (eval "$lt_compile" 2>conftest.err)
+ ac_status=$?
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+ if (exit $ac_status) && test -s "$ac_outfile"; then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings other than the usual output.
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ $2=yes
+ fi
+ fi
+ $RM conftest*
+])
+
+if test x"[$]$2" = xyes; then
+ m4_if([$5], , :, [$5])
+else
+ m4_if([$6], , :, [$6])
+fi
+])# _LT_COMPILER_OPTION
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [])
+
+
+# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+# [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------
+# Check whether the given linker option works
+AC_DEFUN([_LT_LINKER_OPTION],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_SED])dnl
+AC_CACHE_CHECK([$1], [$2],
+ [$2=no
+ save_LDFLAGS="$LDFLAGS"
+ LDFLAGS="$LDFLAGS $3"
+ echo "$lt_simple_link_test_code" > conftest.$ac_ext
+ if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+ # The linker can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ if test -s conftest.err; then
+ # Append any errors to the config.log.
+ cat conftest.err 1>&AS_MESSAGE_LOG_FD
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+ if diff conftest.exp conftest.er2 >/dev/null; then
+ $2=yes
+ fi
+ else
+ $2=yes
+ fi
+ fi
+ $RM -r conftest*
+ LDFLAGS="$save_LDFLAGS"
+])
+
+if test x"[$]$2" = xyes; then
+ m4_if([$4], , :, [$4])
+else
+ m4_if([$5], , :, [$5])
+fi
+])# _LT_LINKER_OPTION
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [])
+
+
+# LT_CMD_MAX_LEN
+#---------------
+AC_DEFUN([LT_CMD_MAX_LEN],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+# find the maximum length of command line arguments
+AC_MSG_CHECKING([the maximum length of command line arguments])
+AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
+ i=0
+ teststring="ABCD"
+
+ case $build_os in
+ msdosdjgpp*)
+ # On DJGPP, this test can blow up pretty badly due to problems in libc
+ # (any single argument exceeding 2000 bytes causes a buffer overrun
+ # during glob expansion). Even if it were fixed, the result of this
+ # check would be larger than it should be.
+ lt_cv_sys_max_cmd_len=12288; # 12K is about right
+ ;;
+
+ gnu*)
+ # Under GNU Hurd, this test is not required because there is
+ # no limit to the length of command line arguments.
+ # Libtool will interpret -1 as no limit whatsoever
+ lt_cv_sys_max_cmd_len=-1;
+ ;;
+
+ cygwin* | mingw* | cegcc*)
+ # On Win9x/ME, this test blows up -- it succeeds, but takes
+ # about 5 minutes as the teststring grows exponentially.
+ # Worse, since 9x/ME are not pre-emptively multitasking,
+ # you end up with a "frozen" computer, even though with patience
+ # the test eventually succeeds (with a max line length of 256k).
+ # Instead, let's just punt: use the minimum linelength reported by
+ # all of the supported platforms: 8192 (on NT/2K/XP).
+ lt_cv_sys_max_cmd_len=8192;
+ ;;
+
+ mint*)
+ # On MiNT this can take a long time and run out of memory.
+ lt_cv_sys_max_cmd_len=8192;
+ ;;
+
+ amigaos*)
+ # On AmigaOS with pdksh, this test takes hours, literally.
+ # So we just punt and use a minimum line length of 8192.
+ lt_cv_sys_max_cmd_len=8192;
+ ;;
+
+ netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
+ # This has been around since 386BSD, at least. Likely further.
+ if test -x /sbin/sysctl; then
+ lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+ elif test -x /usr/sbin/sysctl; then
+ lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+ else
+ lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs
+ fi
+ # And add a safety zone
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+ ;;
+
+ interix*)
+ # We know the value 262144 and hardcode it with a safety zone (like BSD)
+ lt_cv_sys_max_cmd_len=196608
+ ;;
+
+ os2*)
+ # The test takes a long time on OS/2.
+ lt_cv_sys_max_cmd_len=8192
+ ;;
+
+ osf*)
+ # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+ # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+ # nice to cause kernel panics so lets avoid the loop below.
+ # First set a reasonable default.
+ lt_cv_sys_max_cmd_len=16384
+ #
+ if test -x /sbin/sysconfig; then
+ case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+ *1*) lt_cv_sys_max_cmd_len=-1 ;;
+ esac
+ fi
+ ;;
+ sco3.2v5*)
+ lt_cv_sys_max_cmd_len=102400
+ ;;
+ sysv5* | sco5v6* | sysv4.2uw2*)
+ kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+ if test -n "$kargmax"; then
+ lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ ]]//'`
+ else
+ lt_cv_sys_max_cmd_len=32768
+ fi
+ ;;
+ *)
+ lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+ if test -n "$lt_cv_sys_max_cmd_len" && \
+ test undefined != "$lt_cv_sys_max_cmd_len"; then
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+ else
+ # Make teststring a little bigger before we do anything with it.
+ # a 1K string should be a reasonable start.
+ for i in 1 2 3 4 5 6 7 8 ; do
+ teststring=$teststring$teststring
+ done
+ SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+ # If test is not a shell built-in, we'll probably end up computing a
+ # maximum length that is only half of the actual maximum length, but
+ # we can't tell.
+ while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \
+ = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+ test $i != 17 # 1/2 MB should be enough
+ do
+ i=`expr $i + 1`
+ teststring=$teststring$teststring
+ done
+ # Only check the string length outside the loop.
+ lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+ teststring=
+ # Add a significant safety factor because C++ compilers can tack on
+ # massive amounts of additional arguments before passing them to the
+ # linker. It appears as though 1/2 is a usable value.
+ lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+ fi
+ ;;
+ esac
+])
+if test -n $lt_cv_sys_max_cmd_len ; then
+ AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
+else
+ AC_MSG_RESULT(none)
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+_LT_DECL([], [max_cmd_len], [0],
+ [What is the maximum length of a command?])
+])# LT_CMD_MAX_LEN
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [])
+
+
+# _LT_HEADER_DLFCN
+# ----------------
+m4_defun([_LT_HEADER_DLFCN],
+[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
+])# _LT_HEADER_DLFCN
+
+
+# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
+# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
+# ----------------------------------------------------------------
+m4_defun([_LT_TRY_DLOPEN_SELF],
+[m4_require([_LT_HEADER_DLFCN])dnl
+if test "$cross_compiling" = yes; then :
+ [$4]
+else
+ lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+ lt_status=$lt_dlunknown
+ cat > conftest.$ac_ext <<_LT_EOF
+[#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+# define LT_DLGLOBAL RTLD_GLOBAL
+#else
+# ifdef DL_GLOBAL
+# define LT_DLGLOBAL DL_GLOBAL
+# else
+# define LT_DLGLOBAL 0
+# endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+ find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+# ifdef RTLD_LAZY
+# define LT_DLLAZY_OR_NOW RTLD_LAZY
+# else
+# ifdef DL_LAZY
+# define LT_DLLAZY_OR_NOW DL_LAZY
+# else
+# ifdef RTLD_NOW
+# define LT_DLLAZY_OR_NOW RTLD_NOW
+# else
+# ifdef DL_NOW
+# define LT_DLLAZY_OR_NOW DL_NOW
+# else
+# define LT_DLLAZY_OR_NOW 0
+# endif
+# endif
+# endif
+# endif
+#endif
+
+/* When -fvisbility=hidden is used, assume the code has been annotated
+ correspondingly for the symbols needed. */
+#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+ void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+ int status = $lt_dlunknown;
+
+ if (self)
+ {
+ if (dlsym (self,"fnord")) status = $lt_dlno_uscore;
+ else
+ {
+ if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+ else puts (dlerror ());
+ }
+ /* dlclose (self); */
+ }
+ else
+ puts (dlerror ());
+
+ return status;
+}]
+_LT_EOF
+ if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
+ (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
+ lt_status=$?
+ case x$lt_status in
+ x$lt_dlno_uscore) $1 ;;
+ x$lt_dlneed_uscore) $2 ;;
+ x$lt_dlunknown|x*) $3 ;;
+ esac
+ else :
+ # compilation failed
+ $3
+ fi
+fi
+rm -fr conftest*
+])# _LT_TRY_DLOPEN_SELF
+
+
+# LT_SYS_DLOPEN_SELF
+# ------------------
+AC_DEFUN([LT_SYS_DLOPEN_SELF],
+[m4_require([_LT_HEADER_DLFCN])dnl
+if test "x$enable_dlopen" != xyes; then
+ enable_dlopen=unknown
+ enable_dlopen_self=unknown
+ enable_dlopen_self_static=unknown
+else
+ lt_cv_dlopen=no
+ lt_cv_dlopen_libs=
+
+ case $host_os in
+ beos*)
+ lt_cv_dlopen="load_add_on"
+ lt_cv_dlopen_libs=
+ lt_cv_dlopen_self=yes
+ ;;
+
+ mingw* | pw32* | cegcc*)
+ lt_cv_dlopen="LoadLibrary"
+ lt_cv_dlopen_libs=
+ ;;
+
+ cygwin*)
+ lt_cv_dlopen="dlopen"
+ lt_cv_dlopen_libs=
+ ;;
+
+ darwin*)
+ # if libdl is installed we need to link against it
+ AC_CHECK_LIB([dl], [dlopen],
+ [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
+ lt_cv_dlopen="dyld"
+ lt_cv_dlopen_libs=
+ lt_cv_dlopen_self=yes
+ ])
+ ;;
+
+ *)
+ AC_CHECK_FUNC([shl_load],
+ [lt_cv_dlopen="shl_load"],
+ [AC_CHECK_LIB([dld], [shl_load],
+ [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"],
+ [AC_CHECK_FUNC([dlopen],
+ [lt_cv_dlopen="dlopen"],
+ [AC_CHECK_LIB([dl], [dlopen],
+ [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
+ [AC_CHECK_LIB([svld], [dlopen],
+ [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
+ [AC_CHECK_LIB([dld], [dld_link],
+ [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"])
+ ])
+ ])
+ ])
+ ])
+ ])
+ ;;
+ esac
+
+ if test "x$lt_cv_dlopen" != xno; then
+ enable_dlopen=yes
+ else
+ enable_dlopen=no
+ fi
+
+ case $lt_cv_dlopen in
+ dlopen)
+ save_CPPFLAGS="$CPPFLAGS"
+ test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+ save_LDFLAGS="$LDFLAGS"
+ wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+ save_LIBS="$LIBS"
+ LIBS="$lt_cv_dlopen_libs $LIBS"
+
+ AC_CACHE_CHECK([whether a program can dlopen itself],
+ lt_cv_dlopen_self, [dnl
+ _LT_TRY_DLOPEN_SELF(
+ lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
+ lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
+ ])
+
+ if test "x$lt_cv_dlopen_self" = xyes; then
+ wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+ AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
+ lt_cv_dlopen_self_static, [dnl
+ _LT_TRY_DLOPEN_SELF(
+ lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
+ lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross)
+ ])
+ fi
+
+ CPPFLAGS="$save_CPPFLAGS"
+ LDFLAGS="$save_LDFLAGS"
+ LIBS="$save_LIBS"
+ ;;
+ esac
+
+ case $lt_cv_dlopen_self in
+ yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+ *) enable_dlopen_self=unknown ;;
+ esac
+
+ case $lt_cv_dlopen_self_static in
+ yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+ *) enable_dlopen_self_static=unknown ;;
+ esac
+fi
+_LT_DECL([dlopen_support], [enable_dlopen], [0],
+ [Whether dlopen is supported])
+_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
+ [Whether dlopen of programs is supported])
+_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
+ [Whether dlopen of statically linked programs is supported])
+])# LT_SYS_DLOPEN_SELF
+
+# Old name:
+AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [])
+
+
+# _LT_COMPILER_C_O([TAGNAME])
+# ---------------------------
+# Check to see if options -c and -o are simultaneously supported by compiler.
+# This macro does not hard code the compiler like AC_PROG_CC_C_O.
+m4_defun([_LT_COMPILER_C_O],
+[m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
+ [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
+ [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
+ $RM -r conftest 2>/dev/null
+ mkdir conftest
+ cd conftest
+ mkdir out
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ lt_compiler_flag="-o out/conftest2.$ac_objext"
+ # Insert the option either (1) after the last *FLAGS variable, or
+ # (2) before a word containing "conftest.", or (3) at the end.
+ # Note that $ac_compile itself does not contain backslashes and begins
+ # with a dollar sign (not a hyphen), so the echo should work correctly.
+ lt_compile=`echo "$ac_compile" | $SED \
+ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+ -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+ -e 's:$: $lt_compiler_flag:'`
+ (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+ (eval "$lt_compile" 2>out/conftest.err)
+ ac_status=$?
+ cat out/conftest.err >&AS_MESSAGE_LOG_FD
+ echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+ if (exit $ac_status) && test -s out/conftest2.$ac_objext
+ then
+ # The compiler can only warn and ignore the option if not recognized
+ # So say no if there are warnings
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+ if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+ fi
+ fi
+ chmod u+w . 2>&AS_MESSAGE_LOG_FD
+ $RM conftest*
+ # SGI C++ compiler will create directory out/ii_files/ for
+ # template instantiation
+ test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+ $RM out/* && rmdir out
+ cd ..
+ $RM -r conftest
+ $RM conftest*
+])
+_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
+ [Does compiler simultaneously support -c and -o options?])
+])# _LT_COMPILER_C_O
+
+
+# _LT_COMPILER_FILE_LOCKS([TAGNAME])
+# ----------------------------------
+# Check to see if we can do hard links to lock some files if needed
+m4_defun([_LT_COMPILER_FILE_LOCKS],
+[m4_require([_LT_ENABLE_LOCK])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+_LT_COMPILER_C_O([$1])
+
+hard_links="nottested"
+if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
+ # do not overwrite the value of need_locks provided by the user
+ AC_MSG_CHECKING([if we can lock with hard links])
+ hard_links=yes
+ $RM conftest*
+ ln conftest.a conftest.b 2>/dev/null && hard_links=no
+ touch conftest.a
+ ln conftest.a conftest.b 2>&5 || hard_links=no
+ ln conftest.a conftest.b 2>/dev/null && hard_links=no
+ AC_MSG_RESULT([$hard_links])
+ if test "$hard_links" = no; then
+ AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
+ need_locks=warn
+ fi
+else
+ need_locks=no
+fi
+_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
+])# _LT_COMPILER_FILE_LOCKS
+
+
+# _LT_CHECK_OBJDIR
+# ----------------
+m4_defun([_LT_CHECK_OBJDIR],
+[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
+[rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+ lt_cv_objdir=.libs
+else
+ # MS-DOS does not allow filenames that begin with a dot.
+ lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null])
+objdir=$lt_cv_objdir
+_LT_DECL([], [objdir], [0],
+ [The name of the directory that contains temporary libtool files])dnl
+m4_pattern_allow([LT_OBJDIR])dnl
+AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/",
+ [Define to the sub-directory in which libtool stores uninstalled libraries.])
+])# _LT_CHECK_OBJDIR
+
+
+# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME])
+# --------------------------------------
+# Check hardcoding attributes.
+m4_defun([_LT_LINKER_HARDCODE_LIBPATH],
+[AC_MSG_CHECKING([how to hardcode library paths into programs])
+_LT_TAGVAR(hardcode_action, $1)=
+if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
+ test -n "$_LT_TAGVAR(runpath_var, $1)" ||
+ test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then
+
+ # We can hardcode non-existent directories.
+ if test "$_LT_TAGVAR(hardcode_direct, $1)" != no &&
+ # If the only mechanism to avoid hardcoding is shlibpath_var, we
+ # have to relink, otherwise we might link with an installed library
+ # when we should be linking with a yet-to-be-installed one
+ ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
+ test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then
+ # Linking always hardcodes the temporary library directory.
+ _LT_TAGVAR(hardcode_action, $1)=relink
+ else
+ # We can link without hardcoding, and we can hardcode nonexisting dirs.
+ _LT_TAGVAR(hardcode_action, $1)=immediate
+ fi
+else
+ # We cannot hardcode anything, or else we can only hardcode existing
+ # directories.
+ _LT_TAGVAR(hardcode_action, $1)=unsupported
+fi
+AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)])
+
+if test "$_LT_TAGVAR(hardcode_action, $1)" = relink ||
+ test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then
+ # Fast installation is not supported
+ enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+ test "$enable_shared" = no; then
+ # Fast installation is not necessary
+ enable_fast_install=needless
+fi
+_LT_TAGDECL([], [hardcode_action], [0],
+ [How to hardcode a shared library path into an executable])
+])# _LT_LINKER_HARDCODE_LIBPATH
+
+
+# _LT_CMD_STRIPLIB
+# ----------------
+m4_defun([_LT_CMD_STRIPLIB],
+[m4_require([_LT_DECL_EGREP])
+striplib=
+old_striplib=
+AC_MSG_CHECKING([whether stripping libraries is possible])
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+ test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+ test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+ AC_MSG_RESULT([yes])
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+ case $host_os in
+ darwin*)
+ if test -n "$STRIP" ; then
+ striplib="$STRIP -x"
+ old_striplib="$STRIP -S"
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ fi
+ ;;
+ *)
+ AC_MSG_RESULT([no])
+ ;;
+ esac
+fi
+_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
+_LT_DECL([], [striplib], [1])
+])# _LT_CMD_STRIPLIB
+
+
+# _LT_SYS_DYNAMIC_LINKER([TAG])
+# -----------------------------
+# PORTME Fill in your ld.so characteristics
+m4_defun([_LT_SYS_DYNAMIC_LINKER],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_OBJDUMP])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_CHECK_SHELL_FEATURES])dnl
+AC_MSG_CHECKING([dynamic linker characteristics])
+m4_if([$1],
+ [], [
+if test "$GCC" = yes; then
+ case $host_os in
+ darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
+ *) lt_awk_arg="/^libraries:/" ;;
+ esac
+ case $host_os in
+ mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;;
+ *) lt_sed_strip_eq="s,=/,/,g" ;;
+ esac
+ lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
+ case $lt_search_path_spec in
+ *\;*)
+ # if the path contains ";" then we assume it to be the separator
+ # otherwise default to the standard path separator (i.e. ":") - it is
+ # assumed that no part of a normal pathname contains ";" but that should
+ # okay in the real world where ";" in dirpaths is itself problematic.
+ lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
+ ;;
+ *)
+ lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
+ ;;
+ esac
+ # Ok, now we have the path, separated by spaces, we can step through it
+ # and add multilib dir if necessary.
+ lt_tmp_lt_search_path_spec=
+ lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+ for lt_sys_path in $lt_search_path_spec; do
+ if test -d "$lt_sys_path/$lt_multi_os_dir"; then
+ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
+ else
+ test -d "$lt_sys_path" && \
+ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+ fi
+ done
+ lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
+BEGIN {RS=" "; FS="/|\n";} {
+ lt_foo="";
+ lt_count=0;
+ for (lt_i = NF; lt_i > 0; lt_i--) {
+ if ($lt_i != "" && $lt_i != ".") {
+ if ($lt_i == "..") {
+ lt_count++;
+ } else {
+ if (lt_count == 0) {
+ lt_foo="/" $lt_i lt_foo;
+ } else {
+ lt_count--;
+ }
+ }
+ }
+ }
+ if (lt_foo != "") { lt_freq[[lt_foo]]++; }
+ if (lt_freq[[lt_foo]] == 1) { print lt_foo; }
+}'`
+ # AWK program above erroneously prepends '/' to C:/dos/paths
+ # for these hosts.
+ case $host_os in
+ mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
+ $SED 's,/\([[A-Za-z]]:\),\1,g'` ;;
+ esac
+ sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
+else
+ sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi])
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+ shlibpath_var=LIBPATH
+
+ # AIX 3 has no versioning support, so we append a major version to the name.
+ soname_spec='${libname}${release}${shared_ext}$major'
+ ;;
+
+aix[[4-9]]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ hardcode_into_libs=yes
+ if test "$host_cpu" = ia64; then
+ # AIX 5 supports IA64
+ library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ else
+ # With GCC up to 2.95.x, collect2 would create an import file
+ # for dependence libraries. The import file would start with
+ # the line `#! .'. This would cause the generated library to
+ # depend on `.', always an invalid library. This was fixed in
+ # development snapshots of GCC prior to 3.0.
+ case $host_os in
+ aix4 | aix4.[[01]] | aix4.[[01]].*)
+ if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+ echo ' yes '
+ echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+ :
+ else
+ can_build_shared=no
+ fi
+ ;;
+ esac
+ # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+ # soname into executable. Probably we can add versioning support to
+ # collect2, so additional links can be useful in future.
+ if test "$aix_use_runtimelinking" = yes; then
+ # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+ # instead of lib<name>.a to let people know that these are not
+ # typical AIX shared libraries.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ else
+ # We preserve .a as extension for shared libraries through AIX4.2
+ # and later when we are not doing run time linking.
+ library_names_spec='${libname}${release}.a $libname.a'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ fi
+ shlibpath_var=LIBPATH
+ fi
+ ;;
+
+amigaos*)
+ case $host_cpu in
+ powerpc)
+ # Since July 2007 AmigaOS4 officially supports .so libraries.
+ # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ ;;
+ m68k)
+ library_names_spec='$libname.ixlibrary $libname.a'
+ # Create ${libname}_ixlibrary.a entries in /sys/libs.
+ finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+ ;;
+ esac
+ ;;
+
+beos*)
+ library_names_spec='${libname}${shared_ext}'
+ dynamic_linker="$host_os ld.so"
+ shlibpath_var=LIBRARY_PATH
+ ;;
+
+bsdi[[45]]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+ sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+ # the default ld.so.conf also contains /usr/contrib/lib and
+ # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+ # libtool to hard-code these into programs
+ ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+ version_type=windows
+ shrext_cmds=".dll"
+ need_version=no
+ need_lib_prefix=no
+
+ case $GCC,$cc_basename in
+ yes,*)
+ # gcc
+ library_names_spec='$libname.dll.a'
+ # DLL is installed to $(libdir)/../bin by postinstall_cmds
+ postinstall_cmds='base_file=`basename \${file}`~
+ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+ dldir=$destdir/`dirname \$dlpath`~
+ test -d \$dldir || mkdir -p \$dldir~
+ $install_prog $dir/$dlname \$dldir/$dlname~
+ chmod a+x \$dldir/$dlname~
+ if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+ eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+ fi'
+ postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+ dlpath=$dir/\$dldll~
+ $RM \$dlpath'
+ shlibpath_overrides_runpath=yes
+
+ case $host_os in
+ cygwin*)
+ # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+ soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+m4_if([$1], [],[
+ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"])
+ ;;
+ mingw* | cegcc*)
+ # MinGW DLLs use traditional 'lib' prefix
+ soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+ ;;
+ pw32*)
+ # pw32 DLLs use 'pw' prefix rather than 'lib'
+ library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+ ;;
+ esac
+ dynamic_linker='Win32 ld.exe'
+ ;;
+
+ *,cl*)
+ # Native MSVC
+ libname_spec='$name'
+ soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+ library_names_spec='${libname}.dll.lib'
+
+ case $build_os in
+ mingw*)
+ sys_lib_search_path_spec=
+ lt_save_ifs=$IFS
+ IFS=';'
+ for lt_path in $LIB
+ do
+ IFS=$lt_save_ifs
+ # Let DOS variable expansion print the short 8.3 style file name.
+ lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+ sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+ done
+ IFS=$lt_save_ifs
+ # Convert to MSYS style.
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'`
+ ;;
+ cygwin*)
+ # Convert to unix form, then to dos form, then back to unix form
+ # but this time dos style (no spaces!) so that the unix form looks
+ # like /cygdrive/c/PROGRA~1:/cygdr...
+ sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+ sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+ sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+ ;;
+ *)
+ sys_lib_search_path_spec="$LIB"
+ if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
+ # It is most probably a Windows format PATH.
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+ else
+ sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+ fi
+ # FIXME: find the short name or the path components, as spaces are
+ # common. (e.g. "Program Files" -> "PROGRA~1")
+ ;;
+ esac
+
+ # DLL is installed to $(libdir)/../bin by postinstall_cmds
+ postinstall_cmds='base_file=`basename \${file}`~
+ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
+ dldir=$destdir/`dirname \$dlpath`~
+ test -d \$dldir || mkdir -p \$dldir~
+ $install_prog $dir/$dlname \$dldir/$dlname'
+ postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+ dlpath=$dir/\$dldll~
+ $RM \$dlpath'
+ shlibpath_overrides_runpath=yes
+ dynamic_linker='Win32 link.exe'
+ ;;
+
+ *)
+ # Assume MSVC wrapper
+ library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
+ dynamic_linker='Win32 ld.exe'
+ ;;
+ esac
+ # FIXME: first we should search . and the directory the executable is in
+ shlibpath_var=PATH
+ ;;
+
+darwin* | rhapsody*)
+ dynamic_linker="$host_os dyld"
+ version_type=darwin
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+ soname_spec='${libname}${release}${major}$shared_ext'
+ shlibpath_overrides_runpath=yes
+ shlibpath_var=DYLD_LIBRARY_PATH
+ shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+m4_if([$1], [],[
+ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"])
+ sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+ ;;
+
+dgux*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ ;;
+
+freebsd* | dragonfly*)
+ # DragonFly does not have aout. When/if they implement a new
+ # versioning mechanism, adjust this.
+ if test -x /usr/bin/objformat; then
+ objformat=`/usr/bin/objformat`
+ else
+ case $host_os in
+ freebsd[[23]].*) objformat=aout ;;
+ *) objformat=elf ;;
+ esac
+ fi
+ version_type=freebsd-$objformat
+ case $version_type in
+ freebsd-elf*)
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+ need_version=no
+ need_lib_prefix=no
+ ;;
+ freebsd-*)
+ library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+ need_version=yes
+ ;;
+ esac
+ shlibpath_var=LD_LIBRARY_PATH
+ case $host_os in
+ freebsd2.*)
+ shlibpath_overrides_runpath=yes
+ ;;
+ freebsd3.[[01]]* | freebsdelf3.[[01]]*)
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+ freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
+ freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+ *) # from 4.6 on, and DragonFly
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+ esac
+ ;;
+
+haiku*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ dynamic_linker="$host_os runtime_loader"
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+ hardcode_into_libs=yes
+ ;;
+
+hpux9* | hpux10* | hpux11*)
+ # Give a soname corresponding to the major version so that dld.sl refuses to
+ # link against other versions.
+ version_type=sunos
+ need_lib_prefix=no
+ need_version=no
+ case $host_cpu in
+ ia64*)
+ shrext_cmds='.so'
+ hardcode_into_libs=yes
+ dynamic_linker="$host_os dld.so"
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ if test "X$HPUX_IA64_MODE" = X32; then
+ sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+ else
+ sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+ fi
+ sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+ ;;
+ hppa*64*)
+ shrext_cmds='.sl'
+ hardcode_into_libs=yes
+ dynamic_linker="$host_os dld.sl"
+ shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+ shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+ sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+ ;;
+ *)
+ shrext_cmds='.sl'
+ dynamic_linker="$host_os dld.sl"
+ shlibpath_var=SHLIB_PATH
+ shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ ;;
+ esac
+ # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+ postinstall_cmds='chmod 555 $lib'
+ # or fails outright, so override atomically:
+ install_override_mode=555
+ ;;
+
+interix[[3-9]]*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
+irix5* | irix6* | nonstopux*)
+ case $host_os in
+ nonstopux*) version_type=nonstopux ;;
+ *)
+ if test "$lt_cv_prog_gnu_ld" = yes; then
+ version_type=linux # correct to gnu/linux during the next big refactor
+ else
+ version_type=irix
+ fi ;;
+ esac
+ need_lib_prefix=no
+ need_version=no
+ soname_spec='${libname}${release}${shared_ext}$major'
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+ case $host_os in
+ irix5* | nonstopux*)
+ libsuff= shlibsuff=
+ ;;
+ *)
+ case $LD in # libtool.m4 will add one of these switches to LD
+ *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+ libsuff= shlibsuff= libmagic=32-bit;;
+ *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+ libsuff=32 shlibsuff=N32 libmagic=N32;;
+ *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+ libsuff=64 shlibsuff=64 libmagic=64-bit;;
+ *) libsuff= shlibsuff= libmagic=never-match;;
+ esac
+ ;;
+ esac
+ shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+ shlibpath_overrides_runpath=no
+ sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+ sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+ hardcode_into_libs=yes
+ ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+ dynamic_linker=no
+ ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+
+ # Some binutils ld are patched to set DT_RUNPATH
+ AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath],
+ [lt_cv_shlibpath_overrides_runpath=no
+ save_LDFLAGS=$LDFLAGS
+ save_libdir=$libdir
+ eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \
+ LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\""
+ AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+ [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null],
+ [lt_cv_shlibpath_overrides_runpath=yes])])
+ LDFLAGS=$save_LDFLAGS
+ libdir=$save_libdir
+ ])
+ shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+ # This implies no fast_install, which is unacceptable.
+ # Some rework will be needed to allow for fast_install
+ # before this can be enabled.
+ hardcode_into_libs=yes
+
+ # Append ld.so.conf contents to the search path
+ if test -f /etc/ld.so.conf; then
+ lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '`
+ sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+ fi
+
+ # We used to test for /lib/ld.so.1 and disable shared libraries on
+ # powerpc, because MkLinux only supported shared libraries with the
+ # GNU dynamic linker. Since this was broken with cross compilers,
+ # most powerpc-linux boxes support dynamic linking these days and
+ # people can always --disable-shared, the test was removed, and we
+ # assume the GNU/Linux dynamic linker is in use.
+ dynamic_linker='GNU/Linux ld.so'
+ ;;
+
+netbsdelf*-gnu)
+ version_type=linux
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ dynamic_linker='NetBSD ld.elf_so'
+ ;;
+
+netbsd*)
+ version_type=sunos
+ need_lib_prefix=no
+ need_version=no
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+ dynamic_linker='NetBSD (a.out) ld.so'
+ else
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ dynamic_linker='NetBSD ld.elf_so'
+ fi
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ ;;
+
+newsos6)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ ;;
+
+*nto* | *qnx*)
+ version_type=qnx
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ dynamic_linker='ldqnx.so'
+ ;;
+
+openbsd*)
+ version_type=sunos
+ sys_lib_dlsearch_path_spec="/usr/lib"
+ need_lib_prefix=no
+ # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
+ case $host_os in
+ openbsd3.3 | openbsd3.3.*) need_version=yes ;;
+ *) need_version=no ;;
+ esac
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ case $host_os in
+ openbsd2.[[89]] | openbsd2.[[89]].*)
+ shlibpath_overrides_runpath=no
+ ;;
+ *)
+ shlibpath_overrides_runpath=yes
+ ;;
+ esac
+ else
+ shlibpath_overrides_runpath=yes
+ fi
+ ;;
+
+os2*)
+ libname_spec='$name'
+ shrext_cmds=".dll"
+ need_lib_prefix=no
+ library_names_spec='$libname${shared_ext} $libname.a'
+ dynamic_linker='OS/2 ld.exe'
+ shlibpath_var=LIBPATH
+ ;;
+
+osf3* | osf4* | osf5*)
+ version_type=osf
+ need_lib_prefix=no
+ need_version=no
+ soname_spec='${libname}${release}${shared_ext}$major'
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+ sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+ ;;
+
+rdos*)
+ dynamic_linker=no
+ ;;
+
+solaris*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ # ldd complains unless libraries are executable
+ postinstall_cmds='chmod +x $lib'
+ ;;
+
+sunos4*)
+ version_type=sunos
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+ finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ if test "$with_gnu_ld" = yes; then
+ need_lib_prefix=no
+ fi
+ need_version=yes
+ ;;
+
+sysv4 | sysv4.3*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ case $host_vendor in
+ sni)
+ shlibpath_overrides_runpath=no
+ need_lib_prefix=no
+ runpath_var=LD_RUN_PATH
+ ;;
+ siemens)
+ need_lib_prefix=no
+ ;;
+ motorola)
+ need_lib_prefix=no
+ need_version=no
+ shlibpath_overrides_runpath=no
+ sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+ ;;
+ esac
+ ;;
+
+sysv4*MP*)
+ if test -d /usr/nec ;then
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+ soname_spec='$libname${shared_ext}.$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ fi
+ ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+ version_type=freebsd-elf
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=yes
+ hardcode_into_libs=yes
+ if test "$with_gnu_ld" = yes; then
+ sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+ else
+ sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+ case $host_os in
+ sco3.2v5*)
+ sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+ ;;
+ esac
+ fi
+ sys_lib_dlsearch_path_spec='/usr/lib'
+ ;;
+
+tpf*)
+ # TPF is a cross-target only. Preferred cross-host = GNU/Linux.
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
+uts4*)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+ soname_spec='${libname}${release}${shared_ext}$major'
+ shlibpath_var=LD_LIBRARY_PATH
+ ;;
+
+*)
+ dynamic_linker=no
+ ;;
+esac
+AC_MSG_RESULT([$dynamic_linker])
+test "$dynamic_linker" = no && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+ variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then
+ sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec"
+fi
+if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then
+ sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec"
+fi
+
+_LT_DECL([], [variables_saved_for_relink], [1],
+ [Variables whose values should be saved in libtool wrapper scripts and
+ restored at link time])
+_LT_DECL([], [need_lib_prefix], [0],
+ [Do we need the "lib" prefix for modules?])
+_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
+_LT_DECL([], [version_type], [0], [Library versioning type])
+_LT_DECL([], [runpath_var], [0], [Shared library runtime path variable])
+_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
+_LT_DECL([], [shlibpath_overrides_runpath], [0],
+ [Is shlibpath searched before the hard-coded library search path?])
+_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
+_LT_DECL([], [library_names_spec], [1],
+ [[List of archive names. First name is the real one, the rest are links.
+ The last name is the one that the linker finds with -lNAME]])
+_LT_DECL([], [soname_spec], [1],
+ [[The coded name of the library, if different from the real name]])
+_LT_DECL([], [install_override_mode], [1],
+ [Permission mode override for installation of shared libraries])
+_LT_DECL([], [postinstall_cmds], [2],
+ [Command to use after installation of a shared archive])
+_LT_DECL([], [postuninstall_cmds], [2],
+ [Command to use after uninstallation of a shared archive])
+_LT_DECL([], [finish_cmds], [2],
+ [Commands used to finish a libtool library installation in a directory])
+_LT_DECL([], [finish_eval], [1],
+ [[As "finish_cmds", except a single script fragment to be evaled but
+ not shown]])
+_LT_DECL([], [hardcode_into_libs], [0],
+ [Whether we should hardcode library paths into libraries])
+_LT_DECL([], [sys_lib_search_path_spec], [2],
+ [Compile-time system search path for libraries])
+_LT_DECL([], [sys_lib_dlsearch_path_spec], [2],
+ [Run-time system search path for libraries])
+])# _LT_SYS_DYNAMIC_LINKER
+
+
+# _LT_PATH_TOOL_PREFIX(TOOL)
+# --------------------------
+# find a file program which can recognize shared library
+AC_DEFUN([_LT_PATH_TOOL_PREFIX],
+[m4_require([_LT_DECL_EGREP])dnl
+AC_MSG_CHECKING([for $1])
+AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
+[case $MAGIC_CMD in
+[[\\/*] | ?:[\\/]*])
+ lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+ ;;
+*)
+ lt_save_MAGIC_CMD="$MAGIC_CMD"
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+dnl $ac_dummy forces splitting on constant user-supplied paths.
+dnl POSIX.2 word splitting is done only on the output of word expansions,
+dnl not every word. This closes a longstanding sh security hole.
+ ac_dummy="m4_if([$2], , $PATH, [$2])"
+ for ac_dir in $ac_dummy; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ if test -f $ac_dir/$1; then
+ lt_cv_path_MAGIC_CMD="$ac_dir/$1"
+ if test -n "$file_magic_test_file"; then
+ case $deplibs_check_method in
+ "file_magic "*)
+ file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
+ MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+ if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+ $EGREP "$file_magic_regex" > /dev/null; then
+ :
+ else
+ cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such. This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem. Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+ fi ;;
+ esac
+ fi
+ break
+ fi
+ done
+ IFS="$lt_save_ifs"
+ MAGIC_CMD="$lt_save_MAGIC_CMD"
+ ;;
+esac])
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+ AC_MSG_RESULT($MAGIC_CMD)
+else
+ AC_MSG_RESULT(no)
+fi
+_LT_DECL([], [MAGIC_CMD], [0],
+ [Used to examine libraries when file_magic_cmd begins with "file"])dnl
+])# _LT_PATH_TOOL_PREFIX
+
+# Old name:
+AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], [])
+
+
+# _LT_PATH_MAGIC
+# --------------
+# find a file program which can recognize a shared library
+m4_defun([_LT_PATH_MAGIC],
+[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+ if test -n "$ac_tool_prefix"; then
+ _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
+ else
+ MAGIC_CMD=:
+ fi
+fi
+])# _LT_PATH_MAGIC
+
+
+# LT_PATH_LD
+# ----------
+# find the pathname to the GNU or non-GNU linker
+AC_DEFUN([LT_PATH_LD],
+[AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_PROG_ECHO_BACKSLASH])dnl
+
+AC_ARG_WITH([gnu-ld],
+ [AS_HELP_STRING([--with-gnu-ld],
+ [assume the C compiler uses GNU ld @<:@default=no@:>@])],
+ [test "$withval" = no || with_gnu_ld=yes],
+ [with_gnu_ld=no])dnl
+
+ac_prog=ld
+if test "$GCC" = yes; then
+ # Check if gcc -print-prog-name=ld gives a path.
+ AC_MSG_CHECKING([for ld used by $CC])
+ case $host in
+ *-*-mingw*)
+ # gcc leaves a trailing carriage return which upsets mingw
+ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+ *)
+ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+ esac
+ case $ac_prog in
+ # Accept absolute paths.
+ [[\\/]]* | ?:[[\\/]]*)
+ re_direlt='/[[^/]][[^/]]*/\.\./'
+ # Canonicalize the pathname of ld
+ ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+ while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+ ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+ done
+ test -z "$LD" && LD="$ac_prog"
+ ;;
+ "")
+ # If it fails, then pretend we aren't using GCC.
+ ac_prog=ld
+ ;;
+ *)
+ # If it is relative, then search for the first ld in PATH.
+ with_gnu_ld=unknown
+ ;;
+ esac
+elif test "$with_gnu_ld" = yes; then
+ AC_MSG_CHECKING([for GNU ld])
+else
+ AC_MSG_CHECKING([for non-GNU ld])
+fi
+AC_CACHE_VAL(lt_cv_path_LD,
+[if test -z "$LD"; then
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+ for ac_dir in $PATH; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+ lt_cv_path_LD="$ac_dir/$ac_prog"
+ # Check to see if the program is GNU ld. I'd rather use --version,
+ # but apparently some variants of GNU ld only accept -v.
+ # Break only if it was the GNU/non-GNU ld that we prefer.
+ case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+ *GNU* | *'with BFD'*)
+ test "$with_gnu_ld" != no && break
+ ;;
+ *)
+ test "$with_gnu_ld" != yes && break
+ ;;
+ esac
+ fi
+ done
+ IFS="$lt_save_ifs"
+else
+ lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi])
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+ AC_MSG_RESULT($LD)
+else
+ AC_MSG_RESULT(no)
+fi
+test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
+_LT_PATH_LD_GNU
+AC_SUBST([LD])
+
+_LT_TAGDECL([], [LD], [1], [The linker used to build libraries])
+])# LT_PATH_LD
+
+# Old names:
+AU_ALIAS([AM_PROG_LD], [LT_PATH_LD])
+AU_ALIAS([AC_PROG_LD], [LT_PATH_LD])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_PROG_LD], [])
+dnl AC_DEFUN([AC_PROG_LD], [])
+
+
+# _LT_PATH_LD_GNU
+#- --------------
+m4_defun([_LT_PATH_LD_GNU],
+[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
+[# I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+ lt_cv_prog_gnu_ld=yes
+ ;;
+*)
+ lt_cv_prog_gnu_ld=no
+ ;;
+esac])
+with_gnu_ld=$lt_cv_prog_gnu_ld
+])# _LT_PATH_LD_GNU
+
+
+# _LT_CMD_RELOAD
+# --------------
+# find reload flag for linker
+# -- PORTME Some linkers may need a different reload flag.
+m4_defun([_LT_CMD_RELOAD],
+[AC_CACHE_CHECK([for $LD option to reload object files],
+ lt_cv_ld_reload_flag,
+ [lt_cv_ld_reload_flag='-r'])
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+ cygwin* | mingw* | pw32* | cegcc*)
+ if test "$GCC" != yes; then
+ reload_cmds=false
+ fi
+ ;;
+ darwin*)
+ if test "$GCC" = yes; then
+ reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
+ else
+ reload_cmds='$LD$reload_flag -o $output$reload_objs'
+ fi
+ ;;
+esac
+_LT_TAGDECL([], [reload_flag], [1], [How to create reloadable object files])dnl
+_LT_TAGDECL([], [reload_cmds], [2])dnl
+])# _LT_CMD_RELOAD
+
+
+# _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
+# which responds to the $file_magic_cmd with a given extended regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix[[4-9]]*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+beos*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+bsdi[[45]]*)
+ lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
+ lt_cv_file_magic_cmd='/usr/bin/file -L'
+ lt_cv_file_magic_test_file=/shlib/libc.so
+ ;;
+
+cygwin*)
+ # func_win32_libid is a shell function defined in ltmain.sh
+ lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+ lt_cv_file_magic_cmd='func_win32_libid'
+ ;;
+
+mingw* | pw32*)
+ # Base MSYS/MinGW do not provide the 'file' command needed by
+ # func_win32_libid shell function, so use a weaker test based on 'objdump',
+ # unless we find 'file', for example because we are cross-compiling.
+ # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin.
+ if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then
+ lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+ lt_cv_file_magic_cmd='func_win32_libid'
+ else
+ # Keep this pattern in sync with the one in func_win32_libid.
+ lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
+ lt_cv_file_magic_cmd='$OBJDUMP -f'
+ fi
+ ;;
+
+cegcc*)
+ # use the weaker test based on 'objdump'. See mingw*.
+ lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+ lt_cv_file_magic_cmd='$OBJDUMP -f'
+ ;;
+
+darwin* | rhapsody*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+freebsd* | dragonfly*)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+ case $host_cpu in
+ i*86 )
+ # Not sure whether the presence of OpenBSD here was a mistake.
+ # Let's accept both of them until this is cleared up.
+ lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
+ lt_cv_file_magic_cmd=/usr/bin/file
+ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+ ;;
+ esac
+ else
+ lt_cv_deplibs_check_method=pass_all
+ fi
+ ;;
+
+haiku*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+hpux10.20* | hpux11*)
+ lt_cv_file_magic_cmd=/usr/bin/file
+ case $host_cpu in
+ ia64*)
+ lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
+ lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+ ;;
+ hppa*64*)
+ [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]']
+ lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+ ;;
+ *)
+ lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library'
+ lt_cv_file_magic_test_file=/usr/lib/libc.sl
+ ;;
+ esac
+ ;;
+
+interix[[3-9]]*)
+ # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+ lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
+ ;;
+
+irix5* | irix6* | nonstopux*)
+ case $LD in
+ *-32|*"-32 ") libmagic=32-bit;;
+ *-n32|*"-n32 ") libmagic=N32;;
+ *-64|*"-64 ") libmagic=64-bit;;
+ *) libmagic=never-match;;
+ esac
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+netbsd* | netbsdelf*-gnu)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+ lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+ else
+ lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
+ fi
+ ;;
+
+newos6*)
+ lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
+ lt_cv_file_magic_cmd=/usr/bin/file
+ lt_cv_file_magic_test_file=/usr/lib/libnls.so
+ ;;
+
+*nto* | *qnx*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+openbsd*)
+ if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
+ else
+ lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+ fi
+ ;;
+
+osf3* | osf4* | osf5*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+rdos*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+solaris*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+
+sysv4 | sysv4.3*)
+ case $host_vendor in
+ motorola)
+ lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
+ lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+ ;;
+ ncr)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+ sequent)
+ lt_cv_file_magic_cmd='/bin/file'
+ lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
+ ;;
+ sni)
+ lt_cv_file_magic_cmd='/bin/file'
+ lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
+ lt_cv_file_magic_test_file=/lib/libc.so
+ ;;
+ siemens)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+ pc)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+ esac
+ ;;
+
+tpf*)
+ lt_cv_deplibs_check_method=pass_all
+ ;;
+esac
+])
+
+file_magic_glob=
+want_nocaseglob=no
+if test "$build" = "$host"; then
+ case $host_os in
+ mingw* | pw32*)
+ if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
+ want_nocaseglob=yes
+ else
+ file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"`
+ fi
+ ;;
+ esac
+fi
+
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+_LT_DECL([], [deplibs_check_method], [1],
+ [Method to check whether dependent libraries are shared objects])
+_LT_DECL([], [file_magic_cmd], [1],
+ [Command to use when deplibs_check_method = "file_magic"])
+_LT_DECL([], [file_magic_glob], [1],
+ [How to find potential files when deplibs_check_method = "file_magic"])
+_LT_DECL([], [want_nocaseglob], [1],
+ [Find potential files using nocaseglob when deplibs_check_method = "file_magic"])
+])# _LT_CHECK_MAGIC_METHOD
+
+
+# LT_PATH_NM
+# ----------
+# find the pathname to a BSD- or MS-compatible name lister
+AC_DEFUN([LT_PATH_NM],
+[AC_REQUIRE([AC_PROG_CC])dnl
+AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM,
+[if test -n "$NM"; then
+ # Let the user override the test.
+ lt_cv_path_NM="$NM"
+else
+ lt_nm_to_check="${ac_tool_prefix}nm"
+ if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+ lt_nm_to_check="$lt_nm_to_check nm"
+ fi
+ for lt_tmp_nm in $lt_nm_to_check; do
+ lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+ for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+ IFS="$lt_save_ifs"
+ test -z "$ac_dir" && ac_dir=.
+ tmp_nm="$ac_dir/$lt_tmp_nm"
+ if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+ # Check to see if the nm accepts a BSD-compat flag.
+ # Adding the `sed 1q' prevents false positives on HP-UX, which says:
+ # nm: unknown option "B" ignored
+ # Tru64's nm complains that /dev/null is an invalid object file
+ case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
+ */dev/null* | *'Invalid file or object type'*)
+ lt_cv_path_NM="$tmp_nm -B"
+ break
+ ;;
+ *)
+ case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+ */dev/null*)
+ lt_cv_path_NM="$tmp_nm -p"
+ break
+ ;;
+ *)
+ lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+ continue # so that we can try to find one that supports BSD flags
+ ;;
+ esac
+ ;;
+ esac
+ fi
+ done
+ IFS="$lt_save_ifs"
+ done
+ : ${lt_cv_path_NM=no}
+fi])
+if test "$lt_cv_path_NM" != "no"; then
+ NM="$lt_cv_path_NM"
+else
+ # Didn't find any BSD compatible name lister, look for dumpbin.
+ if test -n "$DUMPBIN"; then :
+ # Let the user override the test.
+ else
+ AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :)
+ case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in
+ *COFF*)
+ DUMPBIN="$DUMPBIN -symbols"
+ ;;
+ *)
+ DUMPBIN=:
+ ;;
+ esac
+ fi
+ AC_SUBST([DUMPBIN])
+ if test "$DUMPBIN" != ":"; then
+ NM="$DUMPBIN"
+ fi
+fi
+test -z "$NM" && NM=nm
+AC_SUBST([NM])
+_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl
+
+AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface],
+ [lt_cv_nm_interface="BSD nm"
+ echo "int some_variable = 0;" > conftest.$ac_ext
+ (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD)
+ (eval "$ac_compile" 2>conftest.err)
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD)
+ (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD)
+ cat conftest.out >&AS_MESSAGE_LOG_FD
+ if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+ lt_cv_nm_interface="MS dumpbin"
+ fi
+ rm -f conftest*])
+])# LT_PATH_NM
+
+# Old names:
+AU_ALIAS([AM_PROG_NM], [LT_PATH_NM])
+AU_ALIAS([AC_PROG_NM], [LT_PATH_NM])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_PROG_NM], [])
+dnl AC_DEFUN([AC_PROG_NM], [])
+
+# _LT_CHECK_SHAREDLIB_FROM_LINKLIB
+# --------------------------------
+# how to determine the name of the shared library
+# associated with a specific link library.
+# -- PORTME fill in with the dynamic library characteristics
+m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB],
+[m4_require([_LT_DECL_EGREP])
+m4_require([_LT_DECL_OBJDUMP])
+m4_require([_LT_DECL_DLLTOOL])
+AC_CACHE_CHECK([how to associate runtime and link libraries],
+lt_cv_sharedlib_from_linklib_cmd,
+[lt_cv_sharedlib_from_linklib_cmd='unknown'
+
+case $host_os in
+cygwin* | mingw* | pw32* | cegcc*)
+ # two different shell functions defined in ltmain.sh
+ # decide which to use based on capabilities of $DLLTOOL
+ case `$DLLTOOL --help 2>&1` in
+ *--identify-strict*)
+ lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
+ ;;
+ *)
+ lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
+ ;;
+ esac
+ ;;
+*)
+ # fallback: assume linklib IS sharedlib
+ lt_cv_sharedlib_from_linklib_cmd="$ECHO"
+ ;;
+esac
+])
+sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
+test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
+
+_LT_DECL([], [sharedlib_from_linklib_cmd], [1],
+ [Command to associate shared and link libraries])
+])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB
+
+
+# _LT_PATH_MANIFEST_TOOL
+# ----------------------
+# locate the manifest tool
+m4_defun([_LT_PATH_MANIFEST_TOOL],
+[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :)
+test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
+AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool],
+ [lt_cv_path_mainfest_tool=no
+ echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD
+ $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
+ cat conftest.err >&AS_MESSAGE_LOG_FD
+ if $GREP 'Manifest Tool' conftest.out > /dev/null; then
+ lt_cv_path_mainfest_tool=yes
+ fi
+ rm -f conftest*])
+if test "x$lt_cv_path_mainfest_tool" != xyes; then
+ MANIFEST_TOOL=:
+fi
+_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl
+])# _LT_PATH_MANIFEST_TOOL
+
+
+# LT_LIB_M
+# --------
+# check for math library
+AC_DEFUN([LT_LIB_M],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+LIBM=
+case $host in
+*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*)
+ # These system don't have libm, or don't need it
+ ;;
+*-ncr-sysv4.3*)
+ AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
+ AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
+ ;;
+*)
+ AC_CHECK_LIB(m, cos, LIBM="-lm")
+ ;;
+esac
+AC_SUBST([LIBM])
+])# LT_LIB_M
+
+# Old name:
+AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_CHECK_LIBM], [])
+
+
+# _LT_COMPILER_NO_RTTI([TAGNAME])
+# -------------------------------
+m4_defun([_LT_COMPILER_NO_RTTI],
+[m4_require([_LT_TAG_COMPILER])dnl
+
+_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+
+if test "$GCC" = yes; then
+ case $cc_basename in
+ nvcc*)
+ _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;;
+ esac
+
+ _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
+ lt_cv_prog_compiler_rtti_exceptions,
+ [-fno-rtti -fno-exceptions], [],
+ [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
+fi
+_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
+ [Compiler flag to turn off builtin functions])
+])# _LT_COMPILER_NO_RTTI
+
+
+# _LT_CMD_GLOBAL_SYMBOLS
+# ----------------------
+m4_defun([_LT_CMD_GLOBAL_SYMBOLS],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_PROG_AWK])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+AC_REQUIRE([LT_PATH_LD])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+AC_MSG_CHECKING([command to parse $NM output from $compiler object])
+AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
+[
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix. What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[[BCDEGRST]]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+ symcode='[[BCDT]]'
+ ;;
+cygwin* | mingw* | pw32* | cegcc*)
+ symcode='[[ABCDGISTW]]'
+ ;;
+hpux*)
+ if test "$host_cpu" = ia64; then
+ symcode='[[ABCDEGRST]]'
+ fi
+ ;;
+irix* | nonstopux*)
+ symcode='[[BCDEGRST]]'
+ ;;
+osf*)
+ symcode='[[BCDEGQRST]]'
+ ;;
+solaris*)
+ symcode='[[BDRT]]'
+ ;;
+sco3.2v5*)
+ symcode='[[DT]]'
+ ;;
+sysv4.2uw2*)
+ symcode='[[DT]]'
+ ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+ symcode='[[ABDT]]'
+ ;;
+sysv4)
+ symcode='[[DFNSTU]]'
+ ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+ symcode='[[ABCDGIRSTW]]' ;;
+esac
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p'"
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"lib\2\", (void *) \&\2},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+ opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+ ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+ # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+ symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+ # Write the raw and C identifiers.
+ if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+ # Fake it for dumpbin and say T for any non-static function
+ # and D for any global variable.
+ # Also find C++ and __fastcall symbols from MSVC++,
+ # which start with @ or ?.
+ lt_cv_sys_global_symbol_pipe="$AWK ['"\
+" {last_section=section; section=\$ 3};"\
+" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
+" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
+" \$ 0!~/External *\|/{next};"\
+" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
+" {if(hide[section]) next};"\
+" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
+" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
+" s[1]~/^[@?]/{print s[1], s[1]; next};"\
+" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
+" ' prfx=^$ac_symprfx]"
+ else
+ lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+ fi
+ lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+
+ # Check to see that the pipe works correctly.
+ pipe_works=no
+
+ rm -f conftest*
+ cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+ if AC_TRY_EVAL(ac_compile); then
+ # Now try to grab the symbols.
+ nlist=conftest.nm
+ if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then
+ # Try sorting and uniquifying the output.
+ if sort "$nlist" | uniq > "$nlist"T; then
+ mv -f "$nlist"T "$nlist"
+ else
+ rm -f "$nlist"T
+ fi
+
+ # Make sure that we snagged all the symbols we need.
+ if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+ if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+ cat <<_LT_EOF > conftest.$ac_ext
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
+/* DATA imports from DLLs on WIN32 con't be const, because runtime
+ relocations are performed -- see ld's documentation on pseudo-relocs. */
+# define LT@&t@_DLSYM_CONST
+#elif defined(__osf__)
+/* This system does not cope well with relocations in const data. */
+# define LT@&t@_DLSYM_CONST
+#else
+# define LT@&t@_DLSYM_CONST const
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+ # Now generate the symbol file.
+ eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+ cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols. */
+LT@&t@_DLSYM_CONST struct {
+ const char *name;
+ void *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols[[]] =
+{
+ { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+ $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+ cat <<\_LT_EOF >> conftest.$ac_ext
+ {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+ return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+ # Now try linking the two files.
+ mv conftest.$ac_objext conftstm.$ac_objext
+ lt_globsym_save_LIBS=$LIBS
+ lt_globsym_save_CFLAGS=$CFLAGS
+ LIBS="conftstm.$ac_objext"
+ CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
+ if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
+ pipe_works=yes
+ fi
+ LIBS=$lt_globsym_save_LIBS
+ CFLAGS=$lt_globsym_save_CFLAGS
+ else
+ echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
+ fi
+ else
+ echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
+ fi
+ else
+ echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
+ fi
+ else
+ echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
+ cat conftest.$ac_ext >&5
+ fi
+ rm -rf conftest* conftst*
+
+ # Do not use the global_symbol_pipe unless it works.
+ if test "$pipe_works" = yes; then
+ break
+ else
+ lt_cv_sys_global_symbol_pipe=
+ fi
+done
+])
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+ lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+ AC_MSG_RESULT(failed)
+else
+ AC_MSG_RESULT(ok)
+fi
+
+# Response file support.
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+ nm_file_list_spec='@'
+elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then
+ nm_file_list_spec='@'
+fi
+
+_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
+ [Take the output of nm and produce a listing of raw symbols and C names])
+_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
+ [Transform the output of nm in a proper C declaration])
+_LT_DECL([global_symbol_to_c_name_address],
+ [lt_cv_sys_global_symbol_to_c_name_address], [1],
+ [Transform the output of nm in a C name address pair])
+_LT_DECL([global_symbol_to_c_name_address_lib_prefix],
+ [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1],
+ [Transform the output of nm in a C name address pair when lib prefix is needed])
+_LT_DECL([], [nm_file_list_spec], [1],
+ [Specify filename containing input files for $NM])
+]) # _LT_CMD_GLOBAL_SYMBOLS
+
+
+# _LT_COMPILER_PIC([TAGNAME])
+# ---------------------------
+m4_defun([_LT_COMPILER_PIC],
+[m4_require([_LT_TAG_COMPILER])dnl
+_LT_TAGVAR(lt_prog_compiler_wl, $1)=
+_LT_TAGVAR(lt_prog_compiler_pic, $1)=
+_LT_TAGVAR(lt_prog_compiler_static, $1)=
+
+m4_if([$1], [CXX], [
+ # C++ specific cases for pic, static, wl, etc.
+ if test "$GXX" = yes; then
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+ case $host_os in
+ aix*)
+ # All AIX code is PIC.
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ ;;
+ m68k)
+ # FIXME: we need at least 68020 code to build shared libraries, but
+ # adding the `-m68020' flag to GCC prevents building anything better,
+ # like `-m68040'.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+ ;;
+ esac
+ ;;
+
+ beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+ # PIC is the default for these OSes.
+ ;;
+ mingw* | cygwin* | os2* | pw32* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ # Although the cygwin gcc ignores -fPIC, still need this for old-style
+ # (--disable-auto-import) libraries
+ m4_if([$1], [GCJ], [],
+ [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+ ;;
+ darwin* | rhapsody*)
+ # PIC is the default on this platform
+ # Common symbols not allowed in MH_DYLIB files
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+ ;;
+ *djgpp*)
+ # DJGPP does not support shared libraries at all
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+ ;;
+ haiku*)
+ # PIC is the default for Haiku.
+ # The "-static" flag exists, but is broken.
+ _LT_TAGVAR(lt_prog_compiler_static, $1)=
+ ;;
+ interix[[3-9]]*)
+ # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+ # Instead, we relocate shared libraries at runtime.
+ ;;
+ sysv4*MP*)
+ if test -d /usr/nec; then
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+ fi
+ ;;
+ hpux*)
+ # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+ # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag
+ # sets the default TLS model and affects inlining.
+ case $host_cpu in
+ hppa*64*)
+ ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ ;;
+ esac
+ ;;
+ *qnx* | *nto*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+ ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ ;;
+ esac
+ else
+ case $host_os in
+ aix[[4-9]]*)
+ # All AIX code is PIC.
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ else
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+ fi
+ ;;
+ chorus*)
+ case $cc_basename in
+ cxch68*)
+ # Green Hills C++ Compiler
+ # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+ ;;
+ esac
+ ;;
+ mingw* | cygwin* | os2* | pw32* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ m4_if([$1], [GCJ], [],
+ [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+ ;;
+ dgux*)
+ case $cc_basename in
+ ec++*)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ ;;
+ ghcx*)
+ # Green Hills C++ Compiler
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ freebsd* | dragonfly*)
+ # FreeBSD uses GNU C++
+ ;;
+ hpux9* | hpux10* | hpux11*)
+ case $cc_basename in
+ CC*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+ if test "$host_cpu" != ia64; then
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+ fi
+ ;;
+ aCC*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+ case $host_cpu in
+ hppa*64*|ia64*)
+ # +Z the default
+ ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+ ;;
+ esac
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ interix*)
+ # This is c89, which is MS Visual C++ (no shared libs)
+ # Anyone wants to do a port?
+ ;;
+ irix5* | irix6* | nonstopux*)
+ case $cc_basename in
+ CC*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+ # CC pic flag -KPIC is the default.
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ case $cc_basename in
+ KCC*)
+ # KAI C++ Compiler
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ ;;
+ ecpc* )
+ # old Intel C++ for x86_64 which still supported -KPIC.
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+ ;;
+ icpc* )
+ # Intel C++, used to be incompatible with GCC.
+ # ICC 10 doesn't accept -KPIC any more.
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+ ;;
+ pgCC* | pgcpp*)
+ # Portland Group C++ compiler
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+ cxx*)
+ # Compaq C++
+ # Make sure the PIC flag is empty. It appears that all Alpha
+ # Linux and Compaq Tru64 Unix objects are PIC.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+ ;;
+ xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*)
+ # IBM XL 8.0, 9.0 on PPC and BlueGene
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
+ ;;
+ *)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*)
+ # Sun C++ 5.9
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+ ;;
+ esac
+ ;;
+ esac
+ ;;
+ lynxos*)
+ ;;
+ m88k*)
+ ;;
+ mvs*)
+ case $cc_basename in
+ cxx*)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ netbsd* | netbsdelf*-gnu)
+ ;;
+ *qnx* | *nto*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+ ;;
+ osf3* | osf4* | osf5*)
+ case $cc_basename in
+ KCC*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+ ;;
+ RCC*)
+ # Rational C++ 2.4.1
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+ ;;
+ cxx*)
+ # Digital/Compaq C++
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ # Make sure the PIC flag is empty. It appears that all Alpha
+ # Linux and Compaq Tru64 Unix objects are PIC.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ psos*)
+ ;;
+ solaris*)
+ case $cc_basename in
+ CC* | sunCC*)
+ # Sun C++ 4.2, 5.x and Centerline C++
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+ ;;
+ gcx*)
+ # Green Hills C++ Compiler
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ sunos4*)
+ case $cc_basename in
+ CC*)
+ # Sun C++ 4.x
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+ lcc*)
+ # Lucid
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+ case $cc_basename in
+ CC*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+ esac
+ ;;
+ tandem*)
+ case $cc_basename in
+ NCC*)
+ # NonStop-UX NCC 3.20
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ ;;
+ *)
+ ;;
+ esac
+ ;;
+ vxworks*)
+ ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+ ;;
+ esac
+ fi
+],
+[
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+ case $host_os in
+ aix*)
+ # All AIX code is PIC.
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ ;;
+ m68k)
+ # FIXME: we need at least 68020 code to build shared libraries, but
+ # adding the `-m68020' flag to GCC prevents building anything better,
+ # like `-m68040'.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+ ;;
+ esac
+ ;;
+
+ beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+ # PIC is the default for these OSes.
+ ;;
+
+ mingw* | cygwin* | pw32* | os2* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ # Although the cygwin gcc ignores -fPIC, still need this for old-style
+ # (--disable-auto-import) libraries
+ m4_if([$1], [GCJ], [],
+ [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+ ;;
+
+ darwin* | rhapsody*)
+ # PIC is the default on this platform
+ # Common symbols not allowed in MH_DYLIB files
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+ ;;
+
+ haiku*)
+ # PIC is the default for Haiku.
+ # The "-static" flag exists, but is broken.
+ _LT_TAGVAR(lt_prog_compiler_static, $1)=
+ ;;
+
+ hpux*)
+ # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+ # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag
+ # sets the default TLS model and affects inlining.
+ case $host_cpu in
+ hppa*64*)
+ # +Z the default
+ ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ ;;
+ esac
+ ;;
+
+ interix[[3-9]]*)
+ # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+ # Instead, we relocate shared libraries at runtime.
+ ;;
+
+ msdosdjgpp*)
+ # Just because we use GCC doesn't mean we suddenly get shared libraries
+ # on systems that don't support them.
+ _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+ enable_shared=no
+ ;;
+
+ *nto* | *qnx*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+ ;;
+
+ sysv4*MP*)
+ if test -d /usr/nec; then
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+ fi
+ ;;
+
+ *)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ ;;
+ esac
+
+ case $cc_basename in
+ nvcc*) # Cuda Compiler Driver 2.2
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker '
+ if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)"
+ fi
+ ;;
+ esac
+ else
+ # PORTME Check for flag to pass linker flags through the system compiler.
+ case $host_os in
+ aix*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ if test "$host_cpu" = ia64; then
+ # AIX 5 now supports IA64 processor
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ else
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+ fi
+ ;;
+
+ mingw* | cygwin* | pw32* | os2* | cegcc*)
+ # This hack is so that the source file can tell whether it is being
+ # built for inclusion in a dll (and should export symbols for example).
+ m4_if([$1], [GCJ], [],
+ [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'])
+ ;;
+
+ hpux9* | hpux10* | hpux11*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+ # not for PA HP-UX.
+ case $host_cpu in
+ hppa*64*|ia64*)
+ # +Z the default
+ ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+ ;;
+ esac
+ # Is there a better lt_prog_compiler_static that works with the bundled CC?
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+ ;;
+
+ irix5* | irix6* | nonstopux*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ # PIC (with -KPIC) is the default.
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+ ;;
+
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ case $cc_basename in
+ # old Intel for x86_64 which still supported -KPIC.
+ ecc*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+ ;;
+ # icc used to be incompatible with GCC.
+ # ICC 10 doesn't accept -KPIC any more.
+ icc* | ifort*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+ ;;
+ # Lahey Fortran 8.1.
+ lf95*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='--static'
+ ;;
+ nagfor*)
+ # NAG Fortran compiler
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+ pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+ # Portland Group compilers (*not* the Pentium gcc compiler,
+ # which looks to be a dead project)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+ ccc*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ # All Alpha code is PIC.
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+ ;;
+ xl* | bgxl* | bgf* | mpixl*)
+ # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink'
+ ;;
+ *)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*)
+ # Sun Fortran 8.3 passes all unrecognized flags to the linker
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)=''
+ ;;
+ *Sun\ F* | *Sun*Fortran*)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+ ;;
+ *Sun\ C*)
+ # Sun C 5.9
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ ;;
+ *Intel*\ [[CF]]*Compiler*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+ ;;
+ *Portland\ Group*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+ esac
+ ;;
+ esac
+ ;;
+
+ newsos6)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+
+ *nto* | *qnx*)
+ # QNX uses GNU C++, but need to define -shared option too, otherwise
+ # it will coredump.
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared'
+ ;;
+
+ osf3* | osf4* | osf5*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ # All OSF/1 code is PIC.
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+ ;;
+
+ rdos*)
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+ ;;
+
+ solaris*)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ case $cc_basename in
+ f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
+ esac
+ ;;
+
+ sunos4*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+
+ sysv4 | sysv4.2uw2* | sysv4.3*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+
+ sysv4*MP*)
+ if test -d /usr/nec ;then
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ fi
+ ;;
+
+ sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+
+ unicos*)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+ ;;
+
+ uts4*)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+ ;;
+
+ *)
+ _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+ ;;
+ esac
+ fi
+])
+case $host_os in
+ # For platforms which do not support PIC, -DPIC is meaningless:
+ *djgpp*)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)=
+ ;;
+ *)
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
+ ;;
+esac
+
+AC_CACHE_CHECK([for $compiler option to produce PIC],
+ [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)],
+ [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)])
+_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then
+ _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works],
+ [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)],
+ [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
+ [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in
+ "" | " "*) ;;
+ *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;;
+ esac],
+ [_LT_TAGVAR(lt_prog_compiler_pic, $1)=
+ _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
+fi
+_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
+ [Additional compiler flags for building library objects])
+
+_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
+ [How to pass a linker flag through the compiler])
+#
+# Check to make sure the static flag actually works.
+#
+wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\"
+_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
+ _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1),
+ $lt_tmp_static_flag,
+ [],
+ [_LT_TAGVAR(lt_prog_compiler_static, $1)=])
+_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
+ [Compiler flag to prevent dynamic linking])
+])# _LT_COMPILER_PIC
+
+
+# _LT_LINKER_SHLIBS([TAGNAME])
+# ----------------------------
+# See if the linker supports building shared libraries.
+m4_defun([_LT_LINKER_SHLIBS],
+[AC_REQUIRE([LT_PATH_LD])dnl
+AC_REQUIRE([LT_PATH_NM])dnl
+m4_require([_LT_PATH_MANIFEST_TOOL])dnl
+m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_DECL_SED])dnl
+m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
+m4_require([_LT_TAG_COMPILER])dnl
+AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+m4_if([$1], [CXX], [
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+ _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
+ case $host_os in
+ aix[[4-9]]*)
+ # If we're using GNU nm, then we don't want the "-C" option.
+ # -C means demangle to AIX nm, but means don't demangle with GNU nm
+ # Also, AIX nm treats weak defined symbols like other global defined
+ # symbols, whereas GNU nm marks them as "W".
+ if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ else
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ fi
+ ;;
+ pw32*)
+ _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
+ ;;
+ cygwin* | mingw* | cegcc*)
+ case $cc_basename in
+ cl*)
+ _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+ ;;
+ *)
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
+ _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
+ ;;
+ esac
+ ;;
+ linux* | k*bsd*-gnu | gnu*)
+ _LT_TAGVAR(link_all_deplibs, $1)=no
+ ;;
+ *)
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+ ;;
+ esac
+], [
+ runpath_var=
+ _LT_TAGVAR(allow_undefined_flag, $1)=
+ _LT_TAGVAR(always_export_symbols, $1)=no
+ _LT_TAGVAR(archive_cmds, $1)=
+ _LT_TAGVAR(archive_expsym_cmds, $1)=
+ _LT_TAGVAR(compiler_needs_object, $1)=no
+ _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)=
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+ _LT_TAGVAR(hardcode_automatic, $1)=no
+ _LT_TAGVAR(hardcode_direct, $1)=no
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=no
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=
+ _LT_TAGVAR(hardcode_minus_L, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+ _LT_TAGVAR(inherit_rpath, $1)=no
+ _LT_TAGVAR(link_all_deplibs, $1)=unknown
+ _LT_TAGVAR(module_cmds, $1)=
+ _LT_TAGVAR(module_expsym_cmds, $1)=
+ _LT_TAGVAR(old_archive_from_new_cmds, $1)=
+ _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)=
+ _LT_TAGVAR(thread_safe_flag_spec, $1)=
+ _LT_TAGVAR(whole_archive_flag_spec, $1)=
+ # include_expsyms should be a list of space-separated symbols to be *always*
+ # included in the symbol list
+ _LT_TAGVAR(include_expsyms, $1)=
+ # exclude_expsyms can be an extended regexp of symbols to exclude
+ # it will be wrapped by ` (' and `)$', so one must not match beginning or
+ # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+ # as well as any symbol that contains `d'.
+ _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*']
+ # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+ # platforms (ab)use it in PIC code, but their linkers get confused if
+ # the symbol is explicitly referenced. Since portable code cannot
+ # rely on this symbol name, it's probably fine to never include it in
+ # preloaded symbol tables.
+ # Exclude shared library initialization/finalization symbols.
+dnl Note also adjust exclude_expsyms for C++ above.
+ extract_expsyms_cmds=
+
+ case $host_os in
+ cygwin* | mingw* | pw32* | cegcc*)
+ # FIXME: the MSVC++ port hasn't been tested in a loooong time
+ # When not using gcc, we currently assume that we are using
+ # Microsoft Visual C++.
+ if test "$GCC" != yes; then
+ with_gnu_ld=no
+ fi
+ ;;
+ interix*)
+ # we just hope/assume this is gcc and not c89 (= MSVC++)
+ with_gnu_ld=yes
+ ;;
+ openbsd*)
+ with_gnu_ld=no
+ ;;
+ linux* | k*bsd*-gnu | gnu*)
+ _LT_TAGVAR(link_all_deplibs, $1)=no
+ ;;
+ esac
+
+ _LT_TAGVAR(ld_shlibs, $1)=yes
+
+ # On some targets, GNU ld is compatible enough with the native linker
+ # that we're better off using the native interface for both.
+ lt_use_gnu_ld_interface=no
+ if test "$with_gnu_ld" = yes; then
+ case $host_os in
+ aix*)
+ # The AIX port of GNU ld has always aspired to compatibility
+ # with the native linker. However, as the warning in the GNU ld
+ # block says, versions before 2.19.5* couldn't really create working
+ # shared libraries, regardless of the interface used.
+ case `$LD -v 2>&1` in
+ *\ \(GNU\ Binutils\)\ 2.19.5*) ;;
+ *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;;
+ *\ \(GNU\ Binutils\)\ [[3-9]]*) ;;
+ *)
+ lt_use_gnu_ld_interface=yes
+ ;;
+ esac
+ ;;
+ *)
+ lt_use_gnu_ld_interface=yes
+ ;;
+ esac
+ fi
+
+ if test "$lt_use_gnu_ld_interface" = yes; then
+ # If archive_cmds runs LD, not CC, wlarc should be empty
+ wlarc='${wl}'
+
+ # Set some defaults for GNU ld with shared library support. These
+ # are reset later if shared libraries are not supported. Putting them
+ # here allows them to be overridden if necessary.
+ runpath_var=LD_RUN_PATH
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+ # ancient GNU ld didn't support --whole-archive et. al.
+ if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+ _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+ else
+ _LT_TAGVAR(whole_archive_flag_spec, $1)=
+ fi
+ supports_anon_versioning=no
+ case `$LD -v 2>&1` in
+ *GNU\ gold*) supports_anon_versioning=yes ;;
+ *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
+ *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+ *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+ *\ 2.11.*) ;; # other 2.11 versions
+ *) supports_anon_versioning=yes ;;
+ esac
+
+ # See if GNU ld supports shared libraries.
+ case $host_os in
+ aix[[3-9]]*)
+ # On AIX/PPC, the GNU linker is very broken
+ if test "$host_cpu" != ia64; then
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.19, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support. If you
+*** really care for shared libraries, you may want to install binutils
+*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
+*** You will then need to restart the configuration process.
+
+_LT_EOF
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)=''
+ ;;
+ m68k)
+ _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ ;;
+ esac
+ ;;
+
+ beos*)
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+ # support --undefined. This deserves some investigation. FIXME
+ _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+
+ cygwin* | mingw* | pw32* | cegcc*)
+ # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+ # as there is no search path for DLLs.
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ _LT_TAGVAR(always_export_symbols, $1)=no
+ _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols'
+ _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname']
+
+ if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ # If the export-symbols file already is a .def file (1st line
+ # is EXPORTS), use it as is; otherwise, prepend...
+ _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ cp $export_symbols $output_objdir/$soname.def;
+ else
+ echo EXPORTS > $output_objdir/$soname.def;
+ cat $export_symbols >> $output_objdir/$soname.def;
+ fi~
+ $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+
+ haiku*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ ;;
+
+ interix[[3-9]]*)
+ _LT_TAGVAR(hardcode_direct, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+ # Instead, shared libraries are loaded at an image base (0x10000000 by
+ # default) and relocated if they conflict, which is a slow very memory
+ # consuming and fragmenting process. To avoid this, we pick a random,
+ # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+ # time. Moving up from 0x10000000 also allows more sbrk(2) space.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ ;;
+
+ gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+ tmp_diet=no
+ if test "$host_os" = linux-dietlibc; then
+ case $cc_basename in
+ diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn)
+ esac
+ fi
+ if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+ && test "$tmp_diet" = no
+ then
+ tmp_addflag=' $pic_flag'
+ tmp_sharedflag='-shared'
+ case $cc_basename,$host_cpu in
+ pgcc*) # Portland Group C compiler
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ tmp_addflag=' $pic_flag'
+ ;;
+ pgf77* | pgf90* | pgf95* | pgfortran*)
+ # Portland Group f77 and f90 compilers
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ tmp_addflag=' $pic_flag -Mnomain' ;;
+ ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64
+ tmp_addflag=' -i_dynamic' ;;
+ efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64
+ tmp_addflag=' -i_dynamic -nofor_main' ;;
+ ifc* | ifort*) # Intel Fortran compiler
+ tmp_addflag=' -nofor_main' ;;
+ lf95*) # Lahey Fortran 8.1
+ _LT_TAGVAR(whole_archive_flag_spec, $1)=
+ tmp_sharedflag='--shared' ;;
+ xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below)
+ tmp_sharedflag='-qmkshrobj'
+ tmp_addflag= ;;
+ nvcc*) # Cuda Compiler Driver 2.2
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ _LT_TAGVAR(compiler_needs_object, $1)=yes
+ ;;
+ esac
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*) # Sun C 5.9
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ _LT_TAGVAR(compiler_needs_object, $1)=yes
+ tmp_sharedflag='-G' ;;
+ *Sun\ F*) # Sun Fortran 8.3
+ tmp_sharedflag='-G' ;;
+ esac
+ _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+
+ if test "x$supports_anon_versioning" = xyes; then
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+ echo "local: *; };" >> $output_objdir/$libname.ver~
+ $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+ fi
+
+ case $cc_basename in
+ xlf* | bgf* | bgxlf* | mpixlf*)
+ # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
+ if test "x$supports_anon_versioning" = xyes; then
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+ echo "local: *; };" >> $output_objdir/$libname.ver~
+ $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+ fi
+ ;;
+ esac
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+
+ netbsd* | netbsdelf*-gnu)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+ wlarc=
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ fi
+ ;;
+
+ solaris*)
+ if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems. Therefore, libtool
+*** is disabling shared libraries support. We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer. Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+ elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+
+ sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+ case `$LD -v 2>&1` in
+ *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*)
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
+*** reliably create shared libraries on SCO systems. Therefore, libtool
+*** is disabling shared libraries support. We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer. Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+ ;;
+ *)
+ # For security reasons, it is highly recommended that you always
+ # use absolute paths for naming shared libraries, and exclude the
+ # DT_RUNPATH tag from executables and libraries. But doing so
+ # requires that you compile everything twice, which is a pain.
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+ esac
+ ;;
+
+ sunos4*)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+ wlarc=
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ *)
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+ esac
+
+ if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then
+ runpath_var=
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)=
+ _LT_TAGVAR(whole_archive_flag_spec, $1)=
+ fi
+ else
+ # PORTME fill in a description of your system's linker (not GNU ld)
+ case $host_os in
+ aix3*)
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ _LT_TAGVAR(always_export_symbols, $1)=yes
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+ # Note: this linker hardcodes the directories in LIBPATH if there
+ # are no directories specified by -L.
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
+ # Neither direct hardcoding nor static linking is supported with a
+ # broken collect2.
+ _LT_TAGVAR(hardcode_direct, $1)=unsupported
+ fi
+ ;;
+
+ aix[[4-9]]*)
+ if test "$host_cpu" = ia64; then
+ # On IA64, the linker does run time linking by default, so we don't
+ # have to do anything special.
+ aix_use_runtimelinking=no
+ exp_sym_flag='-Bexport'
+ no_entry_flag=""
+ else
+ # If we're using GNU nm, then we don't want the "-C" option.
+ # -C means demangle to AIX nm, but means don't demangle with GNU nm
+ # Also, AIX nm treats weak defined symbols like other global
+ # defined symbols, whereas GNU nm marks them as "W".
+ if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ else
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ fi
+ aix_use_runtimelinking=no
+
+ # Test if we are trying to use run time linking or normal
+ # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+ # need to do runtime linking.
+ case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
+ for ld_flag in $LDFLAGS; do
+ if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+ aix_use_runtimelinking=yes
+ break
+ fi
+ done
+ ;;
+ esac
+
+ exp_sym_flag='-bexport'
+ no_entry_flag='-bnoentry'
+ fi
+
+ # When large executables or shared objects are built, AIX ld can
+ # have problems creating the table of contents. If linking a library
+ # or program results in "error TOC overflow" add -mminimal-toc to
+ # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not
+ # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+ _LT_TAGVAR(archive_cmds, $1)=''
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
+
+ if test "$GCC" = yes; then
+ case $host_os in aix4.[[012]]|aix4.[[012]].*)
+ # We only want to do this on AIX 4.2 and lower, the check
+ # below for broken collect2 doesn't work under 4.3+
+ collect2name=`${CC} -print-prog-name=collect2`
+ if test -f "$collect2name" &&
+ strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+ then
+ # We have reworked collect2
+ :
+ else
+ # We have old collect2
+ _LT_TAGVAR(hardcode_direct, $1)=unsupported
+ # It fails to find uninstalled libraries when the uninstalled
+ # path is not listed in the libpath. Setting hardcode_minus_L
+ # to unsupported forces relinking
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=
+ fi
+ ;;
+ esac
+ shared_flag='-shared'
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag="$shared_flag "'${wl}-G'
+ fi
+ _LT_TAGVAR(link_all_deplibs, $1)=no
+ else
+ # not using gcc
+ if test "$host_cpu" = ia64; then
+ # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+ # chokes on -Wl,-G. The following line is correct:
+ shared_flag='-G'
+ else
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag='${wl}-G'
+ else
+ shared_flag='${wl}-bM:SRE'
+ fi
+ fi
+ fi
+
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
+ # It seems that -bexpall does not export symbols beginning with
+ # underscore (_), so it is better to generate a list of symbols to export.
+ _LT_TAGVAR(always_export_symbols, $1)=yes
+ if test "$aix_use_runtimelinking" = yes; then
+ # Warning - without using the other runtime loading flags (-brtl),
+ # -berok will link without error, but may produce a broken library.
+ _LT_TAGVAR(allow_undefined_flag, $1)='-berok'
+ # Determine the default libpath from the value encoded in an
+ # empty executable.
+ _LT_SYS_MODULE_PATH_AIX([$1])
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+ else
+ if test "$host_cpu" = ia64; then
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+ _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+ _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+ else
+ # Determine the default libpath from the value encoded in an
+ # empty executable.
+ _LT_SYS_MODULE_PATH_AIX([$1])
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+ # Warning - without using the other run time loading flags,
+ # -berok will link without error, but may produce a broken library.
+ _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+ _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+ if test "$with_gnu_ld" = yes; then
+ # We only use this code for GNU lds that support --whole-archive.
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+ else
+ # Exported symbols can be pulled into shared objects from archives
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+ fi
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+ # This is similar to how AIX traditionally builds its shared libraries.
+ _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+ fi
+ fi
+ ;;
+
+ amigaos*)
+ case $host_cpu in
+ powerpc)
+ # see comment about AmigaOS4 .so support
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)=''
+ ;;
+ m68k)
+ _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ ;;
+ esac
+ ;;
+
+ bsdi[[45]]*)
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
+ ;;
+
+ cygwin* | mingw* | pw32* | cegcc*)
+ # When not using gcc, we currently assume that we are using
+ # Microsoft Visual C++.
+ # hardcode_libdir_flag_spec is actually meaningless, as there is
+ # no search path for DLLs.
+ case $cc_basename in
+ cl*)
+ # Native MSVC
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ _LT_TAGVAR(always_export_symbols, $1)=yes
+ _LT_TAGVAR(file_list_spec, $1)='@'
+ # Tell ltmain to make .lib files, not .a files.
+ libext=lib
+ # Tell ltmain to make .dll files, not .so files.
+ shrext_cmds=".dll"
+ # FIXME: Setting linknames here is a bad hack.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
+ _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
+ else
+ sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
+ fi~
+ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+ linknames='
+ # The linker will not automatically build a static lib if we build a DLL.
+ # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
+ _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+ _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols'
+ # Don't use ranlib
+ _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
+ _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
+ lt_tool_outputfile="@TOOL_OUTPUT@"~
+ case $lt_outputfile in
+ *.exe|*.EXE) ;;
+ *)
+ lt_outputfile="$lt_outputfile.exe"
+ lt_tool_outputfile="$lt_tool_outputfile.exe"
+ ;;
+ esac~
+ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
+ $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+ $RM "$lt_outputfile.manifest";
+ fi'
+ ;;
+ *)
+ # Assume MSVC wrapper
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ # Tell ltmain to make .lib files, not .a files.
+ libext=lib
+ # Tell ltmain to make .dll files, not .so files.
+ shrext_cmds=".dll"
+ # FIXME: Setting linknames here is a bad hack.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+ # The linker will automatically build a .lib file if we build a DLL.
+ _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
+ # FIXME: Should let the user specify the lib program.
+ _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs'
+ _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+ ;;
+ esac
+ ;;
+
+ darwin* | rhapsody*)
+ _LT_DARWIN_LINKER_FEATURES($1)
+ ;;
+
+ dgux*)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+ # support. Future versions do this automatically, but an explicit c++rt0.o
+ # does not break anything, and helps significantly (at the cost of a little
+ # extra space).
+ freebsd2.2*)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+ freebsd2.*)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+ freebsd* | dragonfly*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ hpux9*)
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ fi
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+
+ # hardcode_minus_L: Not really in the search PATH,
+ # but as the default location of the library.
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ ;;
+
+ hpux10*)
+ if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+ fi
+ if test "$with_gnu_ld" = no; then
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ # hardcode_minus_L: Not really in the search PATH,
+ # but as the default location of the library.
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ fi
+ ;;
+
+ hpux11*)
+ if test "$GCC" = yes && test "$with_gnu_ld" = no; then
+ case $host_cpu in
+ hppa*64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ ia64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ *)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ esac
+ else
+ case $host_cpu in
+ hppa*64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ ia64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ *)
+ m4_if($1, [], [
+ # Older versions of the 11.00 compiler do not understand -b yet
+ # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
+ _LT_LINKER_OPTION([if $CC understands -b],
+ _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b],
+ [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'],
+ [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])],
+ [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'])
+ ;;
+ esac
+ fi
+ if test "$with_gnu_ld" = no; then
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+ case $host_cpu in
+ hppa*64*|ia64*)
+ _LT_TAGVAR(hardcode_direct, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+ *)
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+
+ # hardcode_minus_L: Not really in the search PATH,
+ # but as the default location of the library.
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ ;;
+ esac
+ fi
+ ;;
+
+ irix5* | irix6* | nonstopux*)
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ # Try to use the -exported_symbol ld option, if it does not
+ # work, assume that -exports_file does not work either and
+ # implicitly export all symbols.
+ # This should be the same for all languages, so no per-tag cache variable.
+ AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol],
+ [lt_cv_irix_exported_symbol],
+ [save_LDFLAGS="$LDFLAGS"
+ LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
+ AC_LINK_IFELSE(
+ [AC_LANG_SOURCE(
+ [AC_LANG_CASE([C], [[int foo (void) { return 0; }]],
+ [C++], [[int foo (void) { return 0; }]],
+ [Fortran 77], [[
+ subroutine foo
+ end]],
+ [Fortran], [[
+ subroutine foo
+ end]])])],
+ [lt_cv_irix_exported_symbol=yes],
+ [lt_cv_irix_exported_symbol=no])
+ LDFLAGS="$save_LDFLAGS"])
+ if test "$lt_cv_irix_exported_symbol" = yes; then
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
+ fi
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
+ fi
+ _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ _LT_TAGVAR(inherit_rpath, $1)=yes
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ ;;
+
+ netbsd* | netbsdelf*-gnu)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF
+ fi
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ newsos6)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ *nto* | *qnx*)
+ ;;
+
+ openbsd*)
+ if test -f /usr/libexec/ld.so; then
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+ if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ else
+ case $host_os in
+ openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ ;;
+ *)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ ;;
+ esac
+ fi
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+
+ os2*)
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+ _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+ ;;
+
+ osf3*)
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ else
+ _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ fi
+ _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ ;;
+
+ osf4* | osf5*) # as osf3* with the addition of -msym flag
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ else
+ _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+ $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
+
+ # Both c and cxx compiler support -rpath directly
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+ fi
+ _LT_TAGVAR(archive_cmds_need_lc, $1)='no'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ ;;
+
+ solaris*)
+ _LT_TAGVAR(no_undefined_flag, $1)=' -z defs'
+ if test "$GCC" = yes; then
+ wlarc='${wl}'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ else
+ case `$CC -V 2>&1` in
+ *"Compilers 5.0"*)
+ wlarc=''
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+ ;;
+ *)
+ wlarc='${wl}'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ ;;
+ esac
+ fi
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ case $host_os in
+ solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+ *)
+ # The compiler driver will combine and reorder linker options,
+ # but understands `-z linker_flag'. GCC discards it without `$wl',
+ # but is careful enough not to reorder.
+ # Supported since Solaris 2.6 (maybe 2.5.1?)
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+ else
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
+ fi
+ ;;
+ esac
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ ;;
+
+ sunos4*)
+ if test "x$host_vendor" = xsequent; then
+ # Use $CC to link under sequent, because it throws in some extra .o
+ # files that make .init and .fini sections work.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+ fi
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ sysv4)
+ case $host_vendor in
+ sni)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true???
+ ;;
+ siemens)
+ ## LD is ld it makes a PLAMLIB
+ ## CC just makes a GrossModule.
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
+ _LT_TAGVAR(hardcode_direct, $1)=no
+ ;;
+ motorola)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
+ ;;
+ esac
+ runpath_var='LD_RUN_PATH'
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ sysv4.3*)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
+ ;;
+
+ sysv4*MP*)
+ if test -d /usr/nec; then
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ runpath_var=LD_RUN_PATH
+ hardcode_runpath_var=yes
+ _LT_TAGVAR(ld_shlibs, $1)=yes
+ fi
+ ;;
+
+ sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
+ _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ runpath_var='LD_RUN_PATH'
+
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ fi
+ ;;
+
+ sysv5* | sco3.2v5* | sco5v6*)
+ # Note: We can NOT use -z defs as we might desire, because we do not
+ # link with -lc, and that would cause any symbols used from libc to
+ # always be unresolved, which means just about no library would
+ # ever link correctly. If we're not using GNU ld we use -z text
+ # though, which does catch some bad symbols but isn't as heavy-handed
+ # as -z defs.
+ _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+ _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+ runpath_var='LD_RUN_PATH'
+
+ if test "$GCC" = yes; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ fi
+ ;;
+
+ uts4*)
+ _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+
+ *)
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ esac
+
+ if test x$host_vendor = xsni; then
+ case $host in
+ sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym'
+ ;;
+ esac
+ fi
+ fi
+])
+AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
+test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld
+
+_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
+_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
+_LT_DECL([], [extract_expsyms_cmds], [2],
+ [The commands to extract the exported symbol list from a shared archive])
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in
+x|xyes)
+ # Assume -lc should be added
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+
+ if test "$enable_shared" = yes && test "$GCC" = yes; then
+ case $_LT_TAGVAR(archive_cmds, $1) in
+ *'~'*)
+ # FIXME: we may have to deal with multi-command sequences.
+ ;;
+ '$CC '*)
+ # Test whether the compiler implicitly links with -lc since on some
+ # systems, -lgcc has to come before -lc. If gcc already passes -lc
+ # to ld, don't add -lc before -lgcc.
+ AC_CACHE_CHECK([whether -lc should be explicitly linked in],
+ [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1),
+ [$RM conftest*
+ echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+ if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
+ soname=conftest
+ lib=conftest
+ libobjs=conftest.$ac_objext
+ deplibs=
+ wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1)
+ pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1)
+ compiler_flags=-v
+ linker_flags=-v
+ verstring=
+ output_objdir=.
+ libname=conftest
+ lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1)
+ _LT_TAGVAR(allow_undefined_flag, $1)=
+ if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
+ then
+ lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ else
+ lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+ fi
+ _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
+ else
+ cat conftest.err 1>&5
+ fi
+ $RM conftest*
+ ])
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)
+ ;;
+ esac
+ fi
+ ;;
+esac
+
+_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
+ [Whether or not to add -lc for building shared libraries])
+_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
+ [enable_shared_with_static_runtimes], [0],
+ [Whether or not to disallow shared libs when runtime libs are static])
+_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
+ [Compiler flag to allow reflexive dlopens])
+_LT_TAGDECL([], [whole_archive_flag_spec], [1],
+ [Compiler flag to generate shared objects directly from archives])
+_LT_TAGDECL([], [compiler_needs_object], [1],
+ [Whether the compiler copes with passing no objects directly])
+_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
+ [Create an old-style archive from a shared archive])
+_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
+ [Create a temporary old-style archive to link instead of a shared archive])
+_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
+_LT_TAGDECL([], [archive_expsym_cmds], [2])
+_LT_TAGDECL([], [module_cmds], [2],
+ [Commands used to build a loadable module if different from building
+ a shared archive.])
+_LT_TAGDECL([], [module_expsym_cmds], [2])
+_LT_TAGDECL([], [with_gnu_ld], [1],
+ [Whether we are building with GNU ld or not])
+_LT_TAGDECL([], [allow_undefined_flag], [1],
+ [Flag that allows shared libraries with undefined symbols to be built])
+_LT_TAGDECL([], [no_undefined_flag], [1],
+ [Flag that enforces no undefined symbols])
+_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
+ [Flag to hardcode $libdir into a binary during linking.
+ This must work even if $libdir does not exist])
+_LT_TAGDECL([], [hardcode_libdir_separator], [1],
+ [Whether we need a single "-rpath" flag with a separated argument])
+_LT_TAGDECL([], [hardcode_direct], [0],
+ [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
+ DIR into the resulting binary])
+_LT_TAGDECL([], [hardcode_direct_absolute], [0],
+ [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
+ DIR into the resulting binary and the resulting library dependency is
+ "absolute", i.e impossible to change by setting ${shlibpath_var} if the
+ library is relocated])
+_LT_TAGDECL([], [hardcode_minus_L], [0],
+ [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+ into the resulting binary])
+_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
+ [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+ into the resulting binary])
+_LT_TAGDECL([], [hardcode_automatic], [0],
+ [Set to "yes" if building a shared library automatically hardcodes DIR
+ into the library and all subsequent libraries and executables linked
+ against it])
+_LT_TAGDECL([], [inherit_rpath], [0],
+ [Set to yes if linker adds runtime paths of dependent libraries
+ to runtime path list])
+_LT_TAGDECL([], [link_all_deplibs], [0],
+ [Whether libtool must link a program against all its dependency libraries])
+_LT_TAGDECL([], [always_export_symbols], [0],
+ [Set to "yes" if exported symbols are required])
+_LT_TAGDECL([], [export_symbols_cmds], [2],
+ [The commands to list exported symbols])
+_LT_TAGDECL([], [exclude_expsyms], [1],
+ [Symbols that should not be listed in the preloaded symbols])
+_LT_TAGDECL([], [include_expsyms], [1],
+ [Symbols that must always be exported])
+_LT_TAGDECL([], [prelink_cmds], [2],
+ [Commands necessary for linking programs (against libraries) with templates])
+_LT_TAGDECL([], [postlink_cmds], [2],
+ [Commands necessary for finishing linking programs])
+_LT_TAGDECL([], [file_list_spec], [1],
+ [Specify filename containing input files])
+dnl FIXME: Not yet implemented
+dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
+dnl [Compiler flag to generate thread safe objects])
+])# _LT_LINKER_SHLIBS
+
+
+# _LT_LANG_C_CONFIG([TAG])
+# ------------------------
+# Ensure that the configuration variables for a C compiler are suitably
+# defined. These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_C_CONFIG],
+[m4_require([_LT_DECL_EGREP])dnl
+lt_save_CC="$CC"
+AC_LANG_PUSH(C)
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+_LT_TAG_COMPILER
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+ _LT_COMPILER_NO_RTTI($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_SYS_DYNAMIC_LINKER($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+ LT_SYS_DLOPEN_SELF
+ _LT_CMD_STRIPLIB
+
+ # Report which library types will actually be built
+ AC_MSG_CHECKING([if libtool supports shared libraries])
+ AC_MSG_RESULT([$can_build_shared])
+
+ AC_MSG_CHECKING([whether to build shared libraries])
+ test "$can_build_shared" = "no" && enable_shared=no
+
+ # On AIX, shared libraries and static libraries use the same namespace, and
+ # are all built from PIC.
+ case $host_os in
+ aix3*)
+ test "$enable_shared" = yes && enable_static=no
+ if test -n "$RANLIB"; then
+ archive_cmds="$archive_cmds~\$RANLIB \$lib"
+ postinstall_cmds='$RANLIB $lib'
+ fi
+ ;;
+
+ aix[[4-9]]*)
+ if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+ test "$enable_shared" = yes && enable_static=no
+ fi
+ ;;
+ esac
+ AC_MSG_RESULT([$enable_shared])
+
+ AC_MSG_CHECKING([whether to build static libraries])
+ # Make sure either enable_shared or enable_static is yes.
+ test "$enable_shared" = yes || enable_static=yes
+ AC_MSG_RESULT([$enable_static])
+
+ _LT_CONFIG($1)
+fi
+AC_LANG_POP
+CC="$lt_save_CC"
+])# _LT_LANG_C_CONFIG
+
+
+# _LT_LANG_CXX_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a C++ compiler are suitably
+# defined. These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_CXX_CONFIG],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+m4_require([_LT_DECL_EGREP])dnl
+m4_require([_LT_PATH_MANIFEST_TOOL])dnl
+if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
+ ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
+ (test "X$CXX" != "Xg++"))) ; then
+ AC_PROG_CXXCPP
+else
+ _lt_caught_CXX_error=yes
+fi
+
+AC_LANG_PUSH(C++)
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(compiler_needs_object, $1)=no
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the CXX compiler isn't working. Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test "$_lt_caught_CXX_error" != yes; then
+ # Code to be used in simple compile tests
+ lt_simple_compile_test_code="int some_variable = 0;"
+
+ # Code to be used in simple link tests
+ lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }'
+
+ # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+ _LT_TAG_COMPILER
+
+ # save warnings/boilerplate of simple test code
+ _LT_COMPILER_BOILERPLATE
+ _LT_LINKER_BOILERPLATE
+
+ # Allow CC to be a program name with arguments.
+ lt_save_CC=$CC
+ lt_save_CFLAGS=$CFLAGS
+ lt_save_LD=$LD
+ lt_save_GCC=$GCC
+ GCC=$GXX
+ lt_save_with_gnu_ld=$with_gnu_ld
+ lt_save_path_LD=$lt_cv_path_LD
+ if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+ lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+ else
+ $as_unset lt_cv_prog_gnu_ld
+ fi
+ if test -n "${lt_cv_path_LDCXX+set}"; then
+ lt_cv_path_LD=$lt_cv_path_LDCXX
+ else
+ $as_unset lt_cv_path_LD
+ fi
+ test -z "${LDCXX+set}" || LD=$LDCXX
+ CC=${CXX-"c++"}
+ CFLAGS=$CXXFLAGS
+ compiler=$CC
+ _LT_TAGVAR(compiler, $1)=$CC
+ _LT_CC_BASENAME([$compiler])
+
+ if test -n "$compiler"; then
+ # We don't want -fno-exception when compiling C++ code, so set the
+ # no_builtin_flag separately
+ if test "$GXX" = yes; then
+ _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+ else
+ _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+ fi
+
+ if test "$GXX" = yes; then
+ # Set up default GNU C++ configuration
+
+ LT_PATH_LD
+
+ # Check if GNU C++ uses GNU ld as the underlying linker, since the
+ # archiving commands below assume that GNU ld is being used.
+ if test "$with_gnu_ld" = yes; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+ # If archive_cmds runs LD, not CC, wlarc should be empty
+ # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+ # investigate it a little bit more. (MM)
+ wlarc='${wl}'
+
+ # ancient GNU ld didn't support --whole-archive et. al.
+ if eval "`$CC -print-prog-name=ld` --help 2>&1" |
+ $GREP 'no-whole-archive' > /dev/null; then
+ _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+ else
+ _LT_TAGVAR(whole_archive_flag_spec, $1)=
+ fi
+ else
+ with_gnu_ld=no
+ wlarc=
+
+ # A generic and very simple default shared library creation
+ # command for GNU C++ for the case where it uses the native
+ # linker, instead of GNU ld. If possible, this setting should
+ # overridden to take advantage of the native linker features on
+ # the platform it is being used on.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+ fi
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+
+ else
+ GXX=no
+ with_gnu_ld=no
+ wlarc=
+ fi
+
+ # PORTME: fill in a description of your system's C++ link characteristics
+ AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+ _LT_TAGVAR(ld_shlibs, $1)=yes
+ case $host_os in
+ aix3*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ aix[[4-9]]*)
+ if test "$host_cpu" = ia64; then
+ # On IA64, the linker does run time linking by default, so we don't
+ # have to do anything special.
+ aix_use_runtimelinking=no
+ exp_sym_flag='-Bexport'
+ no_entry_flag=""
+ else
+ aix_use_runtimelinking=no
+
+ # Test if we are trying to use run time linking or normal
+ # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+ # need to do runtime linking.
+ case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*)
+ for ld_flag in $LDFLAGS; do
+ case $ld_flag in
+ *-brtl*)
+ aix_use_runtimelinking=yes
+ break
+ ;;
+ esac
+ done
+ ;;
+ esac
+
+ exp_sym_flag='-bexport'
+ no_entry_flag='-bnoentry'
+ fi
+
+ # When large executables or shared objects are built, AIX ld can
+ # have problems creating the table of contents. If linking a library
+ # or program results in "error TOC overflow" add -mminimal-toc to
+ # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not
+ # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+ _LT_TAGVAR(archive_cmds, $1)=''
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ _LT_TAGVAR(file_list_spec, $1)='${wl}-f,'
+
+ if test "$GXX" = yes; then
+ case $host_os in aix4.[[012]]|aix4.[[012]].*)
+ # We only want to do this on AIX 4.2 and lower, the check
+ # below for broken collect2 doesn't work under 4.3+
+ collect2name=`${CC} -print-prog-name=collect2`
+ if test -f "$collect2name" &&
+ strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+ then
+ # We have reworked collect2
+ :
+ else
+ # We have old collect2
+ _LT_TAGVAR(hardcode_direct, $1)=unsupported
+ # It fails to find uninstalled libraries when the uninstalled
+ # path is not listed in the libpath. Setting hardcode_minus_L
+ # to unsupported forces relinking
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=
+ fi
+ esac
+ shared_flag='-shared'
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag="$shared_flag "'${wl}-G'
+ fi
+ else
+ # not using gcc
+ if test "$host_cpu" = ia64; then
+ # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+ # chokes on -Wl,-G. The following line is correct:
+ shared_flag='-G'
+ else
+ if test "$aix_use_runtimelinking" = yes; then
+ shared_flag='${wl}-G'
+ else
+ shared_flag='${wl}-bM:SRE'
+ fi
+ fi
+ fi
+
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall'
+ # It seems that -bexpall does not export symbols beginning with
+ # underscore (_), so it is better to generate a list of symbols to
+ # export.
+ _LT_TAGVAR(always_export_symbols, $1)=yes
+ if test "$aix_use_runtimelinking" = yes; then
+ # Warning - without using the other runtime loading flags (-brtl),
+ # -berok will link without error, but may produce a broken library.
+ _LT_TAGVAR(allow_undefined_flag, $1)='-berok'
+ # Determine the default libpath from the value encoded in an empty
+ # executable.
+ _LT_SYS_MODULE_PATH_AIX([$1])
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+ else
+ if test "$host_cpu" = ia64; then
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+ _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+ _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
+ else
+ # Determine the default libpath from the value encoded in an
+ # empty executable.
+ _LT_SYS_MODULE_PATH_AIX([$1])
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+ # Warning - without using the other run time loading flags,
+ # -berok will link without error, but may produce a broken library.
+ _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+ _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+ if test "$with_gnu_ld" = yes; then
+ # We only use this code for GNU lds that support --whole-archive.
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+ else
+ # Exported symbols can be pulled into shared objects from archives
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
+ fi
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
+ # This is similar to how AIX traditionally builds its shared
+ # libraries.
+ _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+ fi
+ fi
+ ;;
+
+ beos*)
+ if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+ # support --undefined. This deserves some investigation. FIXME
+ _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+
+ chorus*)
+ case $cc_basename in
+ *)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ esac
+ ;;
+
+ cygwin* | mingw* | pw32* | cegcc*)
+ case $GXX,$cc_basename in
+ ,cl* | no,cl*)
+ # Native MSVC
+ # hardcode_libdir_flag_spec is actually meaningless, as there is
+ # no search path for DLLs.
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ _LT_TAGVAR(always_export_symbols, $1)=yes
+ _LT_TAGVAR(file_list_spec, $1)='@'
+ # Tell ltmain to make .lib files, not .a files.
+ libext=lib
+ # Tell ltmain to make .dll files, not .so files.
+ shrext_cmds=".dll"
+ # FIXME: Setting linknames here is a bad hack.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames='
+ _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp;
+ else
+ $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp;
+ fi~
+ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+ linknames='
+ # The linker will not automatically build a static lib if we build a DLL.
+ # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
+ _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+ # Don't use ranlib
+ _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib'
+ _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~
+ lt_tool_outputfile="@TOOL_OUTPUT@"~
+ case $lt_outputfile in
+ *.exe|*.EXE) ;;
+ *)
+ lt_outputfile="$lt_outputfile.exe"
+ lt_tool_outputfile="$lt_tool_outputfile.exe"
+ ;;
+ esac~
+ func_to_tool_file "$lt_outputfile"~
+ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then
+ $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+ $RM "$lt_outputfile.manifest";
+ fi'
+ ;;
+ *)
+ # g++
+ # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+ # as there is no search path for DLLs.
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols'
+ _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+ _LT_TAGVAR(always_export_symbols, $1)=no
+ _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+
+ if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ # If the export-symbols file already is a .def file (1st line
+ # is EXPORTS), use it as is; otherwise, prepend...
+ _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+ cp $export_symbols $output_objdir/$soname.def;
+ else
+ echo EXPORTS > $output_objdir/$soname.def;
+ cat $export_symbols >> $output_objdir/$soname.def;
+ fi~
+ $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+ esac
+ ;;
+ darwin* | rhapsody*)
+ _LT_DARWIN_LINKER_FEATURES($1)
+ ;;
+
+ dgux*)
+ case $cc_basename in
+ ec++*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ ghcx*)
+ # Green Hills C++ Compiler
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ esac
+ ;;
+
+ freebsd2.*)
+ # C++ shared libraries reported to be fairly broken before
+ # switch to ELF
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+
+ freebsd-elf*)
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ ;;
+
+ freebsd* | dragonfly*)
+ # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+ # conventions
+ _LT_TAGVAR(ld_shlibs, $1)=yes
+ ;;
+
+ haiku*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ ;;
+
+ hpux9*)
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+ # but as the default
+ # location of the library.
+
+ case $cc_basename in
+ CC*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ aCC*)
+ _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+ ;;
+ *)
+ if test "$GXX" = yes; then
+ _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+ else
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+ esac
+ ;;
+
+ hpux10*|hpux11*)
+ if test $with_gnu_ld = no; then
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+ case $host_cpu in
+ hppa*64*|ia64*)
+ ;;
+ *)
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ ;;
+ esac
+ fi
+ case $host_cpu in
+ hppa*64*|ia64*)
+ _LT_TAGVAR(hardcode_direct, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ ;;
+ *)
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+ _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+ # but as the default
+ # location of the library.
+ ;;
+ esac
+
+ case $cc_basename in
+ CC*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ aCC*)
+ case $host_cpu in
+ hppa*64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ ia64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ *)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ esac
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+ ;;
+ *)
+ if test "$GXX" = yes; then
+ if test $with_gnu_ld = no; then
+ case $host_cpu in
+ hppa*64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ ia64*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ *)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ ;;
+ esac
+ fi
+ else
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+ esac
+ ;;
+
+ interix[[3-9]]*)
+ _LT_TAGVAR(hardcode_direct, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+ # Instead, shared libraries are loaded at an image base (0x10000000 by
+ # default) and relocated if they conflict, which is a slow very memory
+ # consuming and fragmenting process. To avoid this, we pick a random,
+ # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+ # time. Moving up from 0x10000000 also allows more sbrk(2) space.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+ ;;
+ irix5* | irix6*)
+ case $cc_basename in
+ CC*)
+ # SGI C++
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+
+ # Archives containing C++ object files must be created using
+ # "CC -ar", where "CC" is the IRIX C++ compiler. This is
+ # necessary to make sure instantiated templates are included
+ # in the archive.
+ _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
+ ;;
+ *)
+ if test "$GXX" = yes; then
+ if test "$with_gnu_ld" = no; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib'
+ fi
+ fi
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ ;;
+ esac
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+ _LT_TAGVAR(inherit_rpath, $1)=yes
+ ;;
+
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ case $cc_basename in
+ KCC*)
+ # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+ # KCC will only create a shared library if the output file
+ # ends with ".so" (or ".sl" for HP-UX), so rename the library
+ # to its proper name (with version) after linking.
+ _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+ # Archives containing C++ object files must be created using
+ # "CC -Bstatic", where "CC" is the KAI C++ compiler.
+ _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
+ ;;
+ icpc* | ecpc* )
+ # Intel C++
+ with_gnu_ld=yes
+ # version 8.0 and above of icpc choke on multiply defined symbols
+ # if we add $predep_objects and $postdep_objects, however 7.1 and
+ # earlier do not add the objects themselves.
+ case `$CC -V 2>&1` in
+ *"Version 7."*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ ;;
+ *) # Version 8.0 or newer
+ tmp_idyn=
+ case $host_cpu in
+ ia64*) tmp_idyn=' -i_dynamic';;
+ esac
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+ ;;
+ esac
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+ ;;
+ pgCC* | pgcpp*)
+ # Portland Group C++ compiler
+ case `$CC -V` in
+ *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*)
+ _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+ compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+ $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ $RANLIB $oldlib'
+ _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
+ rm -rf $tpldir~
+ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ ;;
+ *) # Version 6 and above use weak symbols
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ ;;
+ esac
+
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ ;;
+ cxx*)
+ # Compaq C++
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+
+ runpath_var=LD_RUN_PATH
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
+ ;;
+ xl* | mpixl* | bgxl*)
+ # IBM XL 8.0 on PPC, with GNU ld
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+ if test "x$supports_anon_versioning" = xyes; then
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~
+ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
+ echo "local: *; };" >> $output_objdir/$libname.ver~
+ $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+ fi
+ ;;
+ *)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*)
+ # Sun C++ 5.9
+ _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive'
+ _LT_TAGVAR(compiler_needs_object, $1)=yes
+
+ # Not sure whether something based on
+ # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
+ # would be better.
+ output_verbose_link_cmd='func_echo_all'
+
+ # Archives containing C++ object files must be created using
+ # "CC -xar", where "CC" is the Sun C++ compiler. This is
+ # necessary to make sure instantiated templates are included
+ # in the archive.
+ _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+ ;;
+ esac
+ ;;
+ esac
+ ;;
+
+ lynxos*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+
+ m88k*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+
+ mvs*)
+ case $cc_basename in
+ cxx*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ esac
+ ;;
+
+ netbsd*)
+ if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+ wlarc=
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ fi
+ # Workaround some broken pre-1.5 toolchains
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+ ;;
+
+ *nto* | *qnx*)
+ _LT_TAGVAR(ld_shlibs, $1)=yes
+ ;;
+
+ openbsd2*)
+ # C++ shared libraries are fairly broken
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+
+ openbsd*)
+ if test -f /usr/libexec/ld.so; then
+ _LT_TAGVAR(hardcode_direct, $1)=yes
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ _LT_TAGVAR(hardcode_direct_absolute, $1)=yes
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+ _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+ fi
+ output_verbose_link_cmd=func_echo_all
+ else
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+
+ osf3* | osf4* | osf5*)
+ case $cc_basename in
+ KCC*)
+ # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+ # KCC will only create a shared library if the output file
+ # ends with ".so" (or ".sl" for HP-UX), so rename the library
+ # to its proper name (with version) after linking.
+ _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+ # Archives containing C++ object files must be created using
+ # the KAI C++ compiler.
+ case $host in
+ osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;;
+ *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;;
+ esac
+ ;;
+ RCC*)
+ # Rational C++ 2.4.1
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ cxx*)
+ case $host in
+ osf3*)
+ _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ ;;
+ *)
+ _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+ echo "-hidden">> $lib.exp~
+ $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~
+ $RM $lib.exp'
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+ ;;
+ esac
+
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ #
+ # There doesn't appear to be a way to prevent this compiler from
+ # explicitly linking system object files so we need to strip them
+ # from the output so that they don't get included in the library
+ # dependencies.
+ output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+ ;;
+ *)
+ if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+ _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+ case $host in
+ osf3*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ ;;
+ *)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+ ;;
+ esac
+
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=:
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+
+ else
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ fi
+ ;;
+ esac
+ ;;
+
+ psos*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+
+ sunos4*)
+ case $cc_basename in
+ CC*)
+ # Sun C++ 4.x
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ lcc*)
+ # Lucid
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ esac
+ ;;
+
+ solaris*)
+ case $cc_basename in
+ CC* | sunCC*)
+ # Sun C++ 4.2, 5.x and Centerline C++
+ _LT_TAGVAR(archive_cmds_need_lc,$1)=yes
+ _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ case $host_os in
+ solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+ *)
+ # The compiler driver will combine and reorder linker options,
+ # but understands `-z linker_flag'.
+ # Supported since Solaris 2.6 (maybe 2.5.1?)
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract'
+ ;;
+ esac
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+
+ output_verbose_link_cmd='func_echo_all'
+
+ # Archives containing C++ object files must be created using
+ # "CC -xar", where "CC" is the Sun C++ compiler. This is
+ # necessary to make sure instantiated templates are included
+ # in the archive.
+ _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+ ;;
+ gcx*)
+ # Green Hills C++ Compiler
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+
+ # The C++ compiler must be used to create the archive.
+ _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+ ;;
+ *)
+ # GNU C++ compiler with Solaris linker
+ if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+ _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
+ if $CC --version | $GREP -v '^2\.7' > /dev/null; then
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+ else
+ # g++ 2.7 appears to require `-G' NOT `-shared' on this
+ # platform.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+ $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+ # Commands to make compiler produce verbose output that lists
+ # what "hidden" libraries, object files and flags are used when
+ # linking a shared library.
+ output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+ fi
+
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
+ case $host_os in
+ solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+ *)
+ _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
+ ;;
+ esac
+ fi
+ ;;
+ esac
+ ;;
+
+ sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
+ _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ runpath_var='LD_RUN_PATH'
+
+ case $cc_basename in
+ CC*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ *)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ esac
+ ;;
+
+ sysv5* | sco3.2v5* | sco5v6*)
+ # Note: We can NOT use -z defs as we might desire, because we do not
+ # link with -lc, and that would cause any symbols used from libc to
+ # always be unresolved, which means just about no library would
+ # ever link correctly. If we're not using GNU ld we use -z text
+ # though, which does catch some bad symbols but isn't as heavy-handed
+ # as -z defs.
+ _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
+ _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
+ _LT_TAGVAR(archive_cmds_need_lc, $1)=no
+ _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir'
+ _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
+ _LT_TAGVAR(link_all_deplibs, $1)=yes
+ _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+ runpath_var='LD_RUN_PATH'
+
+ case $cc_basename in
+ CC*)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~
+ '"$_LT_TAGVAR(old_archive_cmds, $1)"
+ _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~
+ '"$_LT_TAGVAR(reload_cmds, $1)"
+ ;;
+ *)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+ ;;
+ esac
+ ;;
+
+ tandem*)
+ case $cc_basename in
+ NCC*)
+ # NonStop-UX NCC 3.20
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ *)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ esac
+ ;;
+
+ vxworks*)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+
+ *)
+ # FIXME: insert proper C++ library support
+ _LT_TAGVAR(ld_shlibs, $1)=no
+ ;;
+ esac
+
+ AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)])
+ test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+ _LT_TAGVAR(GCC, $1)="$GXX"
+ _LT_TAGVAR(LD, $1)="$LD"
+
+ ## CAVEAT EMPTOR:
+ ## There is no encapsulation within the following macros, do not change
+ ## the running order or otherwise move them around unless you know exactly
+ ## what you are doing...
+ _LT_SYS_HIDDEN_LIBDEPS($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_SYS_DYNAMIC_LINKER($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+ fi # test -n "$compiler"
+
+ CC=$lt_save_CC
+ CFLAGS=$lt_save_CFLAGS
+ LDCXX=$LD
+ LD=$lt_save_LD
+ GCC=$lt_save_GCC
+ with_gnu_ld=$lt_save_with_gnu_ld
+ lt_cv_path_LDCXX=$lt_cv_path_LD
+ lt_cv_path_LD=$lt_save_path_LD
+ lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+ lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+fi # test "$_lt_caught_CXX_error" != yes
+
+AC_LANG_POP
+])# _LT_LANG_CXX_CONFIG
+
+
+# _LT_FUNC_STRIPNAME_CNF
+# ----------------------
+# func_stripname_cnf prefix suffix name
+# strip PREFIX and SUFFIX off of NAME.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+#
+# This function is identical to the (non-XSI) version of func_stripname,
+# except this one can be used by m4 code that may be executed by configure,
+# rather than the libtool script.
+m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl
+AC_REQUIRE([_LT_DECL_SED])
+AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])
+func_stripname_cnf ()
+{
+ case ${2} in
+ .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
+ *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
+ esac
+} # func_stripname_cnf
+])# _LT_FUNC_STRIPNAME_CNF
+
+# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME])
+# ---------------------------------
+# Figure out "hidden" library dependencies from verbose
+# compiler output when linking a shared library.
+# Parse the compiler output and extract the necessary
+# objects, libraries and library flags.
+m4_defun([_LT_SYS_HIDDEN_LIBDEPS],
+[m4_require([_LT_FILEUTILS_DEFAULTS])dnl
+AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl
+# Dependencies to place before and after the object being linked:
+_LT_TAGVAR(predep_objects, $1)=
+_LT_TAGVAR(postdep_objects, $1)=
+_LT_TAGVAR(predeps, $1)=
+_LT_TAGVAR(postdeps, $1)=
+_LT_TAGVAR(compiler_lib_search_path, $1)=
+
+dnl we can't use the lt_simple_compile_test_code here,
+dnl because it contains code intended for an executable,
+dnl not a library. It's possible we should let each
+dnl tag define a new lt_????_link_test_code variable,
+dnl but it's only used here...
+m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
+int a;
+void foo (void) { a = 0; }
+_LT_EOF
+], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
+class Foo
+{
+public:
+ Foo (void) { a = 0; }
+private:
+ int a;
+};
+_LT_EOF
+], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
+ subroutine foo
+ implicit none
+ integer*4 a
+ a=0
+ return
+ end
+_LT_EOF
+], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF
+ subroutine foo
+ implicit none
+ integer a
+ a=0
+ return
+ end
+_LT_EOF
+], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
+public class foo {
+ private int a;
+ public void bar (void) {
+ a = 0;
+ }
+};
+_LT_EOF
+], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF
+package foo
+func foo() {
+}
+_LT_EOF
+])
+
+_lt_libdeps_save_CFLAGS=$CFLAGS
+case "$CC $CFLAGS " in #(
+*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
+*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
+*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
+esac
+
+dnl Parse the compiler output and extract the necessary
+dnl objects, libraries and library flags.
+if AC_TRY_EVAL(ac_compile); then
+ # Parse the compiler output and extract the necessary
+ # objects, libraries and library flags.
+
+ # Sentinel used to keep track of whether or not we are before
+ # the conftest object file.
+ pre_test_object_deps_done=no
+
+ for p in `eval "$output_verbose_link_cmd"`; do
+ case ${prev}${p} in
+
+ -L* | -R* | -l*)
+ # Some compilers place space between "-{L,R}" and the path.
+ # Remove the space.
+ if test $p = "-L" ||
+ test $p = "-R"; then
+ prev=$p
+ continue
+ fi
+
+ # Expand the sysroot to ease extracting the directories later.
+ if test -z "$prev"; then
+ case $p in
+ -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
+ -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
+ -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
+ esac
+ fi
+ case $p in
+ =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
+ esac
+ if test "$pre_test_object_deps_done" = no; then
+ case ${prev} in
+ -L | -R)
+ # Internal compiler library paths should come after those
+ # provided the user. The postdeps already come after the
+ # user supplied libs so there is no need to process them.
+ if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then
+ _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
+ else
+ _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
+ fi
+ ;;
+ # The "-l" case would never come before the object being
+ # linked, so don't bother handling this case.
+ esac
+ else
+ if test -z "$_LT_TAGVAR(postdeps, $1)"; then
+ _LT_TAGVAR(postdeps, $1)="${prev}${p}"
+ else
+ _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}"
+ fi
+ fi
+ prev=
+ ;;
+
+ *.lto.$objext) ;; # Ignore GCC LTO objects
+ *.$objext)
+ # This assumes that the test object file only shows up
+ # once in the compiler output.
+ if test "$p" = "conftest.$objext"; then
+ pre_test_object_deps_done=yes
+ continue
+ fi
+
+ if test "$pre_test_object_deps_done" = no; then
+ if test -z "$_LT_TAGVAR(predep_objects, $1)"; then
+ _LT_TAGVAR(predep_objects, $1)="$p"
+ else
+ _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p"
+ fi
+ else
+ if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then
+ _LT_TAGVAR(postdep_objects, $1)="$p"
+ else
+ _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p"
+ fi
+ fi
+ ;;
+
+ *) ;; # Ignore the rest.
+
+ esac
+ done
+
+ # Clean up.
+ rm -f a.out a.exe
+else
+ echo "libtool.m4: error: problem compiling $1 test program"
+fi
+
+$RM -f confest.$objext
+CFLAGS=$_lt_libdeps_save_CFLAGS
+
+# PORTME: override above test on systems where it is broken
+m4_if([$1], [CXX],
+[case $host_os in
+interix[[3-9]]*)
+ # Interix 3.5 installs completely hosed .la files for C++, so rather than
+ # hack all around it, let's just trust "g++" to DTRT.
+ _LT_TAGVAR(predep_objects,$1)=
+ _LT_TAGVAR(postdep_objects,$1)=
+ _LT_TAGVAR(postdeps,$1)=
+ ;;
+
+linux*)
+ case `$CC -V 2>&1 | sed 5q` in
+ *Sun\ C*)
+ # Sun C++ 5.9
+
+ # The more standards-conforming stlport4 library is
+ # incompatible with the Cstd library. Avoid specifying
+ # it if it's in CXXFLAGS. Ignore libCrun as
+ # -library=stlport4 depends on it.
+ case " $CXX $CXXFLAGS " in
+ *" -library=stlport4 "*)
+ solaris_use_stlport4=yes
+ ;;
+ esac
+
+ if test "$solaris_use_stlport4" != yes; then
+ _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
+ fi
+ ;;
+ esac
+ ;;
+
+solaris*)
+ case $cc_basename in
+ CC* | sunCC*)
+ # The more standards-conforming stlport4 library is
+ # incompatible with the Cstd library. Avoid specifying
+ # it if it's in CXXFLAGS. Ignore libCrun as
+ # -library=stlport4 depends on it.
+ case " $CXX $CXXFLAGS " in
+ *" -library=stlport4 "*)
+ solaris_use_stlport4=yes
+ ;;
+ esac
+
+ # Adding this requires a known-good setup of shared libraries for
+ # Sun compiler versions before 5.6, else PIC objects from an old
+ # archive will be linked into the output, leading to subtle bugs.
+ if test "$solaris_use_stlport4" != yes; then
+ _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
+ fi
+ ;;
+ esac
+ ;;
+esac
+])
+
+case " $_LT_TAGVAR(postdeps, $1) " in
+*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;;
+esac
+ _LT_TAGVAR(compiler_lib_search_dirs, $1)=
+if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then
+ _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'`
+fi
+_LT_TAGDECL([], [compiler_lib_search_dirs], [1],
+ [The directories searched by this compiler when creating a shared library])
+_LT_TAGDECL([], [predep_objects], [1],
+ [Dependencies to place before and after the objects being linked to
+ create a shared library])
+_LT_TAGDECL([], [postdep_objects], [1])
+_LT_TAGDECL([], [predeps], [1])
+_LT_TAGDECL([], [postdeps], [1])
+_LT_TAGDECL([], [compiler_lib_search_path], [1],
+ [The library search path used internally by the compiler when linking
+ a shared library])
+])# _LT_SYS_HIDDEN_LIBDEPS
+
+
+# _LT_LANG_F77_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a Fortran 77 compiler are
+# suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_F77_CONFIG],
+[AC_LANG_PUSH(Fortran 77)
+if test -z "$F77" || test "X$F77" = "Xno"; then
+ _lt_disable_F77=yes
+fi
+
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for f77 test sources.
+ac_ext=f
+
+# Object file extension for compiled f77 test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the F77 compiler isn't working. Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test "$_lt_disable_F77" != yes; then
+ # Code to be used in simple compile tests
+ lt_simple_compile_test_code="\
+ subroutine t
+ return
+ end
+"
+
+ # Code to be used in simple link tests
+ lt_simple_link_test_code="\
+ program t
+ end
+"
+
+ # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+ _LT_TAG_COMPILER
+
+ # save warnings/boilerplate of simple test code
+ _LT_COMPILER_BOILERPLATE
+ _LT_LINKER_BOILERPLATE
+
+ # Allow CC to be a program name with arguments.
+ lt_save_CC="$CC"
+ lt_save_GCC=$GCC
+ lt_save_CFLAGS=$CFLAGS
+ CC=${F77-"f77"}
+ CFLAGS=$FFLAGS
+ compiler=$CC
+ _LT_TAGVAR(compiler, $1)=$CC
+ _LT_CC_BASENAME([$compiler])
+ GCC=$G77
+ if test -n "$compiler"; then
+ AC_MSG_CHECKING([if libtool supports shared libraries])
+ AC_MSG_RESULT([$can_build_shared])
+
+ AC_MSG_CHECKING([whether to build shared libraries])
+ test "$can_build_shared" = "no" && enable_shared=no
+
+ # On AIX, shared libraries and static libraries use the same namespace, and
+ # are all built from PIC.
+ case $host_os in
+ aix3*)
+ test "$enable_shared" = yes && enable_static=no
+ if test -n "$RANLIB"; then
+ archive_cmds="$archive_cmds~\$RANLIB \$lib"
+ postinstall_cmds='$RANLIB $lib'
+ fi
+ ;;
+ aix[[4-9]]*)
+ if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+ test "$enable_shared" = yes && enable_static=no
+ fi
+ ;;
+ esac
+ AC_MSG_RESULT([$enable_shared])
+
+ AC_MSG_CHECKING([whether to build static libraries])
+ # Make sure either enable_shared or enable_static is yes.
+ test "$enable_shared" = yes || enable_static=yes
+ AC_MSG_RESULT([$enable_static])
+
+ _LT_TAGVAR(GCC, $1)="$G77"
+ _LT_TAGVAR(LD, $1)="$LD"
+
+ ## CAVEAT EMPTOR:
+ ## There is no encapsulation within the following macros, do not change
+ ## the running order or otherwise move them around unless you know exactly
+ ## what you are doing...
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_SYS_DYNAMIC_LINKER($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+ fi # test -n "$compiler"
+
+ GCC=$lt_save_GCC
+ CC="$lt_save_CC"
+ CFLAGS="$lt_save_CFLAGS"
+fi # test "$_lt_disable_F77" != yes
+
+AC_LANG_POP
+])# _LT_LANG_F77_CONFIG
+
+
+# _LT_LANG_FC_CONFIG([TAG])
+# -------------------------
+# Ensure that the configuration variables for a Fortran compiler are
+# suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_FC_CONFIG],
+[AC_LANG_PUSH(Fortran)
+
+if test -z "$FC" || test "X$FC" = "Xno"; then
+ _lt_disable_FC=yes
+fi
+
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_TAGVAR(allow_undefined_flag, $1)=
+_LT_TAGVAR(always_export_symbols, $1)=no
+_LT_TAGVAR(archive_expsym_cmds, $1)=
+_LT_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_TAGVAR(hardcode_direct, $1)=no
+_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_TAGVAR(hardcode_minus_L, $1)=no
+_LT_TAGVAR(hardcode_automatic, $1)=no
+_LT_TAGVAR(inherit_rpath, $1)=no
+_LT_TAGVAR(module_cmds, $1)=
+_LT_TAGVAR(module_expsym_cmds, $1)=
+_LT_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+_LT_TAGVAR(no_undefined_flag, $1)=
+_LT_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for fc test sources.
+ac_ext=${ac_fc_srcext-f}
+
+# Object file extension for compiled fc test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# No sense in running all these tests if we already determined that
+# the FC compiler isn't working. Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test "$_lt_disable_FC" != yes; then
+ # Code to be used in simple compile tests
+ lt_simple_compile_test_code="\
+ subroutine t
+ return
+ end
+"
+
+ # Code to be used in simple link tests
+ lt_simple_link_test_code="\
+ program t
+ end
+"
+
+ # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+ _LT_TAG_COMPILER
+
+ # save warnings/boilerplate of simple test code
+ _LT_COMPILER_BOILERPLATE
+ _LT_LINKER_BOILERPLATE
+
+ # Allow CC to be a program name with arguments.
+ lt_save_CC="$CC"
+ lt_save_GCC=$GCC
+ lt_save_CFLAGS=$CFLAGS
+ CC=${FC-"f95"}
+ CFLAGS=$FCFLAGS
+ compiler=$CC
+ GCC=$ac_cv_fc_compiler_gnu
+
+ _LT_TAGVAR(compiler, $1)=$CC
+ _LT_CC_BASENAME([$compiler])
+
+ if test -n "$compiler"; then
+ AC_MSG_CHECKING([if libtool supports shared libraries])
+ AC_MSG_RESULT([$can_build_shared])
+
+ AC_MSG_CHECKING([whether to build shared libraries])
+ test "$can_build_shared" = "no" && enable_shared=no
+
+ # On AIX, shared libraries and static libraries use the same namespace, and
+ # are all built from PIC.
+ case $host_os in
+ aix3*)
+ test "$enable_shared" = yes && enable_static=no
+ if test -n "$RANLIB"; then
+ archive_cmds="$archive_cmds~\$RANLIB \$lib"
+ postinstall_cmds='$RANLIB $lib'
+ fi
+ ;;
+ aix[[4-9]]*)
+ if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+ test "$enable_shared" = yes && enable_static=no
+ fi
+ ;;
+ esac
+ AC_MSG_RESULT([$enable_shared])
+
+ AC_MSG_CHECKING([whether to build static libraries])
+ # Make sure either enable_shared or enable_static is yes.
+ test "$enable_shared" = yes || enable_static=yes
+ AC_MSG_RESULT([$enable_static])
+
+ _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu"
+ _LT_TAGVAR(LD, $1)="$LD"
+
+ ## CAVEAT EMPTOR:
+ ## There is no encapsulation within the following macros, do not change
+ ## the running order or otherwise move them around unless you know exactly
+ ## what you are doing...
+ _LT_SYS_HIDDEN_LIBDEPS($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_SYS_DYNAMIC_LINKER($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+ fi # test -n "$compiler"
+
+ GCC=$lt_save_GCC
+ CC=$lt_save_CC
+ CFLAGS=$lt_save_CFLAGS
+fi # test "$_lt_disable_FC" != yes
+
+AC_LANG_POP
+])# _LT_LANG_FC_CONFIG
+
+
+# _LT_LANG_GCJ_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Java Compiler compiler
+# are suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_GCJ_CONFIG],
+[AC_REQUIRE([LT_PROG_GCJ])dnl
+AC_LANG_SAVE
+
+# Source file extension for Java test sources.
+ac_ext=java
+
+# Object file extension for compiled Java test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="class foo {}"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=yes
+CC=${GCJ-"gcj"}
+CFLAGS=$GCJFLAGS
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)="$LD"
+_LT_CC_BASENAME([$compiler])
+
+# GCJ did not exist at the time GCC didn't implicitly link libc in.
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+ _LT_COMPILER_NO_RTTI($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_GCJ_CONFIG
+
+
+# _LT_LANG_GO_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Go compiler
+# are suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_GO_CONFIG],
+[AC_REQUIRE([LT_PROG_GO])dnl
+AC_LANG_SAVE
+
+# Source file extension for Go test sources.
+ac_ext=go
+
+# Object file extension for compiled Go test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="package main; func main() { }"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='package main; func main() { }'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=yes
+CC=${GOC-"gccgo"}
+CFLAGS=$GOFLAGS
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)="$LD"
+_LT_CC_BASENAME([$compiler])
+
+# Go did not exist at the time GCC didn't implicitly link libc in.
+_LT_TAGVAR(archive_cmds_need_lc, $1)=no
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+ _LT_COMPILER_NO_RTTI($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_GO_CONFIG
+
+
+# _LT_LANG_RC_CONFIG([TAG])
+# -------------------------
+# Ensure that the configuration variables for the Windows resource compiler
+# are suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_defun([_LT_LANG_RC_CONFIG],
+[AC_REQUIRE([LT_PROG_RC])dnl
+AC_LANG_SAVE
+
+# Source file extension for RC test sources.
+ac_ext=rc
+
+# Object file extension for compiled RC test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }'
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="$lt_simple_compile_test_code"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=
+CC=${RC-"windres"}
+CFLAGS=
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_CC_BASENAME([$compiler])
+_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+
+if test -n "$compiler"; then
+ :
+ _LT_CONFIG($1)
+fi
+
+GCC=$lt_save_GCC
+AC_LANG_RESTORE
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_RC_CONFIG
+
+
+# LT_PROG_GCJ
+# -----------
+AC_DEFUN([LT_PROG_GCJ],
+[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
+ [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
+ [AC_CHECK_TOOL(GCJ, gcj,)
+ test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
+ AC_SUBST(GCJFLAGS)])])[]dnl
+])
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_GCJ], [])
+
+
+# LT_PROG_GO
+# ----------
+AC_DEFUN([LT_PROG_GO],
+[AC_CHECK_TOOL(GOC, gccgo,)
+])
+
+
+# LT_PROG_RC
+# ----------
+AC_DEFUN([LT_PROG_RC],
+[AC_CHECK_TOOL(RC, windres,)
+])
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_RC], [])
+
+
+# _LT_DECL_EGREP
+# --------------
+# If we don't have a new enough Autoconf to choose the best grep
+# available, choose the one first in the user's PATH.
+m4_defun([_LT_DECL_EGREP],
+[AC_REQUIRE([AC_PROG_EGREP])dnl
+AC_REQUIRE([AC_PROG_FGREP])dnl
+test -z "$GREP" && GREP=grep
+_LT_DECL([], [GREP], [1], [A grep program that handles long lines])
+_LT_DECL([], [EGREP], [1], [An ERE matcher])
+_LT_DECL([], [FGREP], [1], [A literal string matcher])
+dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too
+AC_SUBST([GREP])
+])
+
+
+# _LT_DECL_OBJDUMP
+# --------------
+# If we don't have a new enough Autoconf to choose the best objdump
+# available, choose the one first in the user's PATH.
+m4_defun([_LT_DECL_OBJDUMP],
+[AC_CHECK_TOOL(OBJDUMP, objdump, false)
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper])
+AC_SUBST([OBJDUMP])
+])
+
+# _LT_DECL_DLLTOOL
+# ----------------
+# Ensure DLLTOOL variable is set.
+m4_defun([_LT_DECL_DLLTOOL],
+[AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [1], [DLL creation program])
+AC_SUBST([DLLTOOL])
+])
+
+# _LT_DECL_SED
+# ------------
+# Check for a fully-functional sed program, that truncates
+# as few characters as possible. Prefer GNU sed if found.
+m4_defun([_LT_DECL_SED],
+[AC_PROG_SED
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
+_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"],
+ [Sed that helps us avoid accidentally triggering echo(1) options like -n])
+])# _LT_DECL_SED
+
+m4_ifndef([AC_PROG_SED], [
+############################################################
+# NOTE: This macro has been submitted for inclusion into #
+# GNU Autoconf as AC_PROG_SED. When it is available in #
+# a released version of Autoconf we should remove this #
+# macro and use it instead. #
+############################################################
+
+m4_defun([AC_PROG_SED],
+[AC_MSG_CHECKING([for a sed that does not truncate output])
+AC_CACHE_VAL(lt_cv_path_SED,
+[# Loop through the user's path and test for sed and gsed.
+# Then use that list of sed's as ones to test for truncation.
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for lt_ac_prog in sed gsed; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
+ lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
+ fi
+ done
+ done
+done
+IFS=$as_save_IFS
+lt_ac_max=0
+lt_ac_count=0
+# Add /usr/xpg4/bin/sed as it is typically found on Solaris
+# along with /bin/sed that truncates output.
+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
+ test ! -f $lt_ac_sed && continue
+ cat /dev/null > conftest.in
+ lt_ac_count=0
+ echo $ECHO_N "0123456789$ECHO_C" >conftest.in
+ # Check for GNU sed and select it if it is found.
+ if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
+ lt_cv_path_SED=$lt_ac_sed
+ break
+ fi
+ while true; do
+ cat conftest.in conftest.in >conftest.tmp
+ mv conftest.tmp conftest.in
+ cp conftest.in conftest.nl
+ echo >>conftest.nl
+ $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
+ cmp -s conftest.out conftest.nl || break
+ # 10000 chars as input seems more than enough
+ test $lt_ac_count -gt 10 && break
+ lt_ac_count=`expr $lt_ac_count + 1`
+ if test $lt_ac_count -gt $lt_ac_max; then
+ lt_ac_max=$lt_ac_count
+ lt_cv_path_SED=$lt_ac_sed
+ fi
+ done
+done
+])
+SED=$lt_cv_path_SED
+AC_SUBST([SED])
+AC_MSG_RESULT([$SED])
+])#AC_PROG_SED
+])#m4_ifndef
+
+# Old name:
+AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED])
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([LT_AC_PROG_SED], [])
+
+
+# _LT_CHECK_SHELL_FEATURES
+# ------------------------
+# Find out whether the shell is Bourne or XSI compatible,
+# or has some other useful features.
+m4_defun([_LT_CHECK_SHELL_FEATURES],
+[AC_MSG_CHECKING([whether the shell understands some XSI constructs])
+# Try some XSI features
+xsi_shell=no
+( _lt_dummy="a/b/c"
+ test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \
+ = c,a/b,b/c, \
+ && eval 'test $(( 1 + 1 )) -eq 2 \
+ && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
+ && xsi_shell=yes
+AC_MSG_RESULT([$xsi_shell])
+_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell'])
+
+AC_MSG_CHECKING([whether the shell understands "+="])
+lt_shell_append=no
+( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \
+ >/dev/null 2>&1 \
+ && lt_shell_append=yes
+AC_MSG_RESULT([$lt_shell_append])
+_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append'])
+
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+ lt_unset=unset
+else
+ lt_unset=false
+fi
+_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+ # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+ lt_SP2NL='tr \040 \012'
+ lt_NL2SP='tr \015\012 \040\040'
+ ;;
+ *) # EBCDIC based system
+ lt_SP2NL='tr \100 \n'
+ lt_NL2SP='tr \r\n \100\100'
+ ;;
+esac
+_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl
+_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl
+])# _LT_CHECK_SHELL_FEATURES
+
+
+# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY)
+# ------------------------------------------------------
+# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and
+# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY.
+m4_defun([_LT_PROG_FUNCTION_REPLACE],
+[dnl {
+sed -e '/^$1 ()$/,/^} # $1 /c\
+$1 ()\
+{\
+m4_bpatsubsts([$2], [$], [\\], [^\([ ]\)], [\\\1])
+} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+test 0 -eq $? || _lt_function_replace_fail=:
+])
+
+
+# _LT_PROG_REPLACE_SHELLFNS
+# -------------------------
+# Replace existing portable implementations of several shell functions with
+# equivalent extended shell implementations where those features are available..
+m4_defun([_LT_PROG_REPLACE_SHELLFNS],
+[if test x"$xsi_shell" = xyes; then
+ _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl
+ case ${1} in
+ */*) func_dirname_result="${1%/*}${2}" ;;
+ * ) func_dirname_result="${3}" ;;
+ esac])
+
+ _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl
+ func_basename_result="${1##*/}"])
+
+ _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl
+ case ${1} in
+ */*) func_dirname_result="${1%/*}${2}" ;;
+ * ) func_dirname_result="${3}" ;;
+ esac
+ func_basename_result="${1##*/}"])
+
+ _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl
+ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
+ # positional parameters, so assign one to ordinary parameter first.
+ func_stripname_result=${3}
+ func_stripname_result=${func_stripname_result#"${1}"}
+ func_stripname_result=${func_stripname_result%"${2}"}])
+
+ _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl
+ func_split_long_opt_name=${1%%=*}
+ func_split_long_opt_arg=${1#*=}])
+
+ _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl
+ func_split_short_opt_arg=${1#??}
+ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}])
+
+ _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl
+ case ${1} in
+ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
+ *) func_lo2o_result=${1} ;;
+ esac])
+
+ _LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo])
+
+ _LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))])
+
+ _LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}])
+fi
+
+if test x"$lt_shell_append" = xyes; then
+ _LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"])
+
+ _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl
+ func_quote_for_eval "${2}"
+dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \
+ eval "${1}+=\\\\ \\$func_quote_for_eval_result"])
+
+ # Save a `func_append' function call where possible by direct use of '+='
+ sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+ test 0 -eq $? || _lt_function_replace_fail=:
+else
+ # Save a `func_append' function call even when '+=' is not available
+ sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \
+ && mv -f "$cfgfile.tmp" "$cfgfile" \
+ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp")
+ test 0 -eq $? || _lt_function_replace_fail=:
+fi
+
+if test x"$_lt_function_replace_fail" = x":"; then
+ AC_MSG_WARN([Unable to substitute extended shell functions in $ofile])
+fi
+])
+
+# _LT_PATH_CONVERSION_FUNCTIONS
+# -----------------------------
+# Determine which file name conversion functions should be used by
+# func_to_host_file (and, implicitly, by func_to_host_path). These are needed
+# for certain cross-compile configurations and native mingw.
+m4_defun([_LT_PATH_CONVERSION_FUNCTIONS],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+AC_MSG_CHECKING([how to convert $build file names to $host format])
+AC_CACHE_VAL(lt_cv_to_host_file_cmd,
+[case $host in
+ *-*-mingw* )
+ case $build in
+ *-*-mingw* ) # actually msys
+ lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
+ ;;
+ *-*-cygwin* )
+ lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
+ ;;
+ * ) # otherwise, assume *nix
+ lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
+ ;;
+ esac
+ ;;
+ *-*-cygwin* )
+ case $build in
+ *-*-mingw* ) # actually msys
+ lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
+ ;;
+ *-*-cygwin* )
+ lt_cv_to_host_file_cmd=func_convert_file_noop
+ ;;
+ * ) # otherwise, assume *nix
+ lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
+ ;;
+ esac
+ ;;
+ * ) # unhandled hosts (and "normal" native builds)
+ lt_cv_to_host_file_cmd=func_convert_file_noop
+ ;;
+esac
+])
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+AC_MSG_RESULT([$lt_cv_to_host_file_cmd])
+_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd],
+ [0], [convert $build file names to $host format])dnl
+
+AC_MSG_CHECKING([how to convert $build file names to toolchain format])
+AC_CACHE_VAL(lt_cv_to_tool_file_cmd,
+[#assume ordinary cross tools, or native build.
+lt_cv_to_tool_file_cmd=func_convert_file_noop
+case $host in
+ *-*-mingw* )
+ case $build in
+ *-*-mingw* ) # actually msys
+ lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
+ ;;
+ esac
+ ;;
+esac
+])
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+AC_MSG_RESULT([$lt_cv_to_tool_file_cmd])
+_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd],
+ [0], [convert $build files to toolchain format])dnl
+])# _LT_PATH_CONVERSION_FUNCTIONS
--- /dev/null
+# Helper functions for option handling. -*- Autoconf -*-
+#
+# Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation,
+# Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 7 ltoptions.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME)
+# ------------------------------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME)
+# ---------------------------------------
+# Set option OPTION-NAME for macro MACRO-NAME, and if there is a
+# matching handler defined, dispatch to it. Other OPTION-NAMEs are
+# saved as a flag.
+m4_define([_LT_SET_OPTION],
+[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl
+m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]),
+ _LT_MANGLE_DEFUN([$1], [$2]),
+ [m4_warning([Unknown $1 option `$2'])])[]dnl
+])
+
+
+# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET])
+# ------------------------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])])
+
+
+# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET)
+# -------------------------------------------------------
+# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME
+# are set.
+m4_define([_LT_UNLESS_OPTIONS],
+[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+ [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option),
+ [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST)
+# ----------------------------------------
+# OPTION-LIST is a space-separated list of Libtool options associated
+# with MACRO-NAME. If any OPTION has a matching handler declared with
+# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about
+# the unknown option and exit.
+m4_defun([_LT_SET_OPTIONS],
+[# Set options
+m4_foreach([_LT_Option], m4_split(m4_normalize([$2])),
+ [_LT_SET_OPTION([$1], _LT_Option)])
+
+m4_if([$1],[LT_INIT],[
+ dnl
+ dnl Simply set some default values (i.e off) if boolean options were not
+ dnl specified:
+ _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no
+ ])
+ _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no
+ ])
+ dnl
+ dnl If no reference was made to various pairs of opposing options, then
+ dnl we run the default mode handler for the pair. For example, if neither
+ dnl `shared' nor `disable-shared' was passed, we enable building of shared
+ dnl archives by default:
+ _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
+ _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
+ _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+ _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
+ [_LT_ENABLE_FAST_INSTALL])
+ ])
+])# _LT_SET_OPTIONS
+
+
+## --------------------------------- ##
+## Macros to handle LT_INIT options. ##
+## --------------------------------- ##
+
+# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME)
+# -----------------------------------------
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE)
+# -----------------------------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes
+])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([LT_INIT], [dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `dlopen' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], [])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([LT_INIT], [win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*)
+ AC_CHECK_TOOL(AS, as, false)
+ AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+ AC_CHECK_TOOL(OBJDUMP, objdump, false)
+ ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS], [1], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+_LT_SET_OPTION([LT_INIT], [win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `win32-dll' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the `shared' and
+# `disable-shared' LT_INIT options.
+# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+ [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+ [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+ [p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_shared=yes ;;
+ no) enable_shared=no ;;
+ *)
+ enable_shared=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for pkg in $enableval; do
+ IFS="$lt_save_ifs"
+ if test "X$pkg" = "X$p"; then
+ enable_shared=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac],
+ [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+ _LT_DECL([build_libtool_libs], [enable_shared], [0],
+ [Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared])
+])
+
+AC_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([LT_INIT], [disable-shared])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)])
+AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_SHARED], [])
+dnl AC_DEFUN([AM_DISABLE_SHARED], [])
+
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the `static' and
+# `disable-static' LT_INIT options.
+# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+ [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+ [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+ [p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_static=yes ;;
+ no) enable_static=no ;;
+ *)
+ enable_static=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for pkg in $enableval; do
+ IFS="$lt_save_ifs"
+ if test "X$pkg" = "X$p"; then
+ enable_static=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac],
+ [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+ _LT_DECL([build_old_libs], [enable_static], [0],
+ [Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AC_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static])
+])
+
+AC_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([LT_INIT], [disable-static])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)])
+AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AM_ENABLE_STATIC], [])
+dnl AC_DEFUN([AM_DISABLE_STATIC], [])
+
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the `fast-install'
+# and `disable-fast-install' LT_INIT options.
+# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+ [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+ [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+ [p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_fast_install=yes ;;
+ no) enable_fast_install=no ;;
+ *)
+ enable_fast_install=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for pkg in $enableval; do
+ IFS="$lt_save_ifs"
+ if test "X$pkg" = "X$p"; then
+ enable_fast_install=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac],
+ [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+ [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `fast-install' option into LT_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([LT_INIT], [disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-fast-install' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], [])
+dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], [])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the `pic-only' and `no-pic'
+# LT_INIT options.
+# MODE is either `yes' or `no'. If omitted, it defaults to `both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+ [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@],
+ [try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+ [lt_p=${PACKAGE-default}
+ case $withval in
+ yes|no) pic_mode=$withval ;;
+ *)
+ pic_mode=default
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+ for lt_pkg in $withval; do
+ IFS="$lt_save_ifs"
+ if test "X$lt_pkg" = "X$lt_p"; then
+ pic_mode=yes
+ fi
+ done
+ IFS="$lt_save_ifs"
+ ;;
+ esac],
+ [pic_mode=default])
+
+test -z "$pic_mode" && pic_mode=m4_default([$1], [default])
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PICMODE],
+[_LT_SET_OPTION([LT_INIT], [pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `pic-only' option into LT_INIT's first parameter.])
+])
+
+dnl aclocal-1.4 backwards compatibility:
+dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+## ----------------- ##
+## LTDL_INIT Options ##
+## ----------------- ##
+
+m4_define([_LTDL_MODE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive],
+ [m4_define([_LTDL_MODE], [nonrecursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [recursive],
+ [m4_define([_LTDL_MODE], [recursive])])
+LT_OPTION_DEFINE([LTDL_INIT], [subproject],
+ [m4_define([_LTDL_MODE], [subproject])])
+
+m4_define([_LTDL_TYPE], [])
+LT_OPTION_DEFINE([LTDL_INIT], [installable],
+ [m4_define([_LTDL_TYPE], [installable])])
+LT_OPTION_DEFINE([LTDL_INIT], [convenience],
+ [m4_define([_LTDL_TYPE], [convenience])])
--- /dev/null
+# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*-
+#
+# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+# Written by Gary V. Vaughan, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 6 ltsugar.m4
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier
+# versions in m4sugar had bugs.
+m4_define([lt_join],
+[m4_if([$#], [1], [],
+ [$#], [2], [[$2]],
+ [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])])
+m4_define([_lt_join],
+[m4_if([$#$2], [2], [],
+ [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])])
+
+
+# lt_car(LIST)
+# lt_cdr(LIST)
+# ------------
+# Manipulate m4 lists.
+# These macros are necessary as long as will still need to support
+# Autoconf-2.59 which quotes differently.
+m4_define([lt_car], [[$1]])
+m4_define([lt_cdr],
+[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])],
+ [$#], 1, [],
+ [m4_dquote(m4_shift($@))])])
+m4_define([lt_unquote], $1)
+
+
+# lt_append(MACRO-NAME, STRING, [SEPARATOR])
+# ------------------------------------------
+# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'.
+# Note that neither SEPARATOR nor STRING are expanded; they are appended
+# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked).
+# No SEPARATOR is output if MACRO-NAME was previously undefined (different
+# than defined and empty).
+#
+# This macro is needed until we can rely on Autoconf 2.62, since earlier
+# versions of m4sugar mistakenly expanded SEPARATOR but not STRING.
+m4_define([lt_append],
+[m4_define([$1],
+ m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])])
+
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+# Needed until we can rely on m4_combine added in Autoconf 2.62.
+m4_define([lt_combine],
+[m4_if(m4_eval([$# > 3]), [1],
+ [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl
+[[m4_foreach([_Lt_prefix], [$2],
+ [m4_foreach([_Lt_suffix],
+ ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[,
+ [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+ [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1],
+ [lt_append([$1], [$2], [$3])$4],
+ [$5])],
+ [lt_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$3])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+ m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+ m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+ [$5],
+ [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# --------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+ [lt_join(m4_quote(m4_default([$4], [[, ]])),
+ lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]),
+ [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl
+])
--- /dev/null
+# ltversion.m4 -- version numbers -*- Autoconf -*-
+#
+# Copyright (C) 2004 Free Software Foundation, Inc.
+# Written by Scott James Remnant, 2004
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# @configure_input@
+
+# serial 3337 ltversion.m4
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [2.4.2])
+m4_define([LT_PACKAGE_REVISION], [1.3337])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version='2.4.2'
+macro_revision='1.3337'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])
--- /dev/null
+# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*-
+#
+# Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc.
+# Written by Scott James Remnant, 2004.
+#
+# This file is free software; the Free Software Foundation gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+
+# serial 5 lt~obsolete.m4
+
+# These exist entirely to fool aclocal when bootstrapping libtool.
+#
+# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN)
+# which have later been changed to m4_define as they aren't part of the
+# exported API, or moved to Autoconf or Automake where they belong.
+#
+# The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN
+# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us
+# using a macro with the same name in our local m4/libtool.m4 it'll
+# pull the old libtool.m4 in (it doesn't see our shiny new m4_define
+# and doesn't know about Autoconf macros at all.)
+#
+# So we provide this file, which has a silly filename so it's always
+# included after everything else. This provides aclocal with the
+# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything
+# because those macros already exist, or will be overwritten later.
+# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6.
+#
+# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here.
+# Yes, that means every name once taken will need to remain here until
+# we give up compatibility with versions before 1.7, at which point
+# we need to keep only those names which we still refer to.
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])])
+
+m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])])
+m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])])
+m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])])
+m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])])
+m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])])
+m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])])
+m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])])
+m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])])
+m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])])
+m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])])
+m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])])
+m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])])
+m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])])
+m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])])
+m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])])
+m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])])
+m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])])
+m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])])
+m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])])
+m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])])
+m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])])
+m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])])
+m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])])
+m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])])
+m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])])
+m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])])
+m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])])
+m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])])
+m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])])
+m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])])
+m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])])
+m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])])
+m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])])
+m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])])
+m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])])
+m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])])
+m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])])
+m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])])
+m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])])
+m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])])
+m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])])
+m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])])
+m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])])
+m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])])
+m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])])
+m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])])
+m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])])
+m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])])
+m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])])
+m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])])
+m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])])
+m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])])
+m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])])
+m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])])
+m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])])
--- /dev/null
+#! /bin/sh
+# Common wrapper for a few potentially missing GNU programs.
+
+scriptversion=2013-10-28.13; # UTC
+
+# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 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 <http://www.gnu.org/licenses/>.
+
+# 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 <bug-automake@gnu.org>."
+ exit $?
+ ;;
+
+ -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+ echo "missing $scriptversion (GNU Automake)"
+ exit $?
+ ;;
+
+ -*)
+ echo 1>&2 "$0: unknown '$1' option"
+ echo 1>&2 "Try '$0 --help' for more information"
+ exit 1
+ ;;
+
+esac
+
+# Run the given program, remember its exit status.
+"$@"; st=$?
+
+# If it succeeded, we are done.
+test $st -eq 0 && exit 0
+
+# Also exit now if we it failed (or wasn't found), and '--version' was
+# passed; such an option is passed most likely to detect whether the
+# program is present and works.
+case $2 in --version|--help) exit $st;; esac
+
+# Exit code 63 means version mismatch. This often happens when the user
+# tries to use an ancient version of a tool on a file that requires a
+# minimum version.
+if test $st -eq 63; then
+ msg="probably too old"
+elif test $st -eq 127; then
+ # Program was missing.
+ msg="missing on your system"
+else
+ # Program was found and executed, but failed. Give up.
+ exit $st
+fi
+
+perl_URL=http://www.perl.org/
+flex_URL=http://flex.sourceforge.net/
+gnu_software_URL=http://www.gnu.org/software
+
+program_details ()
+{
+ case $1 in
+ aclocal|automake)
+ echo "The '$1' program is part of the GNU Automake package:"
+ echo "<$gnu_software_URL/automake>"
+ echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
+ echo "<$gnu_software_URL/autoconf>"
+ echo "<$gnu_software_URL/m4/>"
+ echo "<$perl_URL>"
+ ;;
+ autoconf|autom4te|autoheader)
+ echo "The '$1' program is part of the GNU Autoconf package:"
+ echo "<$gnu_software_URL/autoconf/>"
+ echo "It also requires GNU m4 and Perl in order to run:"
+ echo "<$gnu_software_URL/m4/>"
+ echo "<$perl_URL>"
+ ;;
+ esac
+}
+
+give_advice ()
+{
+ # Normalize program name to check for.
+ normalized_program=`echo "$1" | sed '
+ s/^gnu-//; t
+ s/^gnu//; t
+ s/^g//; t'`
+
+ printf '%s\n' "'$1' is $msg."
+
+ configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
+ case $normalized_program in
+ autoconf*)
+ echo "You should only need it if you modified 'configure.ac',"
+ echo "or m4 files included by it."
+ program_details 'autoconf'
+ ;;
+ autoheader*)
+ echo "You should only need it if you modified 'acconfig.h' or"
+ echo "$configure_deps."
+ program_details 'autoheader'
+ ;;
+ automake*)
+ echo "You should only need it if you modified 'Makefile.am' or"
+ echo "$configure_deps."
+ program_details 'automake'
+ ;;
+ aclocal*)
+ echo "You should only need it if you modified 'acinclude.m4' or"
+ echo "$configure_deps."
+ program_details 'aclocal'
+ ;;
+ autom4te*)
+ echo "You might have modified some maintainer files that require"
+ echo "the 'autom4te' program to be rebuilt."
+ program_details 'autom4te'
+ ;;
+ bison*|yacc*)
+ echo "You should only need it if you modified a '.y' file."
+ echo "You may want to install the GNU Bison package:"
+ echo "<$gnu_software_URL/bison/>"
+ ;;
+ lex*|flex*)
+ echo "You should only need it if you modified a '.l' file."
+ echo "You may want to install the Fast Lexical Analyzer package:"
+ echo "<$flex_URL>"
+ ;;
+ help2man*)
+ echo "You should only need it if you modified a dependency" \
+ "of a man page."
+ echo "You may want to install the GNU Help2man package:"
+ echo "<$gnu_software_URL/help2man/>"
+ ;;
+ makeinfo*)
+ echo "You should only need it if you modified a '.texi' file, or"
+ echo "any other file indirectly affecting the aspect of the manual."
+ echo "You might want to install the Texinfo package:"
+ echo "<$gnu_software_URL/texinfo/>"
+ echo "The spurious makeinfo call might also be the consequence of"
+ echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
+ echo "want to install GNU make:"
+ echo "<$gnu_software_URL/make/>"
+ ;;
+ *)
+ echo "You might have modified some files without having the proper"
+ echo "tools for further handling them. Check the 'README' file, it"
+ echo "often tells you about the needed prerequisites for installing"
+ echo "this package. You may also peek at any GNU archive site, in"
+ echo "case some other package contains this missing '$1' program."
+ ;;
+ esac
+}
+
+give_advice "$1" | sed -e '1s/^/WARNING: /' \
+ -e '2,$s/^/ /' >&2
+
+# Propagate the correct exit status (expected to be 127 for a program
+# not found, 63 for a program that failed due to version mismatch).
+exit $st
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
--- /dev/null
+SUBDIRS = include lib script bin test extensions
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+SOURCES =
+DIST_SOURCES =
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+ ctags-recursive dvi-recursive html-recursive info-recursive \
+ install-data-recursive install-dvi-recursive \
+ install-exec-recursive install-html-recursive \
+ install-info-recursive install-pdf-recursive \
+ install-ps-recursive install-recursive installcheck-recursive \
+ installdirs-recursive pdf-recursive ps-recursive \
+ tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
+ distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+ $(RECURSIVE_TARGETS) \
+ $(RECURSIVE_CLEAN_TARGETS) \
+ $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+ distdir
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DIST_SUBDIRS = $(SUBDIRS)
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+am__relativize = \
+ dir0=`pwd`; \
+ sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+ sed_rest='s,^[^/]*/*,,'; \
+ sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+ sed_butlast='s,/*[^/]*$$,,'; \
+ while test -n "$$dir1"; do \
+ first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+ if test "$$first" != "."; then \
+ if test "$$first" = ".."; then \
+ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+ else \
+ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+ if test "$$first2" = "$$first"; then \
+ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+ else \
+ dir2="../$$dir2"; \
+ fi; \
+ dir0="$$dir0"/"$$first"; \
+ fi; \
+ fi; \
+ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+ done; \
+ reldir="$$dir2"
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+SUBDIRS = include lib script bin test extensions
+all: all-recursive
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+# (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+ @fail=; \
+ if $(am__make_keepgoing); then \
+ failcom='fail=yes'; \
+ else \
+ failcom='exit 1'; \
+ fi; \
+ dot_seen=no; \
+ target=`echo $@ | sed s/-recursive//`; \
+ case "$@" in \
+ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+ *) list='$(SUBDIRS)' ;; \
+ esac; \
+ for subdir in $$list; do \
+ echo "Making $$target in $$subdir"; \
+ if test "$$subdir" = "."; then \
+ dot_seen=yes; \
+ local_target="$$target-am"; \
+ else \
+ local_target="$$target"; \
+ fi; \
+ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+ || eval $$failcom; \
+ done; \
+ if test "$$dot_seen" = "no"; then \
+ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+ fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+ include_option=--etags-include; \
+ empty_fix=.; \
+ else \
+ include_option=--include; \
+ empty_fix=; \
+ fi; \
+ list='$(SUBDIRS)'; for subdir in $$list; do \
+ if test "$$subdir" = .; then :; else \
+ test ! -f $$subdir/TAGS || \
+ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+ fi; \
+ done; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+ @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+ if test "$$subdir" = .; then :; else \
+ $(am__make_dryrun) \
+ || test -d "$(distdir)/$$subdir" \
+ || $(MKDIR_P) "$(distdir)/$$subdir" \
+ || exit 1; \
+ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+ $(am__relativize); \
+ new_distdir=$$reldir; \
+ dir1=$$subdir; dir2="$(top_distdir)"; \
+ $(am__relativize); \
+ new_top_distdir=$$reldir; \
+ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+ ($(am__cd) $$subdir && \
+ $(MAKE) $(AM_MAKEFLAGS) \
+ top_distdir="$$new_top_distdir" \
+ distdir="$$new_distdir" \
+ am__remove_distdir=: \
+ am__skip_length_check=: \
+ am__skip_mode_fix=: \
+ distdir) \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-recursive
+all-am: Makefile
+installdirs: installdirs-recursive
+installdirs-am:
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-recursive
+ -rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: $(am__recursive_targets) install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \
+ check-am clean clean-generic clean-libtool cscopelist-am ctags \
+ ctags-am distclean distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am html html-am info info-am \
+ install install-am install-data install-data-am install-dvi \
+ install-dvi-am install-exec install-exec-am install-html \
+ install-html-am install-info install-info-am install-man \
+ install-pdf install-pdf-am install-ps install-ps-am \
+ install-strip installcheck installcheck-am installdirs \
+ installdirs-am maintainer-clean maintainer-clean-generic \
+ mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
+ ps ps-am tags tags-am uninstall uninstall-am
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../include -I$(srcdir)/../script $(ICU_FLAGS)
+LDADD = ../script/libfstscript.la ../lib/libfst.la -lm $(DL_LIBS)
+
+if HAVE_BIN
+bin_PROGRAMS = fstarcsort fstclosure fstcompile fstcompose fstconcat \
+fstconnect fstconvert fstdeterminize fstdifference 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 fstdisambiguate
+
+fstarcsort_SOURCES = fstarcsort.cc
+
+fstclosure_SOURCES = fstclosure.cc
+
+fstcompile_SOURCES = fstcompile.cc
+
+fstcompose_SOURCES = fstcompose.cc
+
+fstconcat_SOURCES = fstconcat.cc
+
+fstconnect_SOURCES = fstconnect.cc
+
+fstconvert_SOURCES = fstconvert.cc
+
+fstdeterminize_SOURCES = fstdeterminize.cc
+
+fstdifference_SOURCES = fstdifference.cc
+
+fstdisambiguate_SOURCES = fstdisambiguate.cc
+
+fstdraw_SOURCES = fstdraw.cc
+
+fstencode_SOURCES = fstencode.cc
+
+fstepsnormalize_SOURCES = fstepsnormalize.cc
+
+fstequal_SOURCES = fstequal.cc
+
+fstequivalent_SOURCES = fstequivalent.cc
+
+fstinfo_SOURCES = fstinfo.cc
+
+fstintersect_SOURCES = fstintersect.cc
+
+fstinvert_SOURCES = fstinvert.cc
+
+fstisomorphic_SOURCES = fstisomorphic.cc
+
+fstmap_SOURCES = fstmap.cc
+
+fstminimize_SOURCES = fstminimize.cc
+
+fstprint_SOURCES = fstprint.cc
+
+fstproject_SOURCES = fstproject.cc
+
+fstprune_SOURCES = fstprune.cc
+
+fstpush_SOURCES = fstpush.cc
+
+fstrandgen_SOURCES = fstrandgen.cc
+
+fstrelabel_SOURCES = fstrelabel.cc
+
+fstreplace_SOURCES = fstreplace.cc
+
+fstreverse_SOURCES = fstreverse.cc
+
+fstreweight_SOURCES = fstreweight.cc
+
+fstrmepsilon_SOURCES = fstrmepsilon.cc
+
+fstshortestdistance_SOURCES = fstshortestdistance.cc
+
+fstshortestpath_SOURCES = fstshortestpath.cc
+
+fstsymbols_SOURCES = fstsymbols.cc
+
+fstsynchronize_SOURCES = fstsynchronize.cc
+
+fsttopsort_SOURCES = fsttopsort.cc
+
+fstunion_SOURCES = fstunion.cc
+endif
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@HAVE_BIN_TRUE@bin_PROGRAMS = fstarcsort$(EXEEXT) fstclosure$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstcompile$(EXEEXT) fstcompose$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstconcat$(EXEEXT) fstconnect$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstconvert$(EXEEXT) fstdeterminize$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstdifference$(EXEEXT) fstdraw$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstencode$(EXEEXT) fstepsnormalize$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstequal$(EXEEXT) fstequivalent$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstinfo$(EXEEXT) fstintersect$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstinvert$(EXEEXT) fstisomorphic$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstmap$(EXEEXT) fstminimize$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstprint$(EXEEXT) fstproject$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstprune$(EXEEXT) fstpush$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstrandgen$(EXEEXT) fstrelabel$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstreplace$(EXEEXT) fstreverse$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstreweight$(EXEEXT) 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) fstdisambiguate$(EXEEXT)
+subdir = src/bin
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)"
+PROGRAMS = $(bin_PROGRAMS)
+am__fstarcsort_SOURCES_DIST = fstarcsort.cc
+@HAVE_BIN_TRUE@am_fstarcsort_OBJECTS = fstarcsort.$(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
+@HAVE_BIN_TRUE@am_fstclosure_OBJECTS = fstclosure.$(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
+@HAVE_BIN_TRUE@am_fstcompile_OBJECTS = fstcompile.$(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
+@HAVE_BIN_TRUE@am_fstcompose_OBJECTS = fstcompose.$(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
+@HAVE_BIN_TRUE@am_fstconcat_OBJECTS = fstconcat.$(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
+@HAVE_BIN_TRUE@am_fstconnect_OBJECTS = fstconnect.$(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
+@HAVE_BIN_TRUE@am_fstconvert_OBJECTS = fstconvert.$(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
+@HAVE_BIN_TRUE@am_fstdeterminize_OBJECTS = fstdeterminize.$(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
+@HAVE_BIN_TRUE@am_fstdifference_OBJECTS = fstdifference.$(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
+@HAVE_BIN_TRUE@am_fstdisambiguate_OBJECTS = fstdisambiguate.$(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
+@HAVE_BIN_TRUE@am_fstdraw_OBJECTS = fstdraw.$(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
+@HAVE_BIN_TRUE@am_fstencode_OBJECTS = fstencode.$(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
+@HAVE_BIN_TRUE@am_fstepsnormalize_OBJECTS = fstepsnormalize.$(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
+@HAVE_BIN_TRUE@am_fstequal_OBJECTS = fstequal.$(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
+@HAVE_BIN_TRUE@am_fstequivalent_OBJECTS = fstequivalent.$(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
+@HAVE_BIN_TRUE@am_fstinfo_OBJECTS = fstinfo.$(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
+@HAVE_BIN_TRUE@am_fstintersect_OBJECTS = fstintersect.$(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
+@HAVE_BIN_TRUE@am_fstinvert_OBJECTS = fstinvert.$(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
+@HAVE_BIN_TRUE@am_fstisomorphic_OBJECTS = fstisomorphic.$(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
+@HAVE_BIN_TRUE@am_fstmap_OBJECTS = fstmap.$(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
+@HAVE_BIN_TRUE@am_fstminimize_OBJECTS = fstminimize.$(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
+@HAVE_BIN_TRUE@am_fstprint_OBJECTS = fstprint.$(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
+@HAVE_BIN_TRUE@am_fstproject_OBJECTS = fstproject.$(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
+@HAVE_BIN_TRUE@am_fstprune_OBJECTS = fstprune.$(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
+@HAVE_BIN_TRUE@am_fstpush_OBJECTS = fstpush.$(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
+@HAVE_BIN_TRUE@am_fstrandgen_OBJECTS = fstrandgen.$(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
+@HAVE_BIN_TRUE@am_fstrelabel_OBJECTS = fstrelabel.$(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
+@HAVE_BIN_TRUE@am_fstreplace_OBJECTS = fstreplace.$(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
+@HAVE_BIN_TRUE@am_fstreverse_OBJECTS = fstreverse.$(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
+@HAVE_BIN_TRUE@am_fstreweight_OBJECTS = fstreweight.$(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
+@HAVE_BIN_TRUE@am_fstrmepsilon_OBJECTS = fstrmepsilon.$(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
+@HAVE_BIN_TRUE@am_fstshortestdistance_OBJECTS = \
+@HAVE_BIN_TRUE@ fstshortestdistance.$(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
+@HAVE_BIN_TRUE@am_fstshortestpath_OBJECTS = fstshortestpath.$(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
+@HAVE_BIN_TRUE@am_fstsymbols_OBJECTS = fstsymbols.$(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
+@HAVE_BIN_TRUE@am_fstsynchronize_OBJECTS = fstsynchronize.$(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
+@HAVE_BIN_TRUE@am_fsttopsort_OBJECTS = fsttopsort.$(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
+@HAVE_BIN_TRUE@am_fstunion_OBJECTS = fstunion.$(OBJEXT)
+fstunion_OBJECTS = $(am_fstunion_OBJECTS)
+fstunion_LDADD = $(LDADD)
+fstunion_DEPENDENCIES = ../script/libfstscript.la ../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(fstarcsort_SOURCES) $(fstclosure_SOURCES) \
+ $(fstcompile_SOURCES) $(fstcompose_SOURCES) \
+ $(fstconcat_SOURCES) $(fstconnect_SOURCES) \
+ $(fstconvert_SOURCES) $(fstdeterminize_SOURCES) \
+ $(fstdifference_SOURCES) $(fstdisambiguate_SOURCES) \
+ $(fstdraw_SOURCES) $(fstencode_SOURCES) \
+ $(fstepsnormalize_SOURCES) $(fstequal_SOURCES) \
+ $(fstequivalent_SOURCES) $(fstinfo_SOURCES) \
+ $(fstintersect_SOURCES) $(fstinvert_SOURCES) \
+ $(fstisomorphic_SOURCES) $(fstmap_SOURCES) \
+ $(fstminimize_SOURCES) $(fstprint_SOURCES) \
+ $(fstproject_SOURCES) $(fstprune_SOURCES) $(fstpush_SOURCES) \
+ $(fstrandgen_SOURCES) $(fstrelabel_SOURCES) \
+ $(fstreplace_SOURCES) $(fstreverse_SOURCES) \
+ $(fstreweight_SOURCES) $(fstrmepsilon_SOURCES) \
+ $(fstshortestdistance_SOURCES) $(fstshortestpath_SOURCES) \
+ $(fstsymbols_SOURCES) $(fstsynchronize_SOURCES) \
+ $(fsttopsort_SOURCES) $(fstunion_SOURCES)
+DIST_SOURCES = $(am__fstarcsort_SOURCES_DIST) \
+ $(am__fstclosure_SOURCES_DIST) $(am__fstcompile_SOURCES_DIST) \
+ $(am__fstcompose_SOURCES_DIST) $(am__fstconcat_SOURCES_DIST) \
+ $(am__fstconnect_SOURCES_DIST) $(am__fstconvert_SOURCES_DIST) \
+ $(am__fstdeterminize_SOURCES_DIST) \
+ $(am__fstdifference_SOURCES_DIST) \
+ $(am__fstdisambiguate_SOURCES_DIST) \
+ $(am__fstdraw_SOURCES_DIST) $(am__fstencode_SOURCES_DIST) \
+ $(am__fstepsnormalize_SOURCES_DIST) \
+ $(am__fstequal_SOURCES_DIST) $(am__fstequivalent_SOURCES_DIST) \
+ $(am__fstinfo_SOURCES_DIST) $(am__fstintersect_SOURCES_DIST) \
+ $(am__fstinvert_SOURCES_DIST) \
+ $(am__fstisomorphic_SOURCES_DIST) $(am__fstmap_SOURCES_DIST) \
+ $(am__fstminimize_SOURCES_DIST) $(am__fstprint_SOURCES_DIST) \
+ $(am__fstproject_SOURCES_DIST) $(am__fstprune_SOURCES_DIST) \
+ $(am__fstpush_SOURCES_DIST) $(am__fstrandgen_SOURCES_DIST) \
+ $(am__fstrelabel_SOURCES_DIST) $(am__fstreplace_SOURCES_DIST) \
+ $(am__fstreverse_SOURCES_DIST) $(am__fstreweight_SOURCES_DIST) \
+ $(am__fstrmepsilon_SOURCES_DIST) \
+ $(am__fstshortestdistance_SOURCES_DIST) \
+ $(am__fstshortestpath_SOURCES_DIST) \
+ $(am__fstsymbols_SOURCES_DIST) \
+ $(am__fstsynchronize_SOURCES_DIST) \
+ $(am__fsttopsort_SOURCES_DIST) $(am__fstunion_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../include -I$(srcdir)/../script $(ICU_FLAGS)
+LDADD = ../script/libfstscript.la ../lib/libfst.la -lm $(DL_LIBS)
+@HAVE_BIN_TRUE@fstarcsort_SOURCES = fstarcsort.cc
+@HAVE_BIN_TRUE@fstclosure_SOURCES = fstclosure.cc
+@HAVE_BIN_TRUE@fstcompile_SOURCES = fstcompile.cc
+@HAVE_BIN_TRUE@fstcompose_SOURCES = fstcompose.cc
+@HAVE_BIN_TRUE@fstconcat_SOURCES = fstconcat.cc
+@HAVE_BIN_TRUE@fstconnect_SOURCES = fstconnect.cc
+@HAVE_BIN_TRUE@fstconvert_SOURCES = fstconvert.cc
+@HAVE_BIN_TRUE@fstdeterminize_SOURCES = fstdeterminize.cc
+@HAVE_BIN_TRUE@fstdifference_SOURCES = fstdifference.cc
+@HAVE_BIN_TRUE@fstdisambiguate_SOURCES = fstdisambiguate.cc
+@HAVE_BIN_TRUE@fstdraw_SOURCES = fstdraw.cc
+@HAVE_BIN_TRUE@fstencode_SOURCES = fstencode.cc
+@HAVE_BIN_TRUE@fstepsnormalize_SOURCES = fstepsnormalize.cc
+@HAVE_BIN_TRUE@fstequal_SOURCES = fstequal.cc
+@HAVE_BIN_TRUE@fstequivalent_SOURCES = fstequivalent.cc
+@HAVE_BIN_TRUE@fstinfo_SOURCES = fstinfo.cc
+@HAVE_BIN_TRUE@fstintersect_SOURCES = fstintersect.cc
+@HAVE_BIN_TRUE@fstinvert_SOURCES = fstinvert.cc
+@HAVE_BIN_TRUE@fstisomorphic_SOURCES = fstisomorphic.cc
+@HAVE_BIN_TRUE@fstmap_SOURCES = fstmap.cc
+@HAVE_BIN_TRUE@fstminimize_SOURCES = fstminimize.cc
+@HAVE_BIN_TRUE@fstprint_SOURCES = fstprint.cc
+@HAVE_BIN_TRUE@fstproject_SOURCES = fstproject.cc
+@HAVE_BIN_TRUE@fstprune_SOURCES = fstprune.cc
+@HAVE_BIN_TRUE@fstpush_SOURCES = fstpush.cc
+@HAVE_BIN_TRUE@fstrandgen_SOURCES = fstrandgen.cc
+@HAVE_BIN_TRUE@fstrelabel_SOURCES = fstrelabel.cc
+@HAVE_BIN_TRUE@fstreplace_SOURCES = fstreplace.cc
+@HAVE_BIN_TRUE@fstreverse_SOURCES = fstreverse.cc
+@HAVE_BIN_TRUE@fstreweight_SOURCES = fstreweight.cc
+@HAVE_BIN_TRUE@fstrmepsilon_SOURCES = fstrmepsilon.cc
+@HAVE_BIN_TRUE@fstshortestdistance_SOURCES = fstshortestdistance.cc
+@HAVE_BIN_TRUE@fstshortestpath_SOURCES = fstshortestpath.cc
+@HAVE_BIN_TRUE@fstsymbols_SOURCES = fstsymbols.cc
+@HAVE_BIN_TRUE@fstsynchronize_SOURCES = fstsynchronize.cc
+@HAVE_BIN_TRUE@fsttopsort_SOURCES = fsttopsort.cc
+@HAVE_BIN_TRUE@fstunion_SOURCES = fstunion.cc
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/bin/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/bin/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p \
+ || test -f $$p1 \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+
+fstarcsort$(EXEEXT): $(fstarcsort_OBJECTS) $(fstarcsort_DEPENDENCIES) $(EXTRA_fstarcsort_DEPENDENCIES)
+ @rm -f fstarcsort$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstarcsort_OBJECTS) $(fstarcsort_LDADD) $(LIBS)
+
+fstclosure$(EXEEXT): $(fstclosure_OBJECTS) $(fstclosure_DEPENDENCIES) $(EXTRA_fstclosure_DEPENDENCIES)
+ @rm -f fstclosure$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstclosure_OBJECTS) $(fstclosure_LDADD) $(LIBS)
+
+fstcompile$(EXEEXT): $(fstcompile_OBJECTS) $(fstcompile_DEPENDENCIES) $(EXTRA_fstcompile_DEPENDENCIES)
+ @rm -f fstcompile$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstcompile_OBJECTS) $(fstcompile_LDADD) $(LIBS)
+
+fstcompose$(EXEEXT): $(fstcompose_OBJECTS) $(fstcompose_DEPENDENCIES) $(EXTRA_fstcompose_DEPENDENCIES)
+ @rm -f fstcompose$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstcompose_OBJECTS) $(fstcompose_LDADD) $(LIBS)
+
+fstconcat$(EXEEXT): $(fstconcat_OBJECTS) $(fstconcat_DEPENDENCIES) $(EXTRA_fstconcat_DEPENDENCIES)
+ @rm -f fstconcat$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstconcat_OBJECTS) $(fstconcat_LDADD) $(LIBS)
+
+fstconnect$(EXEEXT): $(fstconnect_OBJECTS) $(fstconnect_DEPENDENCIES) $(EXTRA_fstconnect_DEPENDENCIES)
+ @rm -f fstconnect$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstconnect_OBJECTS) $(fstconnect_LDADD) $(LIBS)
+
+fstconvert$(EXEEXT): $(fstconvert_OBJECTS) $(fstconvert_DEPENDENCIES) $(EXTRA_fstconvert_DEPENDENCIES)
+ @rm -f fstconvert$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstconvert_OBJECTS) $(fstconvert_LDADD) $(LIBS)
+
+fstdeterminize$(EXEEXT): $(fstdeterminize_OBJECTS) $(fstdeterminize_DEPENDENCIES) $(EXTRA_fstdeterminize_DEPENDENCIES)
+ @rm -f fstdeterminize$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstdeterminize_OBJECTS) $(fstdeterminize_LDADD) $(LIBS)
+
+fstdifference$(EXEEXT): $(fstdifference_OBJECTS) $(fstdifference_DEPENDENCIES) $(EXTRA_fstdifference_DEPENDENCIES)
+ @rm -f fstdifference$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstdifference_OBJECTS) $(fstdifference_LDADD) $(LIBS)
+
+fstdisambiguate$(EXEEXT): $(fstdisambiguate_OBJECTS) $(fstdisambiguate_DEPENDENCIES) $(EXTRA_fstdisambiguate_DEPENDENCIES)
+ @rm -f fstdisambiguate$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstdisambiguate_OBJECTS) $(fstdisambiguate_LDADD) $(LIBS)
+
+fstdraw$(EXEEXT): $(fstdraw_OBJECTS) $(fstdraw_DEPENDENCIES) $(EXTRA_fstdraw_DEPENDENCIES)
+ @rm -f fstdraw$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstdraw_OBJECTS) $(fstdraw_LDADD) $(LIBS)
+
+fstencode$(EXEEXT): $(fstencode_OBJECTS) $(fstencode_DEPENDENCIES) $(EXTRA_fstencode_DEPENDENCIES)
+ @rm -f fstencode$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstencode_OBJECTS) $(fstencode_LDADD) $(LIBS)
+
+fstepsnormalize$(EXEEXT): $(fstepsnormalize_OBJECTS) $(fstepsnormalize_DEPENDENCIES) $(EXTRA_fstepsnormalize_DEPENDENCIES)
+ @rm -f fstepsnormalize$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstepsnormalize_OBJECTS) $(fstepsnormalize_LDADD) $(LIBS)
+
+fstequal$(EXEEXT): $(fstequal_OBJECTS) $(fstequal_DEPENDENCIES) $(EXTRA_fstequal_DEPENDENCIES)
+ @rm -f fstequal$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstequal_OBJECTS) $(fstequal_LDADD) $(LIBS)
+
+fstequivalent$(EXEEXT): $(fstequivalent_OBJECTS) $(fstequivalent_DEPENDENCIES) $(EXTRA_fstequivalent_DEPENDENCIES)
+ @rm -f fstequivalent$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstequivalent_OBJECTS) $(fstequivalent_LDADD) $(LIBS)
+
+fstinfo$(EXEEXT): $(fstinfo_OBJECTS) $(fstinfo_DEPENDENCIES) $(EXTRA_fstinfo_DEPENDENCIES)
+ @rm -f fstinfo$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstinfo_OBJECTS) $(fstinfo_LDADD) $(LIBS)
+
+fstintersect$(EXEEXT): $(fstintersect_OBJECTS) $(fstintersect_DEPENDENCIES) $(EXTRA_fstintersect_DEPENDENCIES)
+ @rm -f fstintersect$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstintersect_OBJECTS) $(fstintersect_LDADD) $(LIBS)
+
+fstinvert$(EXEEXT): $(fstinvert_OBJECTS) $(fstinvert_DEPENDENCIES) $(EXTRA_fstinvert_DEPENDENCIES)
+ @rm -f fstinvert$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstinvert_OBJECTS) $(fstinvert_LDADD) $(LIBS)
+
+fstisomorphic$(EXEEXT): $(fstisomorphic_OBJECTS) $(fstisomorphic_DEPENDENCIES) $(EXTRA_fstisomorphic_DEPENDENCIES)
+ @rm -f fstisomorphic$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstisomorphic_OBJECTS) $(fstisomorphic_LDADD) $(LIBS)
+
+fstmap$(EXEEXT): $(fstmap_OBJECTS) $(fstmap_DEPENDENCIES) $(EXTRA_fstmap_DEPENDENCIES)
+ @rm -f fstmap$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstmap_OBJECTS) $(fstmap_LDADD) $(LIBS)
+
+fstminimize$(EXEEXT): $(fstminimize_OBJECTS) $(fstminimize_DEPENDENCIES) $(EXTRA_fstminimize_DEPENDENCIES)
+ @rm -f fstminimize$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstminimize_OBJECTS) $(fstminimize_LDADD) $(LIBS)
+
+fstprint$(EXEEXT): $(fstprint_OBJECTS) $(fstprint_DEPENDENCIES) $(EXTRA_fstprint_DEPENDENCIES)
+ @rm -f fstprint$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstprint_OBJECTS) $(fstprint_LDADD) $(LIBS)
+
+fstproject$(EXEEXT): $(fstproject_OBJECTS) $(fstproject_DEPENDENCIES) $(EXTRA_fstproject_DEPENDENCIES)
+ @rm -f fstproject$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstproject_OBJECTS) $(fstproject_LDADD) $(LIBS)
+
+fstprune$(EXEEXT): $(fstprune_OBJECTS) $(fstprune_DEPENDENCIES) $(EXTRA_fstprune_DEPENDENCIES)
+ @rm -f fstprune$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstprune_OBJECTS) $(fstprune_LDADD) $(LIBS)
+
+fstpush$(EXEEXT): $(fstpush_OBJECTS) $(fstpush_DEPENDENCIES) $(EXTRA_fstpush_DEPENDENCIES)
+ @rm -f fstpush$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstpush_OBJECTS) $(fstpush_LDADD) $(LIBS)
+
+fstrandgen$(EXEEXT): $(fstrandgen_OBJECTS) $(fstrandgen_DEPENDENCIES) $(EXTRA_fstrandgen_DEPENDENCIES)
+ @rm -f fstrandgen$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstrandgen_OBJECTS) $(fstrandgen_LDADD) $(LIBS)
+
+fstrelabel$(EXEEXT): $(fstrelabel_OBJECTS) $(fstrelabel_DEPENDENCIES) $(EXTRA_fstrelabel_DEPENDENCIES)
+ @rm -f fstrelabel$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstrelabel_OBJECTS) $(fstrelabel_LDADD) $(LIBS)
+
+fstreplace$(EXEEXT): $(fstreplace_OBJECTS) $(fstreplace_DEPENDENCIES) $(EXTRA_fstreplace_DEPENDENCIES)
+ @rm -f fstreplace$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstreplace_OBJECTS) $(fstreplace_LDADD) $(LIBS)
+
+fstreverse$(EXEEXT): $(fstreverse_OBJECTS) $(fstreverse_DEPENDENCIES) $(EXTRA_fstreverse_DEPENDENCIES)
+ @rm -f fstreverse$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstreverse_OBJECTS) $(fstreverse_LDADD) $(LIBS)
+
+fstreweight$(EXEEXT): $(fstreweight_OBJECTS) $(fstreweight_DEPENDENCIES) $(EXTRA_fstreweight_DEPENDENCIES)
+ @rm -f fstreweight$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstreweight_OBJECTS) $(fstreweight_LDADD) $(LIBS)
+
+fstrmepsilon$(EXEEXT): $(fstrmepsilon_OBJECTS) $(fstrmepsilon_DEPENDENCIES) $(EXTRA_fstrmepsilon_DEPENDENCIES)
+ @rm -f fstrmepsilon$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstrmepsilon_OBJECTS) $(fstrmepsilon_LDADD) $(LIBS)
+
+fstshortestdistance$(EXEEXT): $(fstshortestdistance_OBJECTS) $(fstshortestdistance_DEPENDENCIES) $(EXTRA_fstshortestdistance_DEPENDENCIES)
+ @rm -f fstshortestdistance$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstshortestdistance_OBJECTS) $(fstshortestdistance_LDADD) $(LIBS)
+
+fstshortestpath$(EXEEXT): $(fstshortestpath_OBJECTS) $(fstshortestpath_DEPENDENCIES) $(EXTRA_fstshortestpath_DEPENDENCIES)
+ @rm -f fstshortestpath$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstshortestpath_OBJECTS) $(fstshortestpath_LDADD) $(LIBS)
+
+fstsymbols$(EXEEXT): $(fstsymbols_OBJECTS) $(fstsymbols_DEPENDENCIES) $(EXTRA_fstsymbols_DEPENDENCIES)
+ @rm -f fstsymbols$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstsymbols_OBJECTS) $(fstsymbols_LDADD) $(LIBS)
+
+fstsynchronize$(EXEEXT): $(fstsynchronize_OBJECTS) $(fstsynchronize_DEPENDENCIES) $(EXTRA_fstsynchronize_DEPENDENCIES)
+ @rm -f fstsynchronize$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstsynchronize_OBJECTS) $(fstsynchronize_LDADD) $(LIBS)
+
+fsttopsort$(EXEEXT): $(fsttopsort_OBJECTS) $(fsttopsort_DEPENDENCIES) $(EXTRA_fsttopsort_DEPENDENCIES)
+ @rm -f fsttopsort$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fsttopsort_OBJECTS) $(fsttopsort_LDADD) $(LIBS)
+
+fstunion$(EXEEXT): $(fstunion_OBJECTS) $(fstunion_DEPENDENCIES) $(EXTRA_fstunion_DEPENDENCIES)
+ @rm -f fstunion$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstunion_OBJECTS) $(fstunion_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstarcsort.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstclosure.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompile.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompose.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconcat.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconnect.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstconvert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdeterminize.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdifference.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdisambiguate.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstdraw.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstencode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstepsnormalize.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequal.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstequivalent.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinfo.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstintersect.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstinvert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstisomorphic.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstmap.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstminimize.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprint.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstproject.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstprune.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstpush.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrandgen.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrelabel.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreplace.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreverse.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstreweight.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrmepsilon.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestdistance.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstshortestpath.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsymbols.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstsynchronize.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fsttopsort.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstunion.Po@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(PROGRAMS)
+installdirs:
+ for dir in "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+ clean-binPROGRAMS clean-generic clean-libtool cscopelist-am \
+ ctags ctags-am distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-binPROGRAMS \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Sorts arcs of an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/compat.h>
+#include <fst/script/arcsort.h>
+#include <fst/script/getters.h>
+
+DEFINE_string(sort_type, "ilabel",
+ "Comparison method, one of: \"ilabel\", \"olabel\"");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+
+ string usage = "Sorts arcs of an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> 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);
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Creates the Kleene closure of an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/closure.h>
+#include <fst/script/getters.h>
+
+DEFINE_bool(closure_plus, false,
+ "Do not add the empty path (T+ instead of T*)?");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+
+ string usage = "Creates the Kleene closure of an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> fst(MutableFstClass::Read(in_name, true));
+ if (!fst) return 1;
+
+ s::Closure(fst.get(), s::GetClosureType(FLAGS_closure_plus));
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <fstream>
+#include <istream>
+#include <memory>
+#include <string>
+
+#include <fst/script/compile.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::SymbolTable;
+ using fst::SymbolTableTextOptions;
+
+ string usage = "Creates binary FSTs from simple text format.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [text.fst [binary.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ string source = "standard input";
+ std::ifstream fstrm;
+ if (argc > 1 && strcmp(argv[1], "-") != 0) {
+ fstrm.open(argv[1]);
+ if (!fstrm) {
+ LOG(ERROR) << argv[0] << ": Open failed, file = " << argv[1];
+ return 1;
+ }
+ source = argv[1];
+ }
+ std::istream &istrm = fstrm.is_open() ? fstrm : std::cin;
+
+ const SymbolTableTextOptions opts(FLAGS_allow_negative_labels);
+
+ std::unique_ptr<const SymbolTable> isyms;
+ if (!FLAGS_isymbols.empty()) {
+ isyms.reset(SymbolTable::ReadText(FLAGS_isymbols, opts));
+ if (!isyms) return 1;
+ }
+
+ std::unique_ptr<const SymbolTable> osyms;
+ if (!FLAGS_osymbols.empty()) {
+ osyms.reset(SymbolTable::ReadText(FLAGS_osymbols, opts));
+ if (!osyms) return 1;
+ }
+
+ std::unique_ptr<const SymbolTable> ssyms;
+ if (!FLAGS_ssymbols.empty()) {
+ ssyms.reset(SymbolTable::ReadText(FLAGS_ssymbols));
+ if (!ssyms) return 1;
+ }
+
+ const string dest = argc > 2 ? argv[2] : "";
+
+ s::CompileFst(istrm, source, dest, FLAGS_fst_type, FLAGS_arc_type,
+ isyms.get(), osyms.get(), ssyms.get(), FLAGS_acceptor,
+ FLAGS_keep_isymbols, FLAGS_keep_osymbols,
+ FLAGS_keep_state_numbering, FLAGS_allow_negative_labels);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Composes two FSTs.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/compose.h>
+#include <fst/script/getters.h>
+
+DEFINE_string(compose_filter, "auto",
+ "Composition filter, one of: \"alt_sequence\", \"auto\", "
+ "\"match\", \"null\", \"sequence\", \"trivial\"");
+DEFINE_bool(connect, true, "Trim output");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Composes two FSTs.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") != 0 ? argv[1] : "";
+ const string in2_name =
+ (argc > 2 && (strcmp(argv[2], "-") != 0)) ? argv[2] : "";
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+
+ std::unique_ptr<FstClass> 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());
+
+ fst::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;
+ }
+
+ fst::ComposeOptions opts(FLAGS_connect, compose_filter);
+
+ s::Compose(*ifst1, *ifst2, &ofst, opts);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Concatenates two FSTs.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/concat.h>
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::MutableFstClass;
+
+ string usage = "Concatenates two FSTs.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<MutableFstClass> fst1(MutableFstClass::Read(in1_name, true));
+ if (!fst1) return 1;
+
+ std::unique_ptr<FstClass> fst2(FstClass::Read(in2_name));
+ if (!fst2) return 1;
+
+ s::Concat(fst1.get(), *fst2);
+ fst1->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/connect.h>
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::MutableFstClass;
+
+ string usage = "Removes useless states and arcs from an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> fst(MutableFstClass::Read(in_name, true));
+ if (!fst) return 1;
+
+ s::Connect(fst.get());
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Converts an FST to another type.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/convert.h>
+
+DEFINE_string(fst_type, "vector", "Output FST type");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+
+ string usage = "Converts an FST to another type.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ if (ifst->FstType() != FLAGS_fst_type) {
+ std::unique_ptr<FstClass> ofst(s::Convert(*ifst, FLAGS_fst_type));
+ if (!ofst) return 1;
+ ofst->Write(out_name);
+ } else {
+ ifst->Write(out_name);
+ }
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Determinizes an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/determinize.h>
+#include <fst/script/getters.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::DeterminizeType;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::script::WeightClass;
+
+ string usage = "Determinizes an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ DeterminizeType det_type;
+ if (!s::GetDeterminizeType(FLAGS_det_type, &det_type)) {
+ LOG(ERROR) << argv[0] << ": Unknown or unsupported determinization type: "
+ << FLAGS_det_type;
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Subtracts an unweighted DFA from an FSA.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/getters.h>
+#include <fst/script/difference.h>
+
+DEFINE_string(compose_filter, "auto",
+ "Composition filter, one of: \"alt_sequence\", \"auto\", "
+ "\"match\", \"null\", \"sequence\", \"trivial\"");
+DEFINE_bool(connect, true, "Trim output");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::ComposeFilter;
+ using fst::DifferenceOptions;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Subtracts an unweighted DFA from an FSA.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+
+ std::unique_ptr<FstClass> 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);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Disambiguates an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/disambiguate.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::script::WeightClass;
+
+ string usage = "Disambiguates an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <fstream>
+#include <memory>
+#include <ostream>
+#include <string>
+
+#include <fst/script/draw.h>
+
+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_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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::SymbolTable;
+ using fst::SymbolTableTextOptions;
+
+ string usage = "Prints out binary FSTs in dot text format.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [binary.fst [text.dot]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+
+ std::unique_ptr<FstClass> fst(FstClass::Read(in_name));
+ if (!fst) return 1;
+
+ string dest = "stdout";
+ std::ofstream fstrm;
+ if (argc == 3) {
+ fstrm.open(argv[2]);
+ if (!fstrm) {
+ LOG(ERROR) << argv[0] << ": Open failed, file = " << argv[2];
+ return 1;
+ }
+ dest = argv[2];
+ }
+ std::ostream &ostrm = fstrm.is_open() ? fstrm : std::cout;
+
+ const SymbolTableTextOptions opts(FLAGS_allow_negative_labels);
+
+ std::unique_ptr<const SymbolTable> isyms;
+ if (!FLAGS_isymbols.empty() && !FLAGS_numeric) {
+ isyms.reset(SymbolTable::ReadText(FLAGS_isymbols, opts));
+ if (!isyms) return 1;
+ }
+
+ std::unique_ptr<const SymbolTable> osyms;
+ if (!FLAGS_osymbols.empty() && !FLAGS_numeric) {
+ osyms.reset(SymbolTable::ReadText(FLAGS_osymbols, opts));
+ if (!osyms) return 1;
+ }
+
+ std::unique_ptr<const SymbolTable> ssyms;
+ if (!FLAGS_ssymbols.empty() && !FLAGS_numeric) {
+ ssyms.reset(SymbolTable::ReadText(FLAGS_ssymbols));
+ if (!ssyms) return 1;
+ }
+
+ if (!isyms && !FLAGS_numeric && fst->InputSymbols()) {
+ isyms.reset(fst->InputSymbols()->Copy());
+ }
+
+ if (!osyms && !FLAGS_numeric && fst->OutputSymbols()) {
+ osyms.reset(fst->OutputSymbols()->Copy());
+ }
+
+ s::DrawFst(*fst, isyms.get(), osyms.get(), ssyms.get(), FLAGS_acceptor,
+ FLAGS_title, FLAGS_width, FLAGS_height, FLAGS_portrait,
+ FLAGS_vertical, FLAGS_ranksep, FLAGS_nodesep, FLAGS_fontsize,
+ FLAGS_precision, FLAGS_show_weight_one, &ostrm, dest);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Encode transducer labels and/or weights.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/decode.h>
+#include <fst/script/encode.h>
+#include <fst/script/getters.h>
+
+/// EncodeMain specific flag definitions
+DEFINE_bool(encode_labels, false, "Encode output labels");
+DEFINE_bool(encode_weights, false, "Encode weights");
+DEFINE_bool(encode_reuse, false, "Re-use existing codex");
+DEFINE_bool(decode, false, "Decode labels and/or weights");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::MutableFstClass;
+
+ string usage = "Encodes transducer labels and/or weights.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.fst codex [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string codex_name = argv[2];
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ std::unique_ptr<MutableFstClass> fst(MutableFstClass::Read(in_name, true));
+ if (!fst) return 1;
+
+ if (FLAGS_decode) {
+ s::Decode(fst.get(), codex_name);
+ fst->Write(out_name);
+ } else {
+ const auto flags =
+ s::GetEncodeFlags(FLAGS_encode_labels, FLAGS_encode_weights);
+ s::Encode(fst.get(), flags, FLAGS_encode_reuse, codex_name);
+ fst->Write(out_name);
+ }
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Epsilon-normalizes an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/epsnormalize.h>
+#include <fst/script/getters.h>
+
+DEFINE_bool(eps_norm_output, false, "Normalize output epsilons");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Epsilon normalizes an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ s::EpsNormalize(*ifst, &ofst, s::GetEpsNormalizeType(FLAGS_eps_norm_output));
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/equal.h>
+
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+
+ string usage = "Two FSTs are equal iff the exit status is zero.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc != 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+
+ std::unique_ptr<FstClass> 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;
+}
--- /dev/null
+// 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 <unistd.h>
+
+#include <climits>
+#include <cstring>
+#include <ctime>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/equivalent.h>
+#include <fst/script/getters.h>
+#include <fst/script/randequivalent.h>
+
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+DEFINE_bool(random, false,
+ "Test equivalence by randomly selecting paths in the input FSTs");
+DEFINE_int32(max_length, INT32_MAX, "Maximum path length");
+DEFINE_int32(npath, 1, "Number of paths to generate");
+DEFINE_int32(seed, time(nullptr) + getpid(), "Random seed");
+DEFINE_string(select, "uniform",
+ "Selection type: one of: "
+ " \"uniform\", \"log_prob (when appropriate),"
+ " \"fast_log_prob\" (when appropriate)");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+
+ string usage =
+ "Two DFAs are equivalent iff the exit status is zero.\n\n"
+ " Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc != 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+
+ std::unique_ptr<FstClass> 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;
+ }
+ bool result = s::RandEquivalent(
+ *ifst1, *ifst2, FLAGS_npath, FLAGS_delta, FLAGS_seed,
+ fst::RandGenOptions<s::RandArcSelection>(ras, FLAGS_max_length));
+ if (!result) VLOG(1) << "FSTs are not equivalent";
+ return result ? 0 : 2;
+ }
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/info.h>
+
+DEFINE_string(arc_filter, "any",
+ "Arc filter: one of:"
+ " \"any\", \"epsilon\", \"iepsilon\", \"oepsilon\"; "
+ "this only affects the counts of (co)accessible states, "
+ "connected states, and (strongly) connected components");
+DEFINE_string(info_type, "auto",
+ "Info format: one of: \"auto\", \"long\", \"short\"");
+DEFINE_bool(pipe, false, "Send info to stderr, input to stdout");
+DEFINE_bool(test_properties, true,
+ "Compute property values (if unknown to FST)");
+DEFINE_bool(fst_verify, true, "Verify FST sanity");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+
+ string usage = "Prints out information about an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 2) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ s::PrintFstInfo(*ifst, FLAGS_test_properties, FLAGS_arc_filter,
+ FLAGS_info_type, FLAGS_fst_verify, FLAGS_pipe);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Intersects two FSTs.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/getters.h>
+#include <fst/script/intersect.h>
+
+DEFINE_string(compose_filter, "auto",
+ "Composition filter, one of: \"alt_sequence\", \"auto\", "
+ "\"match\", \"null\", \"sequence\", \"trivial\"");
+DEFINE_bool(connect, true, "Trim output");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::ComposeFilter;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Intersects two FSAs.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst [out.fst]\n";
+ usage += " Flags: connect\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+ std::unique_ptr<FstClass> ifst2(FstClass::Read(in2_name));
+ if (!ifst2) return 1;
+
+ VectorFstClass ofst(ifst1->ArcType());
+
+ ComposeFilter compose_filter;
+ if (!s::GetComposeFilter(FLAGS_compose_filter, &compose_filter)) {
+ LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: "
+ << FLAGS_compose_filter;
+ return 1;
+ }
+
+ const fst::IntersectOptions opts(FLAGS_connect, compose_filter);
+
+ s::Intersect(*ifst1, *ifst2, &ofst, opts);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Inverts a transduction.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/invert.h>
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+
+ string usage = "Inverts a transduction.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> fst(MutableFstClass::Read(in_name, true));
+ if (!fst) return 1;
+
+ s::Invert(fst.get());
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/isomorphic.h>
+
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+
+ string usage =
+ "Two FSTs are isomorphic iff the exit status is zero.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc != 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+
+ std::unique_ptr<FstClass> 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;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Applies an operation to each arc of an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/getters.h>
+#include <fst/script/map.h>
+
+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)\", "
+ "\"quantize (--delta)\", \"rmweight\", \"superfinal\", "
+ "\"times (--weight)\", \"to_log\", \"to_log64\", \"to_std\"");
+DEFINE_string(weight, "", "Weight parameter");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::WeightClass;
+
+ string usage = "Applies an operation to each arc of an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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<FstClass> ofst(s::Map(*ifst, map_type, FLAGS_delta,
+ weight_param));
+
+ ofst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Minimizes a deterministic FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/minimize.h>
+
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+DEFINE_bool(allow_nondet, false, "Minimize non-deterministic FSTs");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Minimizes a deterministic FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out1.fst [out2.fst]]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out1_name =
+ (argc > 2 && strcmp(argv[2], "-") != 0) ? argv[2] : "";
+ const string out2_name =
+ (argc > 3 && strcmp(argv[3], "-") != 0) ? argv[3] : "";
+
+ if (out1_name.empty() && out2_name.empty() && argc > 3) {
+ LOG(ERROR) << argv[0] << ": Both outputs can't be standard output.";
+ return 1;
+ }
+
+ std::unique_ptr<MutableFstClass> fst1(MutableFstClass::Read(in_name, true));
+ if (!fst1) return 1;
+
+ if (argc > 3) {
+ std::unique_ptr<MutableFstClass> fst2(new VectorFstClass(fst1->ArcType()));
+ s::Minimize(fst1.get(), fst2.get(), FLAGS_delta, FLAGS_allow_nondet);
+ fst2->Write(out2_name);
+ } else {
+ s::Minimize(fst1.get(), nullptr, FLAGS_delta, FLAGS_allow_nondet);
+ }
+ fst1->Write(out1_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <fstream>
+#include <memory>
+#include <ostream>
+#include <string>
+
+#include <fst/script/print.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::SymbolTable;
+ using fst::SymbolTableTextOptions;
+
+ string usage = "Prints out binary FSTs in simple text format.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [binary.fst [text.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> fst(FstClass::Read(in_name));
+ if (!fst) return 1;
+
+ string dest = "standard output";
+ std::ofstream fstrm;
+ if (argc == 3) {
+ fstrm.open(argv[2]);
+ if (!fstrm) {
+ LOG(ERROR) << argv[0] << ": Open failed, file = " << argv[2];
+ return 1;
+ }
+ dest = argv[2];
+ }
+ std::ostream &ostrm = fstrm.is_open() ? fstrm : std::cout;
+ ostrm.precision(9);
+
+ const SymbolTableTextOptions opts(FLAGS_allow_negative_labels);
+
+ std::unique_ptr<const SymbolTable> isyms;
+ if (!FLAGS_isymbols.empty() && !FLAGS_numeric) {
+ isyms.reset(SymbolTable::ReadText(FLAGS_isymbols, opts));
+ if (!isyms) return 1;
+ }
+
+ std::unique_ptr<const SymbolTable> osyms;
+ if (!FLAGS_osymbols.empty() && !FLAGS_numeric) {
+ osyms.reset(SymbolTable::ReadText(FLAGS_osymbols, opts));
+ if (!osyms) return 1;
+ }
+
+ std::unique_ptr<const SymbolTable> ssyms;
+ if (!FLAGS_ssymbols.empty() && !FLAGS_numeric) {
+ ssyms.reset(SymbolTable::ReadText(FLAGS_ssymbols));
+ if (!ssyms) return 1;
+ }
+
+ if (!isyms && !FLAGS_numeric && fst->InputSymbols()) {
+ isyms.reset(fst->InputSymbols()->Copy());
+ }
+
+ if (!osyms && !FLAGS_numeric && fst->OutputSymbols()) {
+ osyms.reset(fst->OutputSymbols()->Copy());
+ }
+
+ s::PrintFst(*fst, ostrm, dest, isyms.get(), osyms.get(), ssyms.get(),
+ FLAGS_acceptor, FLAGS_show_weight_one, FLAGS_missing_symbol);
+
+ if (isyms && !FLAGS_save_isymbols.empty()) {
+ isyms->WriteText(FLAGS_save_isymbols);
+ }
+
+ if (osyms && !FLAGS_save_osymbols.empty()) {
+ osyms->WriteText(FLAGS_save_osymbols);
+ }
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Projects a transduction onto its input or output language.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/getters.h>
+#include <fst/script/project.h>
+
+DEFINE_bool(project_output, false, "Project on output (vs. input)");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+
+ string usage =
+ "Projects a transduction onto its input"
+ " or output language.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> fst(MutableFstClass::Read(in_name, true));
+ if (!fst) return 1;
+
+ s::Project(fst.get(), s::GetProjectType(FLAGS_project_output));
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/prune.h>
+
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+DEFINE_int64(nstate, fst::kNoStateId, "State number threshold");
+DEFINE_string(weight, "", "Weight threshold");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+ using fst::script::WeightClass;
+
+ string usage = "Prunes states and arcs of an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> 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::PruneOptions opts(weight_threshold, FLAGS_nstate, nullptr, FLAGS_delta);
+
+ s::Prune(fst.get(), opts);
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/getters.h>
+#include <fst/script/push.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Pushes weights and/or olabels in an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Generates random paths through an FST.
+
+#include <unistd.h>
+
+#include <climits>
+#include <cstring>
+#include <ctime>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/getters.h>
+#include <fst/script/randgen.h>
+
+DEFINE_int32(max_length, INT32_MAX, "Maximum path length");
+DEFINE_int32(npath, 1, "Number of paths to generate");
+DEFINE_int32(seed, time(nullptr) + getpid(), "Random seed");
+DEFINE_string(select, "uniform",
+ "Selection type: one of: "
+ " \"uniform\", \"log_prob\" (when appropriate),"
+ " \"fast_log_prob\" (when appropriate)");
+DEFINE_bool(weighted, false,
+ "Output tree weighted by path count vs. unweighted paths");
+DEFINE_bool(remove_total_weight, false,
+ "Remove total weight when output weighted");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Generates random paths through an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ VLOG(1) << argv[0] << ": Seed = " << FLAGS_seed;
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ s::RandArcSelection ras;
+ if (!s::GetRandArcSelection(FLAGS_select, &ras)) {
+ LOG(ERROR) << argv[0] << ": Unknown or unsupported select type "
+ << FLAGS_select;
+ return 1;
+ }
+
+ s::RandGen(*ifst, &ofst, FLAGS_seed,
+ fst::RandGenOptions<s::RandArcSelection>(
+ ras, FLAGS_max_length, FLAGS_npath, FLAGS_weighted,
+ FLAGS_remove_total_weight));
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Relabels input or output space of an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/util.h>
+#include <fst/script/relabel.h>
+#include <fst/script/weight-class.h>
+
+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_bool(allow_negative_labels, false,
+ "Allow negative labels (not recommended; may cause conflicts)");
+
+int main(int argc, char** argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+ using fst::SymbolTable;
+ using fst::SymbolTableTextOptions;
+
+ string usage =
+ "Relabels the input and/or the output labels of the FST.\n\n"
+ " Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+ usage += " Using SymbolTables flags:\n";
+ usage += " -relabel_isymbols isyms.txt\n";
+ usage += " -relabel_osymbols osyms.txt\n";
+ usage += " Using numeric labels flags:\n";
+ usage += " -relabel_ipairs ipairs.txt\n";
+ usage += " -relabel_opairs opairs.txts\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> 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<const SymbolTable> old_isymbols(
+ FLAGS_isymbols.empty() ? nullptr
+ : SymbolTable::ReadText(FLAGS_isymbols, opts));
+ std::unique_ptr<const SymbolTable> relabel_isymbols(
+ FLAGS_relabel_isymbols.empty()
+ ? nullptr
+ : SymbolTable::ReadText(FLAGS_relabel_isymbols, opts));
+ bool attach_new_osymbols = (fst->OutputSymbols() != nullptr);
+ std::unique_ptr<const SymbolTable> old_osymbols(
+ FLAGS_osymbols.empty() ? nullptr
+ : SymbolTable::ReadText(FLAGS_osymbols, opts));
+ std::unique_ptr<const SymbolTable> 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(), attach_new_isymbols,
+ old_osymbols ? old_osymbols.get() : fst->OutputSymbols(),
+ relabel_osymbols.get(), attach_new_osymbols);
+ } else {
+ // Reads in relabeling pairs.
+ std::vector<s::LabelPair> ipairs;
+ std::vector<s::LabelPair> opairs;
+ if (!FLAGS_relabel_ipairs.empty()) {
+ if (!fst::ReadLabelPairs(FLAGS_relabel_ipairs, &ipairs,
+ FLAGS_allow_negative_labels))
+ return 1;
+ }
+ if (!FLAGS_relabel_opairs.empty()) {
+ if (!fst::ReadLabelPairs(FLAGS_relabel_opairs, &opairs,
+ FLAGS_allow_negative_labels))
+ return 1;
+ }
+ s::Relabel(fst.get(), ipairs, opairs);
+ }
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <string>
+#include <vector>
+
+#include <fst/script/getters.h>
+#include <fst/script/replace.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::ReplaceLabelType;
+
+ string usage = "Recursively replaces FST arcs with other FST(s).\n\n"
+ " Usage: ";
+ usage += argv[0];
+ usage += " root.fst rootlabel [rule1.fst label1 ...] [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = argv[1];
+ const string out_name = argc % 2 == 0 ? argv[argc - 1] : "";
+
+ // Replace takes ownership of the pointer of FST arrays, deleting all such
+ // pointers when the underlying ReplaceFst is destroyed.
+ auto *ifst = FstClass::Read(in_name);
+ if (!ifst) return 1;
+
+ std::vector<s::LabelFstClassPair> 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) 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);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Reverses the paths in an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/fst-class.h>
+#include <fst/script/reverse.h>
+
+DEFINE_bool(require_superinitial, true, "Always create a superinitial state");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Reverses the paths in an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ VectorFstClass out(ifst->ArcType());
+
+ s::Reverse(*ifst, &out, FLAGS_require_superinitial);
+
+ out.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Reweights an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/script/getters.h>
+#include <fst/script/reweight.h>
+#include <fst/script/text-io.h>
+
+DEFINE_bool(to_final, false, "Push/reweight to final (vs. to initial) states");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+ using fst::script::WeightClass;
+
+ string usage = "Reweights an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.fst potential.txt [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = argv[1];
+ const string potentials_name = argv[2];
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ std::unique_ptr<MutableFstClass> fst(MutableFstClass::Read(in_name, true));
+ if (!fst) return 1;
+
+ std::vector<WeightClass> potential;
+ if (!s::ReadPotentials(fst->WeightType(), potentials_name, &potential)) {
+ return 1;
+ }
+
+ s::Reweight(fst.get(), potential, s::GetReweightType(FLAGS_to_final));
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Removes epsilons from an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/getters.h>
+#include <fst/script/rmepsilon.h>
+
+DEFINE_bool(connect, true, "Trim output");
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+DEFINE_int64(nstate, fst::kNoStateId, "State number threshold");
+DEFINE_bool(reverse, false, "Perform in the reverse direction");
+DEFINE_string(weight, "", "Weight threshold");
+DEFINE_string(queue_type, "auto",
+ "Queue type: one of: \"auto\", "
+ "\"fifo\", \"lifo\", \"shortest\", \"state\", \"top\"");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::script::WeightClass;
+
+ string usage = "Removes epsilons from an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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);
+
+ fst::QueueType queue_type;
+ if (!s::GetQueueType(FLAGS_queue_type, &queue_type)) {
+ LOG(ERROR) << argv[0]
+ << ": Unknown or unsupported queue type: " << FLAGS_queue_type;
+ return 1;
+ }
+
+ const s::RmEpsilonOptions opts(queue_type, FLAGS_delta, FLAGS_connect,
+ weight_threshold, FLAGS_nstate);
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ s::RmEpsilon(*ifst, &ofst, FLAGS_reverse, opts);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Find shortest distances in an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/script/getters.h>
+#include <fst/script/shortest-distance.h>
+#include <fst/script/text-io.h>
+
+DEFINE_bool(reverse, false, "Perform in the reverse direction");
+DEFINE_double(delta, fst::kDelta, "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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::WeightClass;
+ using fst::QueueType;
+ using fst::AUTO_QUEUE;
+
+ string usage = "Finds shortest distance(s) in an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [distance.txt]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ std::vector<WeightClass> 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);
+ }
+
+ s::WritePotentials(out_name, distance);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Find shortest path(s) in an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/script/getters.h>
+#include <fst/script/shortest-path.h>
+
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+DEFINE_int32(nshortest, 1, "Return N-shortest paths");
+DEFINE_bool(unique, false, "Return unique strings");
+DEFINE_string(weight, "", "Weight threshold");
+DEFINE_int64(nstate, fst::kNoStateId, "State number threshold");
+DEFINE_string(queue_type, "auto",
+ "Queue type: one of \"auto\", "
+ "\"fifo\", \"lifo\", \"shortest\', \"state\", \"top\"");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::WeightClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Finds shortest path(s) in an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ const auto weight_threshold =
+ FLAGS_weight.empty() ? WeightClass::Zero(ifst->WeightType())
+ : WeightClass(ifst->WeightType(), FLAGS_weight);
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ fst::QueueType queue_type;
+ if (!s::GetQueueType(FLAGS_queue_type, &queue_type)) {
+ LOG(ERROR) << "Unknown or unsupported queue type: " << FLAGS_queue_type;
+ return 1;
+ }
+
+ s::ShortestPathOptions opts(queue_type, FLAGS_nshortest, FLAGS_unique, false,
+ FLAGS_delta, false, weight_threshold,
+ FLAGS_nstate);
+
+ std::vector<WeightClass> distance;
+
+ s::ShortestPath(*ifst, &ofst, &distance, opts);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/util.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/verify.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+ using fst::ReadLabelPairs;
+ using fst::SymbolTable;
+ using fst::SymbolTableTextOptions;
+
+ string usage =
+ "Performs operations (set, clear, relabel) on the symbol"
+ " tables attached to an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = argc > 1 && strcmp(argv[1], "-") != 0 ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> 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<SymbolTable> 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<SymbolTable> 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<std::pair<Label, Label>> ipairs;
+ ReadLabelPairs(FLAGS_relabel_ipairs, &ipairs, FLAGS_allow_negative_labels);
+ std::unique_ptr<SymbolTable> isyms_relabel(
+ RelabelSymbolTable(fst->InputSymbols(), ipairs));
+ fst->SetInputSymbols(isyms_relabel.get());
+ }
+ if (!FLAGS_relabel_opairs.empty()) {
+ std::vector<std::pair<Label, Label>> opairs;
+ ReadLabelPairs(FLAGS_relabel_opairs, &opairs, FLAGS_allow_negative_labels);
+ std::unique_ptr<SymbolTable> osyms_relabel(
+ RelabelSymbolTable(fst->OutputSymbols(), opairs));
+ fst->SetOutputSymbols(osyms_relabel.get());
+ }
+
+ if (FLAGS_verify && !s::Verify(*fst)) return 1;
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Synchronizes an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/synchronize.h>
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Synchronizes an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = (argc > 1 && strcmp(argv[1], "-") != 0) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> ifst(FstClass::Read(in_name));
+ if (!ifst) return 1;
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ s::Synchronize(*ifst, &ofst);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Topologically sorts an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/topsort.h>
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::MutableFstClass;
+
+ string usage = "Topologically sorts an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = argc > 1 && strcmp(argv[1], "-") != 0 ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<MutableFstClass> fst(MutableFstClass::Read(in_name, true));
+ if (!fst) return 1;
+
+ bool acyclic = TopSort(fst.get());
+
+ if (!acyclic) LOG(WARNING) << argv[0] << ": Input FST is cyclic";
+
+ fst->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Creates the union of two FSTs.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+
+#include <fst/script/union.h>
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::MutableFstClass;
+
+ string usage = "Creates the union of two FSTs.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in1.fst in2.fst [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") != 0 ? argv[1] : "";
+ const string in2_name = strcmp(argv[2], "-") != 0 ? argv[2] : "";
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ if (in1_name == "" && in2_name == "") {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input";
+ return 1;
+ }
+
+ std::unique_ptr<MutableFstClass> fst1(MutableFstClass::Read(in1_name, true));
+ if (!fst1) return 1;
+
+ std::unique_ptr<FstClass> fst2(FstClass::Read(in2_name));
+ if (!fst2) return 1;
+
+ s::Union(fst1.get(), *fst2);
+
+ fst1->Write(out_name);
+
+ return 0;
+}
--- /dev/null
+if HAVE_COMPACT
+compactdir = compact
+endif
+
+if HAVE_COMPRESS
+compressdir = compress
+endif
+
+if HAVE_CONST
+constdir = const
+endif
+
+if HAVE_FAR
+fardir = far
+endif
+
+if HAVE_GRM
+fardir = far
+pdtdir = pdt
+mpdtdir = mpdt
+endif
+
+if HAVE_LINEAR
+lineardir = linear
+endif
+
+if HAVE_LOOKAHEAD
+lookaheaddir = lookahead
+endif
+
+if HAVE_MPDT
+pdtdir = pdt
+mpdtdir = mpdt
+endif
+
+if HAVE_NGRAM
+ngramdir = ngram
+endif
+
+if HAVE_PYTHON
+fardir = far
+pywrapfstdir = python
+endif
+
+if HAVE_PDT
+pdtdir = pdt
+endif
+
+if HAVE_SPECIAL
+specialdir = special
+endif
+
+SUBDIRS = $(compactdir) $(compressdir) $(constdir) $(fardir) $(lineardir) \
+ $(lookaheaddir) $(pdtdir) $(mpdtdir) $(ngramdir) $(pywrapfstdir) \
+ $(specialdir)
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/extensions
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+SOURCES =
+DIST_SOURCES =
+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
+ ctags-recursive dvi-recursive html-recursive info-recursive \
+ install-data-recursive install-dvi-recursive \
+ install-exec-recursive install-html-recursive \
+ install-info-recursive install-pdf-recursive \
+ install-ps-recursive install-recursive installcheck-recursive \
+ installdirs-recursive pdf-recursive ps-recursive \
+ tags-recursive uninstall-recursive
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
+ distclean-recursive maintainer-clean-recursive
+am__recursive_targets = \
+ $(RECURSIVE_TARGETS) \
+ $(RECURSIVE_CLEAN_TARGETS) \
+ $(am__extra_recursive_targets)
+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
+ distdir
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DIST_SUBDIRS = compact compress const far linear lookahead pdt mpdt \
+ ngram python special
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+am__relativize = \
+ dir0=`pwd`; \
+ sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+ sed_rest='s,^[^/]*/*,,'; \
+ sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+ sed_butlast='s,/*[^/]*$$,,'; \
+ while test -n "$$dir1"; do \
+ first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+ if test "$$first" != "."; then \
+ if test "$$first" = ".."; then \
+ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+ else \
+ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+ if test "$$first2" = "$$first"; then \
+ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+ else \
+ dir2="../$$dir2"; \
+ fi; \
+ dir0="$$dir0"/"$$first"; \
+ fi; \
+ fi; \
+ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+ done; \
+ reldir="$$dir2"
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+@HAVE_COMPACT_TRUE@compactdir = compact
+@HAVE_COMPRESS_TRUE@compressdir = compress
+@HAVE_CONST_TRUE@constdir = const
+@HAVE_FAR_TRUE@fardir = far
+@HAVE_GRM_TRUE@fardir = far
+@HAVE_PYTHON_TRUE@fardir = far
+@HAVE_GRM_TRUE@pdtdir = pdt
+@HAVE_MPDT_TRUE@pdtdir = pdt
+@HAVE_PDT_TRUE@pdtdir = pdt
+@HAVE_GRM_TRUE@mpdtdir = mpdt
+@HAVE_MPDT_TRUE@mpdtdir = mpdt
+@HAVE_LINEAR_TRUE@lineardir = linear
+@HAVE_LOOKAHEAD_TRUE@lookaheaddir = lookahead
+@HAVE_NGRAM_TRUE@ngramdir = ngram
+@HAVE_PYTHON_TRUE@pywrapfstdir = python
+@HAVE_SPECIAL_TRUE@specialdir = special
+SUBDIRS = $(compactdir) $(compressdir) $(constdir) $(fardir) $(lineardir) \
+ $(lookaheaddir) $(pdtdir) $(mpdtdir) $(ngramdir) $(pywrapfstdir) \
+ $(specialdir)
+
+all: all-recursive
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run 'make' without going through this Makefile.
+# To change the values of 'make' variables: instead of editing Makefiles,
+# (1) if the variable is set in 'config.status', edit 'config.status'
+# (which will cause the Makefiles to be regenerated when you run 'make');
+# (2) otherwise, pass the desired values on the 'make' command line.
+$(am__recursive_targets):
+ @fail=; \
+ if $(am__make_keepgoing); then \
+ failcom='fail=yes'; \
+ else \
+ failcom='exit 1'; \
+ fi; \
+ dot_seen=no; \
+ target=`echo $@ | sed s/-recursive//`; \
+ case "$@" in \
+ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+ *) list='$(SUBDIRS)' ;; \
+ esac; \
+ for subdir in $$list; do \
+ echo "Making $$target in $$subdir"; \
+ if test "$$subdir" = "."; then \
+ dot_seen=yes; \
+ local_target="$$target-am"; \
+ else \
+ local_target="$$target"; \
+ fi; \
+ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+ || eval $$failcom; \
+ done; \
+ if test "$$dot_seen" = "no"; then \
+ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+ fi; test -z "$$fail"
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-recursive
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+ include_option=--etags-include; \
+ empty_fix=.; \
+ else \
+ include_option=--include; \
+ empty_fix=; \
+ fi; \
+ list='$(SUBDIRS)'; for subdir in $$list; do \
+ if test "$$subdir" = .; then :; else \
+ test ! -f $$subdir/TAGS || \
+ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+ fi; \
+ done; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-recursive
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-recursive
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+ @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+ if test "$$subdir" = .; then :; else \
+ $(am__make_dryrun) \
+ || test -d "$(distdir)/$$subdir" \
+ || $(MKDIR_P) "$(distdir)/$$subdir" \
+ || exit 1; \
+ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+ $(am__relativize); \
+ new_distdir=$$reldir; \
+ dir1=$$subdir; dir2="$(top_distdir)"; \
+ $(am__relativize); \
+ new_top_distdir=$$reldir; \
+ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+ ($(am__cd) $$subdir && \
+ $(MAKE) $(AM_MAKEFLAGS) \
+ top_distdir="$$new_top_distdir" \
+ distdir="$$new_distdir" \
+ am__remove_distdir=: \
+ am__skip_length_check=: \
+ am__skip_mode_fix=: \
+ distdir) \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-recursive
+all-am: Makefile
+installdirs: installdirs-recursive
+installdirs-am:
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-recursive
+ -rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: $(am__recursive_targets) install-am install-strip
+
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \
+ check-am clean clean-generic clean-libtool cscopelist-am ctags \
+ ctags-am distclean distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am html html-am info info-am \
+ install install-am install-data install-data-am install-dvi \
+ install-dvi-am install-exec install-exec-am install-html \
+ install-html-am install-info install-info-am install-man \
+ install-pdf install-pdf-am install-ps install-ps-am \
+ install-strip installcheck installcheck-am installdirs \
+ installdirs-am maintainer-clean maintainer-clean-generic \
+ mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
+ ps ps-am tags tags-am uninstall uninstall-am
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+libfstdir = @libfstdir@
+libfst_LTLIBRARIES = compact8_acceptor-fst.la compact8_string-fst.la compact8_unweighted-fst.la compact8_unweighted_acceptor-fst.la compact8_weighted_string-fst.la compact16_acceptor-fst.la compact16_string-fst.la compact16_unweighted-fst.la compact16_unweighted_acceptor-fst.la compact16_weighted_string-fst.la compact64_acceptor-fst.la compact64_string-fst.la compact64_unweighted-fst.la compact64_unweighted_acceptor-fst.la compact64_weighted_string-fst.la
+
+lib_LTLIBRARIES = libfstcompact.la
+
+libfstcompact_la_SOURCES = compact8_acceptor-fst.cc compact8_string-fst.cc compact8_unweighted-fst.cc compact8_unweighted_acceptor-fst.cc compact8_weighted_string-fst.cc compact16_acceptor-fst.cc compact16_string-fst.cc compact16_unweighted-fst.cc compact16_unweighted_acceptor-fst.cc compact16_weighted_string-fst.cc compact64_acceptor-fst.cc compact64_string-fst.cc compact64_unweighted-fst.cc compact64_unweighted_acceptor-fst.cc compact64_weighted_string-fst.cc
+libfstcompact_la_LDFLAGS = -version-info 6:0:0
+libfstcompact_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+
+compact8_acceptor_fst_la_SOURCES = compact8_acceptor-fst.cc
+compact8_acceptor_fst_la_LDFLAGS = -module
+
+compact8_string_fst_la_SOURCES = compact8_string-fst.cc
+compact8_string_fst_la_LDFLAGS = -module
+
+compact8_unweighted_fst_la_SOURCES = compact8_unweighted-fst.cc
+compact8_unweighted_fst_la_LDFLAGS = -module
+
+compact8_unweighted_acceptor_fst_la_SOURCES = compact8_unweighted_acceptor-fst.cc
+compact8_unweighted_acceptor_fst_la_LDFLAGS = -module
+
+compact8_weighted_string_fst_la_SOURCES = compact8_weighted_string-fst.cc
+compact8_weighted_string_fst_la_LDFLAGS = -module
+
+compact16_acceptor_fst_la_SOURCES = compact16_acceptor-fst.cc
+compact16_acceptor_fst_la_LDFLAGS = -module
+
+compact16_string_fst_la_SOURCES = compact16_string-fst.cc
+compact16_string_fst_la_LDFLAGS = -module
+
+compact16_unweighted_fst_la_SOURCES = compact16_unweighted-fst.cc
+compact16_unweighted_fst_la_LDFLAGS = -module
+
+compact16_unweighted_acceptor_fst_la_SOURCES = compact16_unweighted_acceptor-fst.cc
+compact16_unweighted_acceptor_fst_la_LDFLAGS = -module
+
+compact16_weighted_string_fst_la_SOURCES = compact16_weighted_string-fst.cc
+compact16_weighted_string_fst_la_LDFLAGS = -module
+
+compact64_acceptor_fst_la_SOURCES = compact64_acceptor-fst.cc
+compact64_acceptor_fst_la_LDFLAGS = -module
+
+compact64_string_fst_la_SOURCES = compact64_string-fst.cc
+compact64_string_fst_la_LDFLAGS = -module
+
+compact64_unweighted_fst_la_SOURCES = compact64_unweighted-fst.cc
+compact64_unweighted_fst_la_LDFLAGS = -module
+
+compact64_unweighted_acceptor_fst_la_SOURCES = compact64_unweighted_acceptor-fst.cc
+compact64_unweighted_acceptor_fst_la_LDFLAGS = -module
+
+compact64_weighted_string_fst_la_SOURCES = compact64_weighted_string-fst.cc
+compact64_weighted_string_fst_la_LDFLAGS = -module
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/extensions/compact
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES)
+compact16_acceptor_fst_la_LIBADD =
+am_compact16_acceptor_fst_la_OBJECTS = compact16_acceptor-fst.lo
+compact16_acceptor_fst_la_OBJECTS = \
+ $(am_compact16_acceptor_fst_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+compact16_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact16_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+compact16_string_fst_la_LIBADD =
+am_compact16_string_fst_la_OBJECTS = compact16_string-fst.lo
+compact16_string_fst_la_OBJECTS = \
+ $(am_compact16_string_fst_la_OBJECTS)
+compact16_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(compact16_string_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+compact16_unweighted_fst_la_LIBADD =
+am_compact16_unweighted_fst_la_OBJECTS = compact16_unweighted-fst.lo
+compact16_unweighted_fst_la_OBJECTS = \
+ $(am_compact16_unweighted_fst_la_OBJECTS)
+compact16_unweighted_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact16_unweighted_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+compact16_unweighted_acceptor_fst_la_LIBADD =
+am_compact16_unweighted_acceptor_fst_la_OBJECTS = \
+ compact16_unweighted_acceptor-fst.lo
+compact16_unweighted_acceptor_fst_la_OBJECTS = \
+ $(am_compact16_unweighted_acceptor_fst_la_OBJECTS)
+compact16_unweighted_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \
+ --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \
+ $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact16_unweighted_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o \
+ $@
+compact16_weighted_string_fst_la_LIBADD =
+am_compact16_weighted_string_fst_la_OBJECTS = \
+ compact16_weighted_string-fst.lo
+compact16_weighted_string_fst_la_OBJECTS = \
+ $(am_compact16_weighted_string_fst_la_OBJECTS)
+compact16_weighted_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \
+ --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \
+ $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact16_weighted_string_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+compact64_acceptor_fst_la_LIBADD =
+am_compact64_acceptor_fst_la_OBJECTS = compact64_acceptor-fst.lo
+compact64_acceptor_fst_la_OBJECTS = \
+ $(am_compact64_acceptor_fst_la_OBJECTS)
+compact64_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact64_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+compact64_string_fst_la_LIBADD =
+am_compact64_string_fst_la_OBJECTS = compact64_string-fst.lo
+compact64_string_fst_la_OBJECTS = \
+ $(am_compact64_string_fst_la_OBJECTS)
+compact64_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(compact64_string_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+compact64_unweighted_fst_la_LIBADD =
+am_compact64_unweighted_fst_la_OBJECTS = compact64_unweighted-fst.lo
+compact64_unweighted_fst_la_OBJECTS = \
+ $(am_compact64_unweighted_fst_la_OBJECTS)
+compact64_unweighted_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact64_unweighted_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+compact64_unweighted_acceptor_fst_la_LIBADD =
+am_compact64_unweighted_acceptor_fst_la_OBJECTS = \
+ compact64_unweighted_acceptor-fst.lo
+compact64_unweighted_acceptor_fst_la_OBJECTS = \
+ $(am_compact64_unweighted_acceptor_fst_la_OBJECTS)
+compact64_unweighted_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \
+ --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \
+ $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact64_unweighted_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o \
+ $@
+compact64_weighted_string_fst_la_LIBADD =
+am_compact64_weighted_string_fst_la_OBJECTS = \
+ compact64_weighted_string-fst.lo
+compact64_weighted_string_fst_la_OBJECTS = \
+ $(am_compact64_weighted_string_fst_la_OBJECTS)
+compact64_weighted_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \
+ --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \
+ $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact64_weighted_string_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+compact8_acceptor_fst_la_LIBADD =
+am_compact8_acceptor_fst_la_OBJECTS = compact8_acceptor-fst.lo
+compact8_acceptor_fst_la_OBJECTS = \
+ $(am_compact8_acceptor_fst_la_OBJECTS)
+compact8_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(compact8_acceptor_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+compact8_string_fst_la_LIBADD =
+am_compact8_string_fst_la_OBJECTS = compact8_string-fst.lo
+compact8_string_fst_la_OBJECTS = $(am_compact8_string_fst_la_OBJECTS)
+compact8_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(compact8_string_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+compact8_unweighted_fst_la_LIBADD =
+am_compact8_unweighted_fst_la_OBJECTS = compact8_unweighted-fst.lo
+compact8_unweighted_fst_la_OBJECTS = \
+ $(am_compact8_unweighted_fst_la_OBJECTS)
+compact8_unweighted_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact8_unweighted_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+compact8_unweighted_acceptor_fst_la_LIBADD =
+am_compact8_unweighted_acceptor_fst_la_OBJECTS = \
+ compact8_unweighted_acceptor-fst.lo
+compact8_unweighted_acceptor_fst_la_OBJECTS = \
+ $(am_compact8_unweighted_acceptor_fst_la_OBJECTS)
+compact8_unweighted_acceptor_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) \
+ --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link \
+ $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact8_unweighted_acceptor_fst_la_LDFLAGS) $(LDFLAGS) -o \
+ $@
+compact8_weighted_string_fst_la_LIBADD =
+am_compact8_weighted_string_fst_la_OBJECTS = \
+ compact8_weighted_string-fst.lo
+compact8_weighted_string_fst_la_OBJECTS = \
+ $(am_compact8_weighted_string_fst_la_OBJECTS)
+compact8_weighted_string_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) \
+ $(compact8_weighted_string_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+am__DEPENDENCIES_1 =
+libfstcompact_la_DEPENDENCIES = ../../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+am_libfstcompact_la_OBJECTS = compact8_acceptor-fst.lo \
+ compact8_string-fst.lo compact8_unweighted-fst.lo \
+ compact8_unweighted_acceptor-fst.lo \
+ compact8_weighted_string-fst.lo compact16_acceptor-fst.lo \
+ compact16_string-fst.lo compact16_unweighted-fst.lo \
+ compact16_unweighted_acceptor-fst.lo \
+ compact16_weighted_string-fst.lo compact64_acceptor-fst.lo \
+ compact64_string-fst.lo compact64_unweighted-fst.lo \
+ compact64_unweighted_acceptor-fst.lo \
+ compact64_weighted_string-fst.lo
+libfstcompact_la_OBJECTS = $(am_libfstcompact_la_OBJECTS)
+libfstcompact_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstcompact_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(compact16_acceptor_fst_la_SOURCES) \
+ $(compact16_string_fst_la_SOURCES) \
+ $(compact16_unweighted_fst_la_SOURCES) \
+ $(compact16_unweighted_acceptor_fst_la_SOURCES) \
+ $(compact16_weighted_string_fst_la_SOURCES) \
+ $(compact64_acceptor_fst_la_SOURCES) \
+ $(compact64_string_fst_la_SOURCES) \
+ $(compact64_unweighted_fst_la_SOURCES) \
+ $(compact64_unweighted_acceptor_fst_la_SOURCES) \
+ $(compact64_weighted_string_fst_la_SOURCES) \
+ $(compact8_acceptor_fst_la_SOURCES) \
+ $(compact8_string_fst_la_SOURCES) \
+ $(compact8_unweighted_fst_la_SOURCES) \
+ $(compact8_unweighted_acceptor_fst_la_SOURCES) \
+ $(compact8_weighted_string_fst_la_SOURCES) \
+ $(libfstcompact_la_SOURCES)
+DIST_SOURCES = $(compact16_acceptor_fst_la_SOURCES) \
+ $(compact16_string_fst_la_SOURCES) \
+ $(compact16_unweighted_fst_la_SOURCES) \
+ $(compact16_unweighted_acceptor_fst_la_SOURCES) \
+ $(compact16_weighted_string_fst_la_SOURCES) \
+ $(compact64_acceptor_fst_la_SOURCES) \
+ $(compact64_string_fst_la_SOURCES) \
+ $(compact64_unweighted_fst_la_SOURCES) \
+ $(compact64_unweighted_acceptor_fst_la_SOURCES) \
+ $(compact64_weighted_string_fst_la_SOURCES) \
+ $(compact8_acceptor_fst_la_SOURCES) \
+ $(compact8_string_fst_la_SOURCES) \
+ $(compact8_unweighted_fst_la_SOURCES) \
+ $(compact8_unweighted_acceptor_fst_la_SOURCES) \
+ $(compact8_weighted_string_fst_la_SOURCES) \
+ $(libfstcompact_la_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+libfst_LTLIBRARIES = compact8_acceptor-fst.la compact8_string-fst.la compact8_unweighted-fst.la compact8_unweighted_acceptor-fst.la compact8_weighted_string-fst.la compact16_acceptor-fst.la compact16_string-fst.la compact16_unweighted-fst.la compact16_unweighted_acceptor-fst.la compact16_weighted_string-fst.la compact64_acceptor-fst.la compact64_string-fst.la compact64_unweighted-fst.la compact64_unweighted_acceptor-fst.la compact64_weighted_string-fst.la
+lib_LTLIBRARIES = libfstcompact.la
+libfstcompact_la_SOURCES = compact8_acceptor-fst.cc compact8_string-fst.cc compact8_unweighted-fst.cc compact8_unweighted_acceptor-fst.cc compact8_weighted_string-fst.cc compact16_acceptor-fst.cc compact16_string-fst.cc compact16_unweighted-fst.cc compact16_unweighted_acceptor-fst.cc compact16_weighted_string-fst.cc compact64_acceptor-fst.cc compact64_string-fst.cc compact64_unweighted-fst.cc compact64_unweighted_acceptor-fst.cc compact64_weighted_string-fst.cc
+libfstcompact_la_LDFLAGS = -version-info 6:0:0
+libfstcompact_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+compact8_acceptor_fst_la_SOURCES = compact8_acceptor-fst.cc
+compact8_acceptor_fst_la_LDFLAGS = -module
+compact8_string_fst_la_SOURCES = compact8_string-fst.cc
+compact8_string_fst_la_LDFLAGS = -module
+compact8_unweighted_fst_la_SOURCES = compact8_unweighted-fst.cc
+compact8_unweighted_fst_la_LDFLAGS = -module
+compact8_unweighted_acceptor_fst_la_SOURCES = compact8_unweighted_acceptor-fst.cc
+compact8_unweighted_acceptor_fst_la_LDFLAGS = -module
+compact8_weighted_string_fst_la_SOURCES = compact8_weighted_string-fst.cc
+compact8_weighted_string_fst_la_LDFLAGS = -module
+compact16_acceptor_fst_la_SOURCES = compact16_acceptor-fst.cc
+compact16_acceptor_fst_la_LDFLAGS = -module
+compact16_string_fst_la_SOURCES = compact16_string-fst.cc
+compact16_string_fst_la_LDFLAGS = -module
+compact16_unweighted_fst_la_SOURCES = compact16_unweighted-fst.cc
+compact16_unweighted_fst_la_LDFLAGS = -module
+compact16_unweighted_acceptor_fst_la_SOURCES = compact16_unweighted_acceptor-fst.cc
+compact16_unweighted_acceptor_fst_la_LDFLAGS = -module
+compact16_weighted_string_fst_la_SOURCES = compact16_weighted_string-fst.cc
+compact16_weighted_string_fst_la_LDFLAGS = -module
+compact64_acceptor_fst_la_SOURCES = compact64_acceptor-fst.cc
+compact64_acceptor_fst_la_LDFLAGS = -module
+compact64_string_fst_la_SOURCES = compact64_string-fst.cc
+compact64_string_fst_la_LDFLAGS = -module
+compact64_unweighted_fst_la_SOURCES = compact64_unweighted-fst.cc
+compact64_unweighted_fst_la_LDFLAGS = -module
+compact64_unweighted_acceptor_fst_la_SOURCES = compact64_unweighted_acceptor-fst.cc
+compact64_unweighted_acceptor_fst_la_LDFLAGS = -module
+compact64_weighted_string_fst_la_SOURCES = compact64_weighted_string-fst.cc
+compact64_weighted_string_fst_la_LDFLAGS = -module
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/compact/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/compact/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \
+ }
+
+uninstall-libfstLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \
+ done
+
+clean-libfstLTLIBRARIES:
+ -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES)
+ @list='$(libfst_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+compact16_acceptor-fst.la: $(compact16_acceptor_fst_la_OBJECTS) $(compact16_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact16_acceptor_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact16_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact16_acceptor_fst_la_OBJECTS) $(compact16_acceptor_fst_la_LIBADD) $(LIBS)
+
+compact16_string-fst.la: $(compact16_string_fst_la_OBJECTS) $(compact16_string_fst_la_DEPENDENCIES) $(EXTRA_compact16_string_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact16_string_fst_la_LINK) -rpath $(libfstdir) $(compact16_string_fst_la_OBJECTS) $(compact16_string_fst_la_LIBADD) $(LIBS)
+
+compact16_unweighted-fst.la: $(compact16_unweighted_fst_la_OBJECTS) $(compact16_unweighted_fst_la_DEPENDENCIES) $(EXTRA_compact16_unweighted_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact16_unweighted_fst_la_LINK) -rpath $(libfstdir) $(compact16_unweighted_fst_la_OBJECTS) $(compact16_unweighted_fst_la_LIBADD) $(LIBS)
+
+compact16_unweighted_acceptor-fst.la: $(compact16_unweighted_acceptor_fst_la_OBJECTS) $(compact16_unweighted_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact16_unweighted_acceptor_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact16_unweighted_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact16_unweighted_acceptor_fst_la_OBJECTS) $(compact16_unweighted_acceptor_fst_la_LIBADD) $(LIBS)
+
+compact16_weighted_string-fst.la: $(compact16_weighted_string_fst_la_OBJECTS) $(compact16_weighted_string_fst_la_DEPENDENCIES) $(EXTRA_compact16_weighted_string_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact16_weighted_string_fst_la_LINK) -rpath $(libfstdir) $(compact16_weighted_string_fst_la_OBJECTS) $(compact16_weighted_string_fst_la_LIBADD) $(LIBS)
+
+compact64_acceptor-fst.la: $(compact64_acceptor_fst_la_OBJECTS) $(compact64_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact64_acceptor_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact64_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact64_acceptor_fst_la_OBJECTS) $(compact64_acceptor_fst_la_LIBADD) $(LIBS)
+
+compact64_string-fst.la: $(compact64_string_fst_la_OBJECTS) $(compact64_string_fst_la_DEPENDENCIES) $(EXTRA_compact64_string_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact64_string_fst_la_LINK) -rpath $(libfstdir) $(compact64_string_fst_la_OBJECTS) $(compact64_string_fst_la_LIBADD) $(LIBS)
+
+compact64_unweighted-fst.la: $(compact64_unweighted_fst_la_OBJECTS) $(compact64_unweighted_fst_la_DEPENDENCIES) $(EXTRA_compact64_unweighted_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact64_unweighted_fst_la_LINK) -rpath $(libfstdir) $(compact64_unweighted_fst_la_OBJECTS) $(compact64_unweighted_fst_la_LIBADD) $(LIBS)
+
+compact64_unweighted_acceptor-fst.la: $(compact64_unweighted_acceptor_fst_la_OBJECTS) $(compact64_unweighted_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact64_unweighted_acceptor_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact64_unweighted_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact64_unweighted_acceptor_fst_la_OBJECTS) $(compact64_unweighted_acceptor_fst_la_LIBADD) $(LIBS)
+
+compact64_weighted_string-fst.la: $(compact64_weighted_string_fst_la_OBJECTS) $(compact64_weighted_string_fst_la_DEPENDENCIES) $(EXTRA_compact64_weighted_string_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact64_weighted_string_fst_la_LINK) -rpath $(libfstdir) $(compact64_weighted_string_fst_la_OBJECTS) $(compact64_weighted_string_fst_la_LIBADD) $(LIBS)
+
+compact8_acceptor-fst.la: $(compact8_acceptor_fst_la_OBJECTS) $(compact8_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact8_acceptor_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact8_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact8_acceptor_fst_la_OBJECTS) $(compact8_acceptor_fst_la_LIBADD) $(LIBS)
+
+compact8_string-fst.la: $(compact8_string_fst_la_OBJECTS) $(compact8_string_fst_la_DEPENDENCIES) $(EXTRA_compact8_string_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact8_string_fst_la_LINK) -rpath $(libfstdir) $(compact8_string_fst_la_OBJECTS) $(compact8_string_fst_la_LIBADD) $(LIBS)
+
+compact8_unweighted-fst.la: $(compact8_unweighted_fst_la_OBJECTS) $(compact8_unweighted_fst_la_DEPENDENCIES) $(EXTRA_compact8_unweighted_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact8_unweighted_fst_la_LINK) -rpath $(libfstdir) $(compact8_unweighted_fst_la_OBJECTS) $(compact8_unweighted_fst_la_LIBADD) $(LIBS)
+
+compact8_unweighted_acceptor-fst.la: $(compact8_unweighted_acceptor_fst_la_OBJECTS) $(compact8_unweighted_acceptor_fst_la_DEPENDENCIES) $(EXTRA_compact8_unweighted_acceptor_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact8_unweighted_acceptor_fst_la_LINK) -rpath $(libfstdir) $(compact8_unweighted_acceptor_fst_la_OBJECTS) $(compact8_unweighted_acceptor_fst_la_LIBADD) $(LIBS)
+
+compact8_weighted_string-fst.la: $(compact8_weighted_string_fst_la_OBJECTS) $(compact8_weighted_string_fst_la_DEPENDENCIES) $(EXTRA_compact8_weighted_string_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(compact8_weighted_string_fst_la_LINK) -rpath $(libfstdir) $(compact8_weighted_string_fst_la_OBJECTS) $(compact8_weighted_string_fst_la_LIBADD) $(LIBS)
+
+libfstcompact.la: $(libfstcompact_la_OBJECTS) $(libfstcompact_la_DEPENDENCIES) $(EXTRA_libfstcompact_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstcompact_la_LINK) -rpath $(libdir) $(libfstcompact_la_OBJECTS) $(libfstcompact_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_acceptor-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_string-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_unweighted-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_unweighted_acceptor-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact16_weighted_string-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_acceptor-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_string-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_unweighted-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_unweighted_acceptor-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact64_weighted_string-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_acceptor-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_string-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_unweighted-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_unweighted_acceptor-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compact8_weighted_string-fst.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-libfstLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \
+ cscopelist-am ctags ctags-am distclean distclean-compile \
+ distclean-generic distclean-libtool distclean-tags distdir dvi \
+ dvi-am html html-am info info-am install install-am \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-libLTLIBRARIES \
+ install-libfstLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \
+ uninstall-libfstLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactAcceptorFst<StdArc, uint16>>
+ CompactAcceptorFst_StdArc_uint16_registerer;
+static FstRegisterer<CompactAcceptorFst<LogArc, uint16>>
+ CompactAcceptorFst_LogArc_uint16_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactStringFst<StdArc, uint16>>
+ CompactStringFst_StdArc_uint16_registerer;
+static FstRegisterer<CompactStringFst<LogArc, uint16>>
+ CompactStringFst_LogArc_uint16_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactUnweightedFst<StdArc, uint16>>
+ CompactUnweightedFst_StdArc_uint16_registerer;
+static FstRegisterer<CompactUnweightedFst<LogArc, uint16>>
+ CompactUnweightedFst_LogArc_uint16_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<
+ CompactUnweightedAcceptorFst<StdArc, uint16>>
+ CompactUnweightedAcceptorFst_StdArc_uint16_registerer;
+static FstRegisterer<
+ CompactUnweightedAcceptorFst<LogArc, uint16>>
+ CompactUnweightedAcceptorFst_LogArc_uint16_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<
+ CompactWeightedStringFst<StdArc, uint16>>
+ CompactWeightedStringFst_StdArc_uint16_registerer;
+
+static FstRegisterer<
+ CompactWeightedStringFst<LogArc, uint16>>
+ CompactWeightedStringFst_LogArc_uint16_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactAcceptorFst<StdArc, uint64>>
+ CompactAcceptorFst_StdArc_uint64_registerer;
+
+static FstRegisterer<CompactAcceptorFst<LogArc, uint64>>
+ CompactAcceptorFst_LogArc_uint64_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactStringFst<StdArc, uint64>>
+ CompactStringFst_StdArc_uint64_registerer;
+static FstRegisterer<CompactStringFst<LogArc, uint64>>
+ CompactStringFst_LogArc_uint64_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactUnweightedFst<StdArc, uint64>>
+ CompactUnweightedFst_StdArc_uint64_registerer;
+static FstRegisterer<CompactUnweightedFst<LogArc, uint64>>
+ CompactUnweightedFst_LogArc_uint64_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<
+ CompactUnweightedAcceptorFst<StdArc, uint64>>
+ CompactUnweightedAcceptorFst_StdArc_uint64_registerer;
+static FstRegisterer<
+ CompactUnweightedAcceptorFst<LogArc, uint64>>
+ CompactUnweightedAcceptorFst_LogArc_uint64_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<
+ CompactWeightedStringFst<StdArc, uint64>>
+ CompactWeightedStringFst_StdArc_uint64_registerer;
+static FstRegisterer<
+ CompactWeightedStringFst<LogArc, uint64>>
+ CompactWeightedStringFst_LogArc_uint64_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactAcceptorFst<StdArc, uint8>>
+ CompactAcceptorFst_StdArc_uint8_registerer;
+static FstRegisterer<CompactAcceptorFst<LogArc, uint8>>
+ CompactAcceptorFst_LogArc_uint8_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactStringFst<StdArc, uint8>>
+ CompactStringFst_StdArc_uint8_registerer;
+static FstRegisterer<CompactStringFst<LogArc, uint8>>
+ CompactStringFst_LogArc_uint8_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<CompactUnweightedFst<StdArc, uint8>>
+ CompactUnweightedFst_StdArc_uint8_registerer;
+static FstRegisterer<CompactUnweightedFst<LogArc, uint8>>
+ CompactUnweightedFst_LogArc_uint8_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<
+ CompactUnweightedAcceptorFst<StdArc, uint8>>
+ CompactUnweightedAcceptorFst_StdArc_uint8_registerer;
+static FstRegisterer<
+ CompactUnweightedAcceptorFst<LogArc, uint8>>
+ CompactUnweightedAcceptorFst_LogArc_uint8_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/compact-fst.h>
+
+namespace fst {
+
+static FstRegisterer<
+ CompactWeightedStringFst<StdArc, uint8>>
+ CompactWeightedStringFst_StdArc_uint8_registerer;
+static FstRegisterer<
+ CompactWeightedStringFst<LogArc, uint8>>
+ CompactWeightedStringFst_LogArc_uint8_registerer;
+
+} // namespace fst
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+if HAVE_BIN
+bin_PROGRAMS = fstcompress fstrandmod
+
+LDADD = libfstcompressscript.la \
+ ../../script/libfstscript.la \
+ ../../lib/libfst.la \
+ -lm $(DL_LIBS)
+
+fstcompress_SOURCES = fstcompress.cc
+fstrandmod_SOURCES = fstrandmod.cc
+endif
+
+if HAVE_SCRIPT
+libfstcompressscript_la_SOURCES = compress-script.cc
+libfstcompressscript_la_LDFLAGS = -version-info 6:0:0
+libfstcompressscript_la_LIBADD = \
+ ../../script/libfstscript.la \
+ ../../lib/libfst.la -lz -lm $(DL_LIBS)
+endif
+
+if HAVE_SCRIPT
+lib_LTLIBRARIES = libfstcompressscript.la
+endif
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@HAVE_BIN_TRUE@bin_PROGRAMS = fstcompress$(EXEEXT) fstrandmod$(EXEEXT)
+subdir = src/extensions/compress
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+@HAVE_SCRIPT_TRUE@libfstcompressscript_la_DEPENDENCIES = \
+@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__libfstcompressscript_la_SOURCES_DIST = compress-script.cc
+@HAVE_SCRIPT_TRUE@am_libfstcompressscript_la_OBJECTS = \
+@HAVE_SCRIPT_TRUE@ compress-script.lo
+libfstcompressscript_la_OBJECTS = \
+ $(am_libfstcompressscript_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstcompressscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstcompressscript_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_TRUE@am_libfstcompressscript_la_rpath = -rpath $(libdir)
+PROGRAMS = $(bin_PROGRAMS)
+am__fstcompress_SOURCES_DIST = fstcompress.cc
+@HAVE_BIN_TRUE@am_fstcompress_OBJECTS = fstcompress.$(OBJEXT)
+fstcompress_OBJECTS = $(am_fstcompress_OBJECTS)
+fstcompress_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@fstcompress_DEPENDENCIES = libfstcompressscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__fstrandmod_SOURCES_DIST = fstrandmod.cc
+@HAVE_BIN_TRUE@am_fstrandmod_OBJECTS = fstrandmod.$(OBJEXT)
+fstrandmod_OBJECTS = $(am_fstrandmod_OBJECTS)
+fstrandmod_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@fstrandmod_DEPENDENCIES = libfstcompressscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstcompressscript_la_SOURCES) $(fstcompress_SOURCES) \
+ $(fstrandmod_SOURCES)
+DIST_SOURCES = $(am__libfstcompressscript_la_SOURCES_DIST) \
+ $(am__fstcompress_SOURCES_DIST) $(am__fstrandmod_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+@HAVE_BIN_TRUE@LDADD = libfstcompressscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la \
+@HAVE_BIN_TRUE@ -lm $(DL_LIBS)
+
+@HAVE_BIN_TRUE@fstcompress_SOURCES = fstcompress.cc
+@HAVE_BIN_TRUE@fstrandmod_SOURCES = fstrandmod.cc
+@HAVE_SCRIPT_TRUE@libfstcompressscript_la_SOURCES = compress-script.cc
+@HAVE_SCRIPT_TRUE@libfstcompressscript_la_LDFLAGS = -version-info 6:0:0
+@HAVE_SCRIPT_TRUE@libfstcompressscript_la_LIBADD = \
+@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lz -lm $(DL_LIBS)
+
+@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstcompressscript.la
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/compress/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/compress/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstcompressscript.la: $(libfstcompressscript_la_OBJECTS) $(libfstcompressscript_la_DEPENDENCIES) $(EXTRA_libfstcompressscript_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstcompressscript_la_LINK) $(am_libfstcompressscript_la_rpath) $(libfstcompressscript_la_OBJECTS) $(libfstcompressscript_la_LIBADD) $(LIBS)
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p \
+ || test -f $$p1 \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+
+fstcompress$(EXEEXT): $(fstcompress_OBJECTS) $(fstcompress_DEPENDENCIES) $(EXTRA_fstcompress_DEPENDENCIES)
+ @rm -f fstcompress$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstcompress_OBJECTS) $(fstcompress_LDADD) $(LIBS)
+
+fstrandmod$(EXEEXT): $(fstrandmod_OBJECTS) $(fstrandmod_DEPENDENCIES) $(EXTRA_fstrandmod_DEPENDENCIES)
+ @rm -f fstrandmod$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstrandmod_OBJECTS) $(fstrandmod_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compress-script.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstcompress.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstrandmod.Po@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(PROGRAMS)
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+ clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool cscopelist-am ctags ctags-am distclean \
+ distclean-compile distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am html html-am info info-am \
+ install install-am install-binPROGRAMS install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-libLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \
+ uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Definitions of 'scriptable' versions of compression operations, that is,
+// those that can be called with FstClass-type arguments.
+//
+// See comments in nlp/fst/script/script-impl.h for how the registration
+// mechanism allows these to work with various arc types.
+
+#include <utility>
+#include <vector>
+
+#include <fst/extensions/compress/compress-script.h>
+
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Compress(const FstClass &fst, const string &filename, const bool gzip) {
+ CompressArgs args(fst, filename, gzip);
+ Apply<Operation<CompressArgs>>("Compress", fst.ArcType(), &args);
+}
+
+void Decompress(const string &filename, MutableFstClass *fst, const bool gzip) {
+ DecompressArgs args(filename, fst, gzip);
+ Apply<Operation<DecompressArgs>>("Decompress", fst->ArcType(), &args);
+}
+
+// Register operations for common arc types.
+
+REGISTER_FST_OPERATION(Compress, StdArc, CompressArgs);
+REGISTER_FST_OPERATION(Compress, LogArc, CompressArgs);
+REGISTER_FST_OPERATION(Compress, Log64Arc, CompressArgs);
+
+REGISTER_FST_OPERATION(Decompress, StdArc, DecompressArgs);
+REGISTER_FST_OPERATION(Decompress, LogArc, DecompressArgs);
+REGISTER_FST_OPERATION(Decompress, Log64Arc, DecompressArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Compresses/decompresses an FST.
+
+#include <string>
+
+#include <fst/extensions/compress/compress-script.h>
+
+#include <fst/util.h>
+#include <fst/script/fst-class.h>
+
+DEFINE_string(arc_type, "standard", "Output arc type");
+DEFINE_bool(decode, false, "Decode");
+DEFINE_bool(gzip, false,
+ "Applies gzip compression after LZA compression and "
+ "gzip decompression before LZA decompression "
+ "(recommended)"
+ "");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ using s::FstClass;
+ using s::VectorFstClass;
+
+ string usage = "Compresses/decompresses an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " [in.fst [out.fstz]]\n";
+ usage += " --decode [in.fstz [out.fst]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ string in_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ string out_name = argc > 2 ? argv[2] : "";
+
+ if (FLAGS_decode == false) {
+ FstClass *ifst = FstClass::Read(in_name);
+ if (!ifst) return 1;
+ s::Compress(*ifst, out_name, FLAGS_gzip);
+ } else {
+ VectorFstClass ofst(FLAGS_arc_type);
+ s::Decompress(in_name, &ofst, FLAGS_gzip);
+ ofst.Write(out_name);
+ }
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Generates a random FST according to a class-specific transition model.
+
+#include <cstdlib>
+#include <ctime>
+#include <memory>
+#include <string>
+
+#include <fst/extensions/compress/randmod.h>
+
+#include <fst/fstlib.h>
+#include <fst/util.h>
+
+DEFINE_int32(seed, time(0), "Random seed");
+DEFINE_int32(states, 10, "# of states");
+DEFINE_int32(labels, 2, "# of labels");
+DEFINE_int32(classes, 1, "# of probability distributions");
+DEFINE_bool(transducer, false, "Output a transducer");
+DEFINE_bool(weights, false, "Output a weighted FST");
+
+int main(int argc, char **argv) {
+ using fst::StdVectorFst;
+ using fst::StdArc;
+ using fst::TropicalWeight;
+ using fst::WeightGenerate;
+
+ string usage = "Generates a random FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += "[out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 2) {
+ ShowUsage();
+ return 1;
+ }
+
+ string out_name = (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+
+ srand(FLAGS_seed);
+
+ int num_states = (rand() % FLAGS_states) + 1; // NOLINT
+ int num_classes = (rand() % FLAGS_classes) + 1; // NOLINT
+ int num_labels = (rand() % FLAGS_labels) + 1; // NOLINT
+
+ StdVectorFst fst;
+ using TropicalWeightGenerate = WeightGenerate<TropicalWeight>;
+ std::unique_ptr<TropicalWeightGenerate> generate(FLAGS_weights ?
+ new TropicalWeightGenerate(false) : nullptr);
+ fst::RandMod<StdArc, TropicalWeightGenerate> rand_mod(num_states,
+ num_classes, num_labels, FLAGS_transducer, generate.get());
+ rand_mod.Generate(&fst);
+ fst.Write(out_name);
+ return 0;
+}
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+libfstdir = @libfstdir@
+libfst_LTLIBRARIES = const8-fst.la const16-fst.la const64-fst.la
+
+lib_LTLIBRARIES = libfstconst.la
+
+libfstconst_la_SOURCES = const8-fst.cc const16-fst.cc const64-fst.cc
+libfstconst_la_LDFLAGS = -version-info 6:0:0 -lm $(DL_LIBS)
+libfstconst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+
+const8_fst_la_SOURCES = const8-fst.cc
+const8_fst_la_LDFLAGS = -module
+
+const16_fst_la_SOURCES = const16-fst.cc
+const16_fst_la_LDFLAGS = -module
+
+const64_fst_la_SOURCES = const64-fst.cc
+const64_fst_la_LDFLAGS = -module
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/extensions/const
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES)
+const16_fst_la_LIBADD =
+am_const16_fst_la_OBJECTS = const16-fst.lo
+const16_fst_la_OBJECTS = $(am_const16_fst_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+const16_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(const16_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+const64_fst_la_LIBADD =
+am_const64_fst_la_OBJECTS = const64-fst.lo
+const64_fst_la_OBJECTS = $(am_const64_fst_la_OBJECTS)
+const64_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(const64_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+const8_fst_la_LIBADD =
+am_const8_fst_la_OBJECTS = const8-fst.lo
+const8_fst_la_OBJECTS = $(am_const8_fst_la_OBJECTS)
+const8_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(const8_fst_la_LDFLAGS) $(LDFLAGS) \
+ -o $@
+am__DEPENDENCIES_1 =
+libfstconst_la_DEPENDENCIES = ../../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+am_libfstconst_la_OBJECTS = const8-fst.lo const16-fst.lo \
+ const64-fst.lo
+libfstconst_la_OBJECTS = $(am_libfstconst_la_OBJECTS)
+libfstconst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstconst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(const16_fst_la_SOURCES) $(const64_fst_la_SOURCES) \
+ $(const8_fst_la_SOURCES) $(libfstconst_la_SOURCES)
+DIST_SOURCES = $(const16_fst_la_SOURCES) $(const64_fst_la_SOURCES) \
+ $(const8_fst_la_SOURCES) $(libfstconst_la_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+libfst_LTLIBRARIES = const8-fst.la const16-fst.la const64-fst.la
+lib_LTLIBRARIES = libfstconst.la
+libfstconst_la_SOURCES = const8-fst.cc const16-fst.cc const64-fst.cc
+libfstconst_la_LDFLAGS = -version-info 6:0:0 -lm $(DL_LIBS)
+libfstconst_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+const8_fst_la_SOURCES = const8-fst.cc
+const8_fst_la_LDFLAGS = -module
+const16_fst_la_SOURCES = const16-fst.cc
+const16_fst_la_LDFLAGS = -module
+const64_fst_la_SOURCES = const64-fst.cc
+const64_fst_la_LDFLAGS = -module
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/const/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/const/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \
+ }
+
+uninstall-libfstLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \
+ done
+
+clean-libfstLTLIBRARIES:
+ -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES)
+ @list='$(libfst_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+const16-fst.la: $(const16_fst_la_OBJECTS) $(const16_fst_la_DEPENDENCIES) $(EXTRA_const16_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(const16_fst_la_LINK) -rpath $(libfstdir) $(const16_fst_la_OBJECTS) $(const16_fst_la_LIBADD) $(LIBS)
+
+const64-fst.la: $(const64_fst_la_OBJECTS) $(const64_fst_la_DEPENDENCIES) $(EXTRA_const64_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(const64_fst_la_LINK) -rpath $(libfstdir) $(const64_fst_la_OBJECTS) $(const64_fst_la_LIBADD) $(LIBS)
+
+const8-fst.la: $(const8_fst_la_OBJECTS) $(const8_fst_la_DEPENDENCIES) $(EXTRA_const8_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(const8_fst_la_LINK) -rpath $(libfstdir) $(const8_fst_la_OBJECTS) $(const8_fst_la_LIBADD) $(LIBS)
+
+libfstconst.la: $(libfstconst_la_OBJECTS) $(libfstconst_la_DEPENDENCIES) $(EXTRA_libfstconst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstconst_la_LINK) -rpath $(libdir) $(libfstconst_la_OBJECTS) $(libfstconst_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const16-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const64-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/const8-fst.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-libfstLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \
+ cscopelist-am ctags ctags-am distclean distclean-compile \
+ distclean-generic distclean-libtool distclean-tags distdir dvi \
+ dvi-am html html-am info info-am install install-am \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-libLTLIBRARIES \
+ install-libfstLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \
+ uninstall-libfstLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/const-fst.h>
+
+namespace fst {
+
+static FstRegisterer<ConstFst<StdArc, uint16>>
+ ConstFst_StdArc_uint16_registerer;
+static FstRegisterer<ConstFst<LogArc, uint16>>
+ ConstFst_LogArc_uint16_registerer;
+static FstRegisterer<ConstFst<Log64Arc, uint16>>
+ ConstFst_Log64Arc_uint16_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/const-fst.h>
+
+namespace fst {
+
+static FstRegisterer<ConstFst<StdArc, uint64>>
+ ConstFst_StdArc_uint64_registerer;
+static FstRegisterer<ConstFst<LogArc, uint64>>
+ ConstFst_LogArc_uint64_registerer;
+static FstRegisterer<ConstFst<Log64Arc, uint64>>
+ ConstFst_Log64Arc_uint64_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/const-fst.h>
+
+namespace fst {
+
+static FstRegisterer<ConstFst<StdArc, uint8>> ConstFst_StdArc_uint8_registerer;
+static FstRegisterer<ConstFst<LogArc, uint8>> ConstFst_LogArc_uint8_registerer;
+static FstRegisterer<ConstFst<Log64Arc, uint8>>
+ ConstFst_Log64Arc_uint8_registerer;
+
+} // namespace fst
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+if HAVE_SCRIPT
+lib_LTLIBRARIES = libfstfar.la libfstfarscript.la
+else
+lib_LTLIBRARIES = libfstfar.la
+endif
+
+libfstfar_la_SOURCES = sttable.cc stlist.cc
+libfstfar_la_LDFLAGS = -version-info 6:0:0
+libfstfar_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+
+if HAVE_SCRIPT
+libfstfarscript_la_SOURCES = far-class.cc farscript.cc getters.cc script-impl.cc \
+ strings.cc
+libfstfarscript_la_LDFLAGS = -version-info 6:0:0
+libfstfarscript_la_LIBADD = \
+ libfstfar.la ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+endif
+
+if HAVE_BIN
+bin_PROGRAMS = farcompilestrings farcreate farequal farextract farinfo \
+ farisomorphic farprintstrings
+
+LDADD = libfstfarscript.la ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+
+farcompilestrings_SOURCES = farcompilestrings.cc
+
+farcreate_SOURCES = farcreate.cc
+
+farequal_SOURCES = farequal.cc
+
+farextract_SOURCES = farextract.cc
+
+farinfo_SOURCES = farinfo.cc
+
+farisomorphic_SOURCES = farisomorphic.cc
+
+farprintstrings_SOURCES = farprintstrings.cc
+endif
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@HAVE_BIN_TRUE@bin_PROGRAMS = farcompilestrings$(EXEEXT) \
+@HAVE_BIN_TRUE@ farcreate$(EXEEXT) farequal$(EXEEXT) \
+@HAVE_BIN_TRUE@ farextract$(EXEEXT) farinfo$(EXEEXT) \
+@HAVE_BIN_TRUE@ farisomorphic$(EXEEXT) farprintstrings$(EXEEXT)
+subdir = src/extensions/far
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+libfstfar_la_DEPENDENCIES = ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am_libfstfar_la_OBJECTS = sttable.lo stlist.lo
+libfstfar_la_OBJECTS = $(am_libfstfar_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstfar_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(libfstfar_la_LDFLAGS) $(LDFLAGS) -o $@
+@HAVE_SCRIPT_FALSE@am_libfstfar_la_rpath = -rpath $(libdir)
+@HAVE_SCRIPT_TRUE@am_libfstfar_la_rpath = -rpath $(libdir)
+@HAVE_SCRIPT_TRUE@libfstfarscript_la_DEPENDENCIES = libfstfar.la \
+@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__libfstfarscript_la_SOURCES_DIST = far-class.cc farscript.cc \
+ getters.cc script-impl.cc strings.cc
+@HAVE_SCRIPT_TRUE@am_libfstfarscript_la_OBJECTS = far-class.lo \
+@HAVE_SCRIPT_TRUE@ farscript.lo getters.lo script-impl.lo \
+@HAVE_SCRIPT_TRUE@ strings.lo
+libfstfarscript_la_OBJECTS = $(am_libfstfarscript_la_OBJECTS)
+libfstfarscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstfarscript_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_TRUE@am_libfstfarscript_la_rpath = -rpath $(libdir)
+PROGRAMS = $(bin_PROGRAMS)
+am__farcompilestrings_SOURCES_DIST = farcompilestrings.cc
+@HAVE_BIN_TRUE@am_farcompilestrings_OBJECTS = \
+@HAVE_BIN_TRUE@ farcompilestrings.$(OBJEXT)
+farcompilestrings_OBJECTS = $(am_farcompilestrings_OBJECTS)
+farcompilestrings_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@farcompilestrings_DEPENDENCIES = libfstfarscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__farcreate_SOURCES_DIST = farcreate.cc
+@HAVE_BIN_TRUE@am_farcreate_OBJECTS = farcreate.$(OBJEXT)
+farcreate_OBJECTS = $(am_farcreate_OBJECTS)
+farcreate_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@farcreate_DEPENDENCIES = libfstfarscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__farequal_SOURCES_DIST = farequal.cc
+@HAVE_BIN_TRUE@am_farequal_OBJECTS = farequal.$(OBJEXT)
+farequal_OBJECTS = $(am_farequal_OBJECTS)
+farequal_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@farequal_DEPENDENCIES = libfstfarscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__farextract_SOURCES_DIST = farextract.cc
+@HAVE_BIN_TRUE@am_farextract_OBJECTS = farextract.$(OBJEXT)
+farextract_OBJECTS = $(am_farextract_OBJECTS)
+farextract_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@farextract_DEPENDENCIES = libfstfarscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__farinfo_SOURCES_DIST = farinfo.cc
+@HAVE_BIN_TRUE@am_farinfo_OBJECTS = farinfo.$(OBJEXT)
+farinfo_OBJECTS = $(am_farinfo_OBJECTS)
+farinfo_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@farinfo_DEPENDENCIES = libfstfarscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__farisomorphic_SOURCES_DIST = farisomorphic.cc
+@HAVE_BIN_TRUE@am_farisomorphic_OBJECTS = farisomorphic.$(OBJEXT)
+farisomorphic_OBJECTS = $(am_farisomorphic_OBJECTS)
+farisomorphic_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@farisomorphic_DEPENDENCIES = libfstfarscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__farprintstrings_SOURCES_DIST = farprintstrings.cc
+@HAVE_BIN_TRUE@am_farprintstrings_OBJECTS = farprintstrings.$(OBJEXT)
+farprintstrings_OBJECTS = $(am_farprintstrings_OBJECTS)
+farprintstrings_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@farprintstrings_DEPENDENCIES = libfstfarscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstfar_la_SOURCES) $(libfstfarscript_la_SOURCES) \
+ $(farcompilestrings_SOURCES) $(farcreate_SOURCES) \
+ $(farequal_SOURCES) $(farextract_SOURCES) $(farinfo_SOURCES) \
+ $(farisomorphic_SOURCES) $(farprintstrings_SOURCES)
+DIST_SOURCES = $(libfstfar_la_SOURCES) \
+ $(am__libfstfarscript_la_SOURCES_DIST) \
+ $(am__farcompilestrings_SOURCES_DIST) \
+ $(am__farcreate_SOURCES_DIST) $(am__farequal_SOURCES_DIST) \
+ $(am__farextract_SOURCES_DIST) $(am__farinfo_SOURCES_DIST) \
+ $(am__farisomorphic_SOURCES_DIST) \
+ $(am__farprintstrings_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+@HAVE_SCRIPT_FALSE@lib_LTLIBRARIES = libfstfar.la
+@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstfar.la libfstfarscript.la
+libfstfar_la_SOURCES = sttable.cc stlist.cc
+libfstfar_la_LDFLAGS = -version-info 6:0:0
+libfstfar_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+@HAVE_SCRIPT_TRUE@libfstfarscript_la_SOURCES = far-class.cc farscript.cc getters.cc script-impl.cc \
+@HAVE_SCRIPT_TRUE@ strings.cc
+
+@HAVE_SCRIPT_TRUE@libfstfarscript_la_LDFLAGS = -version-info 6:0:0
+@HAVE_SCRIPT_TRUE@libfstfarscript_la_LIBADD = \
+@HAVE_SCRIPT_TRUE@ libfstfar.la ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+@HAVE_BIN_TRUE@LDADD = libfstfarscript.la ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+@HAVE_BIN_TRUE@farcompilestrings_SOURCES = farcompilestrings.cc
+@HAVE_BIN_TRUE@farcreate_SOURCES = farcreate.cc
+@HAVE_BIN_TRUE@farequal_SOURCES = farequal.cc
+@HAVE_BIN_TRUE@farextract_SOURCES = farextract.cc
+@HAVE_BIN_TRUE@farinfo_SOURCES = farinfo.cc
+@HAVE_BIN_TRUE@farisomorphic_SOURCES = farisomorphic.cc
+@HAVE_BIN_TRUE@farprintstrings_SOURCES = farprintstrings.cc
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/far/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/far/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstfar.la: $(libfstfar_la_OBJECTS) $(libfstfar_la_DEPENDENCIES) $(EXTRA_libfstfar_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstfar_la_LINK) $(am_libfstfar_la_rpath) $(libfstfar_la_OBJECTS) $(libfstfar_la_LIBADD) $(LIBS)
+
+libfstfarscript.la: $(libfstfarscript_la_OBJECTS) $(libfstfarscript_la_DEPENDENCIES) $(EXTRA_libfstfarscript_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstfarscript_la_LINK) $(am_libfstfarscript_la_rpath) $(libfstfarscript_la_OBJECTS) $(libfstfarscript_la_LIBADD) $(LIBS)
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p \
+ || test -f $$p1 \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+
+farcompilestrings$(EXEEXT): $(farcompilestrings_OBJECTS) $(farcompilestrings_DEPENDENCIES) $(EXTRA_farcompilestrings_DEPENDENCIES)
+ @rm -f farcompilestrings$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(farcompilestrings_OBJECTS) $(farcompilestrings_LDADD) $(LIBS)
+
+farcreate$(EXEEXT): $(farcreate_OBJECTS) $(farcreate_DEPENDENCIES) $(EXTRA_farcreate_DEPENDENCIES)
+ @rm -f farcreate$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(farcreate_OBJECTS) $(farcreate_LDADD) $(LIBS)
+
+farequal$(EXEEXT): $(farequal_OBJECTS) $(farequal_DEPENDENCIES) $(EXTRA_farequal_DEPENDENCIES)
+ @rm -f farequal$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(farequal_OBJECTS) $(farequal_LDADD) $(LIBS)
+
+farextract$(EXEEXT): $(farextract_OBJECTS) $(farextract_DEPENDENCIES) $(EXTRA_farextract_DEPENDENCIES)
+ @rm -f farextract$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(farextract_OBJECTS) $(farextract_LDADD) $(LIBS)
+
+farinfo$(EXEEXT): $(farinfo_OBJECTS) $(farinfo_DEPENDENCIES) $(EXTRA_farinfo_DEPENDENCIES)
+ @rm -f farinfo$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(farinfo_OBJECTS) $(farinfo_LDADD) $(LIBS)
+
+farisomorphic$(EXEEXT): $(farisomorphic_OBJECTS) $(farisomorphic_DEPENDENCIES) $(EXTRA_farisomorphic_DEPENDENCIES)
+ @rm -f farisomorphic$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(farisomorphic_OBJECTS) $(farisomorphic_LDADD) $(LIBS)
+
+farprintstrings$(EXEEXT): $(farprintstrings_OBJECTS) $(farprintstrings_DEPENDENCIES) $(EXTRA_farprintstrings_DEPENDENCIES)
+ @rm -f farprintstrings$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(farprintstrings_OBJECTS) $(farprintstrings_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/far-class.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcompilestrings.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farcreate.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farequal.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farextract.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farinfo.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farisomorphic.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farprintstrings.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/farscript.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/script-impl.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stlist.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/strings.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sttable.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(PROGRAMS)
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+ clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool cscopelist-am ctags ctags-am distclean \
+ distclean-compile distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am html html-am info info-am \
+ install install-am install-binPROGRAMS install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-libLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \
+ uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/far/far-class.h>
+
+#include <fst/script/script-impl.h>
+#include <fst/extensions/far/script-impl.h>
+
+namespace fst {
+namespace script {
+
+
+// FarReaderClass.
+
+FarReaderClass *FarReaderClass::Open(const string &filename) {
+ OpenFarReaderClassArgs1 args(filename);
+ args.retval = nullptr;
+ Apply<Operation<OpenFarReaderClassArgs1>>("OpenFarReaderClass",
+ LoadArcTypeFromFar(filename),
+ &args);
+ return args.retval;
+}
+
+FarReaderClass *FarReaderClass::Open(const std::vector<string> &filenames) {
+ if (filenames.empty()) {
+ LOG(ERROR) << "FarReaderClass::Open: No files specified";
+ return nullptr;
+ }
+ auto it = filenames.cbegin();
+ const auto arc_type = LoadArcTypeFromFar(*it);
+ if (arc_type.empty()) return nullptr;
+ // FIXME(kbg): Is any of this really necessary? I am doing this purely
+ // to conform to what I did with fst::script::Replace.
+ ++it;
+ for (; it != filenames.cend(); ++it) {
+ const string other_arc_type = LoadArcTypeFromFar(*it);
+ if (other_arc_type.empty()) return nullptr;
+ if (arc_type != other_arc_type) {
+ LOG(ERROR) << "FarReaderClass::Open: Trying to open FARs with "
+ << "non-matching arc types:\n\t" << arc_type << " and "
+ << other_arc_type;
+ return nullptr;
+ }
+ }
+ OpenFarReaderClassArgs2 args(filenames);
+ args.retval = nullptr;
+ Apply<Operation<OpenFarReaderClassArgs2>>("OpenFarReaderClass", arc_type,
+ &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(OpenFarReaderClass, StdArc, OpenFarReaderClassArgs1);
+REGISTER_FST_OPERATION(OpenFarReaderClass, LogArc, OpenFarReaderClassArgs1);
+REGISTER_FST_OPERATION(OpenFarReaderClass, Log64Arc, OpenFarReaderClassArgs1);
+
+REGISTER_FST_OPERATION(OpenFarReaderClass, StdArc, OpenFarReaderClassArgs2);
+REGISTER_FST_OPERATION(OpenFarReaderClass, LogArc, OpenFarReaderClassArgs2);
+REGISTER_FST_OPERATION(OpenFarReaderClass, Log64Arc, OpenFarReaderClassArgs2);
+
+// FarWriterClass.
+
+FarWriterClass *FarWriterClass::Create(const string &filename,
+ const string &arc_type, FarType type) {
+ CreateFarWriterClassInnerArgs iargs(filename, type);
+ CreateFarWriterClassArgs args(iargs);
+ args.retval = nullptr;
+ Apply<Operation<CreateFarWriterClassArgs>>("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
--- /dev/null
+// 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 <string>
+#include <vector>
+
+#include <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/getters.h>
+#include <fstream>
+
+DEFINE_string(key_prefix, "", "Prefix to append to keys");
+DEFINE_string(key_suffix, "", "Suffix to append to keys");
+DEFINE_int32(generate_keys, 0,
+ "Generate N digit numeric keys (def: use file basenames)");
+DEFINE_string(far_type, "default",
+ "FAR file format type: one of: \"default\", \"fst\", "
+ "\"stlist\", \"sttable\"");
+DEFINE_bool(allow_negative_labels, false,
+ "Allow negative labels (not recommended; may cause conflicts)");
+DEFINE_string(arc_type, "standard", "Output arc type");
+DEFINE_string(entry_type, "line",
+ "Entry type: one of : "
+ "\"file\" (one FST per file), \"line\" (one FST per line)");
+DEFINE_string(fst_type, "vector", "Output FST type");
+DEFINE_string(token_type, "symbol",
+ "Token type: one of : "
+ "\"symbol\", \"byte\", \"utf8\"");
+DEFINE_string(symbols, "", "Label symbol table");
+DEFINE_string(unknown_symbol, "", "");
+DEFINE_bool(file_list_input, false,
+ "Each input file contains a list of files to be processed");
+DEFINE_bool(keep_symbols, false, "Store symbol table in the FAR file");
+DEFINE_bool(initial_symbols, true,
+ "When keep_symbols is true, stores symbol table only for the first"
+ " FST in archive.");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ string usage = "Compiles a set of strings as FSTs and stores them in";
+ usage += " a finite-state archive.\n\n Usage:";
+ usage += argv[0];
+ usage += " [in1.txt [[in2.txt ...] out.far]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ s::ExpandArgs(argc, argv, &argc, &argv);
+
+ std::vector<string> in_fnames;
+ if (FLAGS_file_list_input) {
+ for (int i = 1; i < argc - 1; ++i) {
+ std::ifstream istrm(argv[i]);
+ string str;
+ while (getline(istrm, str)) in_fnames.push_back(str);
+ }
+ } else {
+ for (int i = 1; i < argc - 1; ++i)
+ in_fnames.push_back(argv[i]);
+ }
+ if (in_fnames.empty()) {
+ in_fnames.push_back(argc == 2 && strcmp(argv[1], "-") != 0 ? argv[1] : "");
+ }
+
+ string out_fname =
+ argc > 2 && strcmp(argv[argc - 1], "-") != 0 ? argv[argc - 1] : "";
+
+ fst::FarEntryType entry_type;
+ if (!s::GetFarEntryType(FLAGS_entry_type, &entry_type)) {
+ LOG(ERROR) << "Unknown or unsupported FAR entry type: " << FLAGS_entry_type;
+ return 1;
+ }
+
+ fst::FarTokenType token_type;
+ if (!s::GetFarTokenType(FLAGS_token_type, &token_type)) {
+ LOG(ERROR) << "Unkonwn or unsupported FAR token type: " << FLAGS_token_type;
+ return 1;
+ }
+
+ const auto far_type = s::GetFarType(FLAGS_far_type);
+
+ s::FarCompileStrings(in_fnames, out_fname, FLAGS_arc_type, FLAGS_fst_type,
+ far_type, FLAGS_generate_keys, entry_type, token_type,
+ FLAGS_symbols, FLAGS_unknown_symbol, FLAGS_keep_symbols,
+ FLAGS_initial_symbols, FLAGS_allow_negative_labels,
+ FLAGS_key_prefix, FLAGS_key_suffix);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Creates a finite-state archive from input FSTs.
+
+#include <string>
+#include <vector>
+
+#include <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/getters.h>
+#include <fstream>
+
+DEFINE_string(key_prefix, "", "Prefix to append to keys");
+DEFINE_string(key_suffix, "", "Suffix to append to keys");
+DEFINE_int32(generate_keys, 0,
+ "Generate N digit numeric keys (def: use file basenames)");
+DEFINE_string(far_type, "default",
+ "FAR file format type: one of: \"default\", "
+ "\"stlist\", \"sttable\"");
+DEFINE_bool(file_list_input, false,
+ "Each input file contains a list of files to be processed");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ string usage = "Creates a finite-state archive from input FSTs.\n\n Usage:";
+ usage += argv[0];
+ usage += " [in1.fst [[in2.fst ...] out.far]]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ s::ExpandArgs(argc, argv, &argc, &argv);
+
+ std::vector<string> in_fnames;
+ if (FLAGS_file_list_input) {
+ for (int i = 1; i < argc - 1; ++i) {
+ std::ifstream istrm(argv[i]);
+ string str;
+ while (getline(istrm, str)) in_fnames.push_back(str);
+ }
+ } else {
+ for (int i = 1; i < argc - 1; ++i)
+ in_fnames.push_back(argv[i]);
+ }
+ if (in_fnames.empty())
+ in_fnames.push_back(argc == 2 && strcmp(argv[1], "-") != 0 ? argv[1] : "");
+
+ string out_fname =
+ argc > 2 && strcmp(argv[argc - 1], "-") != 0 ? argv[argc - 1] : "";
+
+ const auto arc_type = s::LoadArcTypeFromFst(in_fnames[0]);
+ if (arc_type.empty()) return 1;
+
+ const auto far_type = s::GetFarType(FLAGS_far_type);
+
+ s::FarCreate(in_fnames, out_fname, arc_type, FLAGS_generate_keys, far_type,
+ FLAGS_key_prefix, FLAGS_key_suffix);
+
+ return 0;
+}
--- /dev/null
+// 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 <string>
+
+#include <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/getters.h>
+
+DEFINE_string(begin_key, "",
+ "First key to extract (def: first key in archive)");
+DEFINE_string(end_key, "", "Last key to extract (def: last key in archive)");
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ string usage = "Compares the FSTs in two FST archives for equality.";
+ usage += "\n\n Usage:";
+ usage += argv[0];
+ usage += " in1.far in2.far";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ s::ExpandArgs(argc, argv, &argc, &argv);
+ if (argc != 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const auto arc_type = s::LoadArcTypeFromFar(argv[1]);
+ if (arc_type.empty()) return 1;
+
+ bool result = s::FarEqual(argv[1], argv[2], arc_type, FLAGS_delta,
+ FLAGS_begin_key, FLAGS_end_key);
+
+ if (!result) VLOG(1) << "FARs are not equal.";
+
+ return result ? 0 : 2;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Extracts component FSTs from an finite-state archive.
+
+#include <string>
+#include <vector>
+
+#include <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/getters.h>
+
+DEFINE_string(filename_prefix, "", "Prefix to append to filenames");
+DEFINE_string(filename_suffix, "", "Suffix to append to filenames");
+DEFINE_int32(generate_filenames, 0,
+ "Generate N digit numeric filenames (def: use keys)");
+DEFINE_string(keys, "",
+ "Extract set of keys separated by comma (default) "
+ "including ranges delimited by dash (default)");
+DEFINE_string(key_separator, ",", "Separator for individual keys");
+DEFINE_string(range_delimiter, "-", "Delimiter for ranges of keys");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ string usage = "Extracts FSTs from a finite-state archive.\n\n Usage:";
+ usage += argv[0];
+ usage += " [in1.far in2.far...]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ s::ExpandArgs(argc, argv, &argc, &argv);
+
+ std::vector<string> in_fnames;
+ for (int i = 1; i < argc; ++i) in_fnames.push_back(argv[i]);
+ if (in_fnames.empty()) in_fnames.push_back("");
+
+ const auto arc_type = s::LoadArcTypeFromFar(in_fnames[0]);
+ if (arc_type.empty()) return 1;
+
+ s::FarExtract(in_fnames, arc_type, FLAGS_generate_filenames, FLAGS_keys,
+ FLAGS_key_separator, FLAGS_range_delimiter,
+ FLAGS_filename_prefix, FLAGS_filename_suffix);
+
+ return 0;
+}
--- /dev/null
+// 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 <string>
+#include <vector>
+
+#include <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/getters.h>
+
+DEFINE_string(begin_key, "",
+ "First key to extract (default: first key in archive)");
+DEFINE_string(end_key, "",
+ "Last key to extract (default: last key in archive)");
+
+DEFINE_bool(list_fsts, false, "Display FST information for each key");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ string usage = "Prints some basic information about the FSTs in an FST ";
+ usage += "archive.\n\n Usage:";
+ usage += argv[0];
+ usage += " [in1.far in2.far...]\n";
+ usage += " Flags: begin_key end_key list_fsts";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ s::ExpandArgs(argc, argv, &argc, &argv);
+
+ std::vector<string> in_fnames;
+ for (int i = 1; i < argc; ++i) in_fnames.push_back(argv[i]);
+ if (in_fnames.empty()) in_fnames.push_back("");
+
+ const auto arc_type = s::LoadArcTypeFromFar(in_fnames[0]);
+ if (arc_type.empty()) return 1;
+
+ s::FarInfo(in_fnames, arc_type, FLAGS_begin_key, FLAGS_end_key,
+ FLAGS_list_fsts);
+
+ return 0;
+}
--- /dev/null
+// 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 <string>
+
+#include <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/getters.h>
+
+DEFINE_string(begin_key, "",
+ "First key to extract (def: first key in archive)");
+DEFINE_string(end_key, "", "Last key to extract (def: last key in archive)");
+DEFINE_double(delta, fst::kDelta, "Comparison/quantization delta");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ string usage = "Compares the FSTs in two FST archives for isomorphism.";
+ usage += "\n\n Usage:";
+ usage += argv[0];
+ usage += " in1.far in2.far\n";
+ usage += " Flags: begin_key end_key";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ s::ExpandArgs(argc, argv, &argc, &argv);
+
+ if (argc != 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const auto arc_type = s::LoadArcTypeFromFar(argv[1]);
+ if (arc_type.empty()) return 1;
+
+ bool result = s::FarIsomorphic(argv[1], argv[2], arc_type,
+ FLAGS_delta, FLAGS_begin_key, FLAGS_end_key);
+
+ if (!result) VLOG(1) << "FARs are not isomorphic.";
+
+ return result ? 0 : 2;
+}
--- /dev/null
+// 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 <string>
+#include <vector>
+
+#include <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/getters.h>
+
+DEFINE_string(filename_prefix, "", "Prefix to append to filenames");
+DEFINE_string(filename_suffix, "", "Suffix to append to filenames");
+DEFINE_int32(generate_filenames, 0,
+ "Generate N digit numeric filenames (def: use keys)");
+DEFINE_string(begin_key, "",
+ "First key to extract (def: first key in archive)");
+DEFINE_string(end_key, "", "Last key to extract (def: last key in archive)");
+// PrintStringsMain specific flag definitions.
+DEFINE_bool(print_key, false, "Prefix each string by its key");
+DEFINE_bool(print_weight, false, "Suffix each string by its weight");
+DEFINE_string(entry_type, "line",
+ "Entry type: one of : "
+ "\"file\" (one FST per file), \"line\" (one FST per line)");
+DEFINE_string(token_type, "symbol",
+ "Token type: one of : "
+ "\"symbol\", \"byte\", \"utf8\"");
+DEFINE_string(symbols, "", "Label symbol table");
+DEFINE_bool(initial_symbols, true,
+ "Uses symbol table from the first Fst in archive for all entries.");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+
+ string usage = "Print as string the string FSTs in an archive.\n\n Usage:";
+ usage += argv[0];
+ usage += " [in1.far in2.far ...]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ s::ExpandArgs(argc, argv, &argc, &argv);
+
+ std::vector<string> in_fnames;
+ for (int i = 1; i < argc; ++i) in_fnames.push_back(argv[i]);
+ if (in_fnames.empty()) in_fnames.push_back("");
+
+ const auto arc_type = s::LoadArcTypeFromFar(in_fnames[0]);
+ if (arc_type.empty()) return 1;
+
+ fst::FarEntryType entry_type;
+ if (!s::GetFarEntryType(FLAGS_entry_type, &entry_type)) {
+ LOG(ERROR) << "Unknown or unsupported FAR entry type: " << FLAGS_entry_type;
+ return 1;
+ }
+
+ fst::FarTokenType token_type;
+ if (!s::GetFarTokenType(FLAGS_token_type, &token_type)) {
+ LOG(ERROR) << "Unknown or unsupported FAR token type: " << FLAGS_token_type;
+ return 1;
+ }
+
+ s::FarPrintStrings(in_fnames, arc_type, entry_type, token_type,
+ FLAGS_begin_key, FLAGS_end_key, FLAGS_print_key,
+ FLAGS_print_weight, FLAGS_symbols, FLAGS_initial_symbols,
+ FLAGS_generate_filenames, FLAGS_filename_prefix,
+ FLAGS_filename_suffix);
+
+ return 0;
+}
--- /dev/null
+// 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 <fst/extensions/far/farscript.h>
+#include <fst/extensions/far/far.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void FarCompileStrings(const std::vector<string> &in_fnames,
+ const string &out_fname, const string &arc_type,
+ const string &fst_type, const FarType &far_type,
+ int32 generate_keys, FarEntryType fet, FarTokenType tt,
+ const string &symbols_fname,
+ const string &unknown_symbol, bool keep_symbols,
+ bool initial_symbols, bool allow_negative_labels,
+ const string &key_prefix, const string &key_suffix) {
+ FarCompileStringsArgs args(in_fnames, out_fname, fst_type, far_type,
+ generate_keys, fet, tt, symbols_fname,
+ unknown_symbol, keep_symbols, initial_symbols,
+ allow_negative_labels, key_prefix, key_suffix);
+ Apply<Operation<FarCompileStringsArgs>>("FarCompileStrings", arc_type, &args);
+}
+
+void FarCreate(const std::vector<string> &in_fnames, const string &out_fname,
+ const string &arc_type, const int32 generate_keys,
+ const FarType &far_type, const string &key_prefix,
+ const string &key_suffix) {
+ FarCreateArgs args(in_fnames, out_fname, generate_keys, far_type, key_prefix,
+ key_suffix);
+ Apply<Operation<FarCreateArgs>>("FarCreate", arc_type, &args);
+}
+
+bool FarEqual(const string &filename1, const string &filename2,
+ const string &arc_type, float delta, const string &begin_key,
+ const string &end_key) {
+ FarEqualInnerArgs args(filename1, filename2, delta, begin_key, end_key);
+ FarEqualArgs args_with_retval(args);
+ Apply<Operation<FarEqualArgs>>("FarEqual", arc_type, &args_with_retval);
+ return args_with_retval.retval;
+}
+
+void FarExtract(const std::vector<string> &ifilenames, const string &arc_type,
+ int32 generate_filenames, const string &keys,
+ const string &key_separator, const string &range_delimiter,
+ const string &filename_prefix, const string &filename_suffix) {
+ FarExtractArgs args(ifilenames, generate_filenames, keys, key_separator,
+ range_delimiter, filename_prefix, filename_suffix);
+ Apply<Operation<FarExtractArgs>>("FarExtract", arc_type, &args);
+}
+
+void FarInfo(const std::vector<string> &filenames, const string &arc_type,
+ const string &begin_key, const string &end_key,
+ const bool list_fsts) {
+ FarInfoArgs args(filenames, begin_key, end_key, list_fsts);
+ Apply<Operation<FarInfoArgs>>("FarInfo", arc_type, &args);
+}
+
+bool FarIsomorphic(const string &filename1, const string &filename2,
+ const string &arc_type, float delta, const string &begin_key,
+ const string &end_key) {
+ FarIsomorphicInnerArgs args(filename1, filename2, delta, begin_key, end_key);
+ FarIsomorphicArgs args_with_retval(args);
+ Apply<Operation<FarIsomorphicArgs>>("FarIsomorphic", arc_type,
+ &args_with_retval);
+ return args_with_retval.retval;
+}
+
+void FarPrintStrings(const std::vector<string> &ifilenames,
+ const string &arc_type, const FarEntryType entry_type,
+ const FarTokenType token_type, const string &begin_key,
+ const string &end_key, const bool print_key,
+ const bool print_weight, const string &symbols_fname,
+ const bool initial_symbols, const int32 generate_filenames,
+ const string &filename_prefix,
+ const string &filename_suffix) {
+ FarPrintStringsArgs args(ifilenames, entry_type, token_type, begin_key,
+ end_key, print_key, print_weight, symbols_fname,
+ initial_symbols, generate_filenames, filename_prefix,
+ filename_suffix);
+ Apply<Operation<FarPrintStringsArgs>>("FarPrintStrings", arc_type, &args);
+}
+
+// Instantiate all templates for common arc types.
+
+REGISTER_FST_FAR_OPERATIONS(StdArc);
+REGISTER_FST_FAR_OPERATIONS(LogArc);
+REGISTER_FST_FAR_OPERATIONS(Log64Arc);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// 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 <fst/extensions/far/getters.h>
+
+#include <string>
+#include <vector>
+
+#include <fstream>
+
+namespace fst {
+
+namespace script {
+
+FarType GetFarType(const string &str) {
+ if (str == "fst") {
+ return FAR_FST;
+ } else if (str == "stlist") {
+ return FAR_STLIST;
+ } else if (str == "sttable") {
+ return FAR_STTABLE;
+ } else {
+ return FAR_DEFAULT;
+ }
+}
+
+bool GetFarEntryType(const string &str, FarEntryType *entry_type) {
+ if (str == "line") {
+ *entry_type = FET_LINE;
+ } else if (str == "file") {
+ *entry_type = FET_FILE;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetFarTokenType(const string &str, FarTokenType *token_type) {
+ if (str == "symbol") {
+ *token_type = FTT_SYMBOL;
+ } else if (str == "byte") {
+ *token_type = FTT_BYTE;
+ } else if (str == "utf8") {
+ *token_type = FTT_UTF8;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+void ExpandArgs(int argc, char **argv, int *argcp, char ***argvp) {
+}
+
+} // namespace script
+
+string GetFarTypeString(FarType type) {
+ switch (type) {
+ case FAR_FST:
+ return "fst";
+ case FAR_STLIST:
+ return "stlist";
+ case FAR_STTABLE:
+ return "sttable";
+ case FAR_DEFAULT:
+ return "default";
+ default:
+ return "<unknown>";
+ }
+}
+
+} // namespace fst
--- /dev/null
+// 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 <fst/extensions/far/script-impl.h>
+
+#include <string>
+
+#include <fst/extensions/far/far.h>
+#include <fstream>
+
+namespace fst {
+namespace script {
+
+string LoadArcTypeFromFar(const string &far_fname) {
+ FarHeader hdr;
+ if (!hdr.Read(far_fname)) {
+ LOG(ERROR) << "Error reading FAR: " << far_fname;
+ return "";
+ }
+ string atype = hdr.ArcType();
+ if (atype == "unknown") {
+ LOG(ERROR) << "Empty FST archive: " << far_fname;
+ return "";
+ }
+ return atype;
+}
+
+string LoadArcTypeFromFst(const string &fst_fname) {
+ FstHeader hdr;
+ std::ifstream in(fst_fname.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!hdr.Read(in, fst_fname)) {
+ LOG(ERROR) << "Error reading FST: " << fst_fname;
+ return "";
+ }
+ return hdr.ArcType();
+}
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <ios>
+
+#include <fst/extensions/far/stlist.h>
+#include <fstream>
+
+namespace fst {
+
+bool IsSTList(const string &filename) {
+ std::ifstream strm(filename.c_str(),
+ 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
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <cmath>
+#include <string>
+
+#include <fst/extensions/far/compile-strings.h>
+#include <fstream>
+
+DEFINE_string(far_field_separator, "\t",
+ "Set of characters used as a separator between printed fields");
+
+namespace fst {
+
+// Computes the minimal length required to encode each line number as a decimal
+// number.
+int KeySize(const char *filename) {
+ std::ifstream istrm(filename);
+ istrm.seekg(0);
+ string s;
+ int nline = 0;
+ while (getline(istrm, s)) ++nline;
+ istrm.seekg(0);
+ return nline ? ceil(log10(nline + 1)) : 1;
+}
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fstream>
+#include <fst/extensions/far/sttable.h>
+
+namespace fst {
+
+bool IsSTTable(const string &filename) {
+ std::ifstream strm(filename);
+ if (!strm.good()) return false;
+
+ int32 magic_number = 0;
+ ReadType(strm, &magic_number);
+ return magic_number == kSTTableMagicNumber;
+}
+
+} // namespace fst
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+if HAVE_BIN
+bin_PROGRAMS = fstlinear fstloglinearapply
+
+LDADD = libfstlinearscript.la ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+
+fstlinear_SOURCES = fstlinear.cc
+
+fstloglinearapply_SOURCES = fstloglinearapply.cc
+endif
+
+if HAVE_SCRIPT
+libfstlinearscript_la_SOURCES = linearscript.cc
+libfstlinearscript_la_LDFLAGS = -version-info 6:0:0 -lm $(DL_LIBS)
+libfstlinearscript_la_LIBADD = ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+endif
+
+if HAVE_SCRIPT
+libfst_LTLIBRARIES = linear_tagger-fst.la \
+ linear_classifier-fst.la
+lib_LTLIBRARIES = libfstlinearscript.la
+else
+libfst_LTLIBRARIES = linear_tagger-fst.la linear_classifier-fst.la
+endif
+
+libfstdir = @libfstdir@
+
+linear_tagger_fst_la_SOURCES = linear-tagger-fst.cc
+linear_tagger_fst_la_LDFLAGS = -module
+
+linear_classifier_fst_la_SOURCES = linear-classifier-fst.cc
+linear_classifier_fst_la_LDFLAGS = -module
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@HAVE_BIN_TRUE@bin_PROGRAMS = fstlinear$(EXEEXT) \
+@HAVE_BIN_TRUE@ fstloglinearapply$(EXEEXT)
+subdir = src/extensions/linear
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" \
+ "$(DESTDIR)$(bindir)"
+LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+@HAVE_SCRIPT_TRUE@libfstlinearscript_la_DEPENDENCIES = \
+@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__libfstlinearscript_la_SOURCES_DIST = linearscript.cc
+@HAVE_SCRIPT_TRUE@am_libfstlinearscript_la_OBJECTS = linearscript.lo
+libfstlinearscript_la_OBJECTS = $(am_libfstlinearscript_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstlinearscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstlinearscript_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_TRUE@am_libfstlinearscript_la_rpath = -rpath $(libdir)
+linear_classifier_fst_la_LIBADD =
+am_linear_classifier_fst_la_OBJECTS = linear-classifier-fst.lo
+linear_classifier_fst_la_OBJECTS = \
+ $(am_linear_classifier_fst_la_OBJECTS)
+linear_classifier_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(linear_classifier_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_FALSE@am_linear_classifier_fst_la_rpath = -rpath \
+@HAVE_SCRIPT_FALSE@ $(libfstdir)
+@HAVE_SCRIPT_TRUE@am_linear_classifier_fst_la_rpath = -rpath \
+@HAVE_SCRIPT_TRUE@ $(libfstdir)
+linear_tagger_fst_la_LIBADD =
+am_linear_tagger_fst_la_OBJECTS = linear-tagger-fst.lo
+linear_tagger_fst_la_OBJECTS = $(am_linear_tagger_fst_la_OBJECTS)
+linear_tagger_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(linear_tagger_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_FALSE@am_linear_tagger_fst_la_rpath = -rpath $(libfstdir)
+@HAVE_SCRIPT_TRUE@am_linear_tagger_fst_la_rpath = -rpath $(libfstdir)
+PROGRAMS = $(bin_PROGRAMS)
+am__fstlinear_SOURCES_DIST = fstlinear.cc
+@HAVE_BIN_TRUE@am_fstlinear_OBJECTS = fstlinear.$(OBJEXT)
+fstlinear_OBJECTS = $(am_fstlinear_OBJECTS)
+fstlinear_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@fstlinear_DEPENDENCIES = libfstlinearscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__fstloglinearapply_SOURCES_DIST = fstloglinearapply.cc
+@HAVE_BIN_TRUE@am_fstloglinearapply_OBJECTS = \
+@HAVE_BIN_TRUE@ fstloglinearapply.$(OBJEXT)
+fstloglinearapply_OBJECTS = $(am_fstloglinearapply_OBJECTS)
+fstloglinearapply_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@fstloglinearapply_DEPENDENCIES = libfstlinearscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstlinearscript_la_SOURCES) \
+ $(linear_classifier_fst_la_SOURCES) \
+ $(linear_tagger_fst_la_SOURCES) $(fstlinear_SOURCES) \
+ $(fstloglinearapply_SOURCES)
+DIST_SOURCES = $(am__libfstlinearscript_la_SOURCES_DIST) \
+ $(linear_classifier_fst_la_SOURCES) \
+ $(linear_tagger_fst_la_SOURCES) $(am__fstlinear_SOURCES_DIST) \
+ $(am__fstloglinearapply_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+@HAVE_BIN_TRUE@LDADD = libfstlinearscript.la ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+@HAVE_BIN_TRUE@fstlinear_SOURCES = fstlinear.cc
+@HAVE_BIN_TRUE@fstloglinearapply_SOURCES = fstloglinearapply.cc
+@HAVE_SCRIPT_TRUE@libfstlinearscript_la_SOURCES = linearscript.cc
+@HAVE_SCRIPT_TRUE@libfstlinearscript_la_LDFLAGS = -version-info 6:0:0 -lm $(DL_LIBS)
+@HAVE_SCRIPT_TRUE@libfstlinearscript_la_LIBADD = ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+@HAVE_SCRIPT_FALSE@libfst_LTLIBRARIES = linear_tagger-fst.la linear_classifier-fst.la
+@HAVE_SCRIPT_TRUE@libfst_LTLIBRARIES = linear_tagger-fst.la \
+@HAVE_SCRIPT_TRUE@ linear_classifier-fst.la
+
+@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstlinearscript.la
+linear_tagger_fst_la_SOURCES = linear-tagger-fst.cc
+linear_tagger_fst_la_LDFLAGS = -module
+linear_classifier_fst_la_SOURCES = linear-classifier-fst.cc
+linear_classifier_fst_la_LDFLAGS = -module
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/linear/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/linear/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \
+ }
+
+uninstall-libfstLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \
+ done
+
+clean-libfstLTLIBRARIES:
+ -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES)
+ @list='$(libfst_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstlinearscript.la: $(libfstlinearscript_la_OBJECTS) $(libfstlinearscript_la_DEPENDENCIES) $(EXTRA_libfstlinearscript_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstlinearscript_la_LINK) $(am_libfstlinearscript_la_rpath) $(libfstlinearscript_la_OBJECTS) $(libfstlinearscript_la_LIBADD) $(LIBS)
+
+linear_classifier-fst.la: $(linear_classifier_fst_la_OBJECTS) $(linear_classifier_fst_la_DEPENDENCIES) $(EXTRA_linear_classifier_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(linear_classifier_fst_la_LINK) $(am_linear_classifier_fst_la_rpath) $(linear_classifier_fst_la_OBJECTS) $(linear_classifier_fst_la_LIBADD) $(LIBS)
+
+linear_tagger-fst.la: $(linear_tagger_fst_la_OBJECTS) $(linear_tagger_fst_la_DEPENDENCIES) $(EXTRA_linear_tagger_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(linear_tagger_fst_la_LINK) $(am_linear_tagger_fst_la_rpath) $(linear_tagger_fst_la_OBJECTS) $(linear_tagger_fst_la_LIBADD) $(LIBS)
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p \
+ || test -f $$p1 \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+
+fstlinear$(EXEEXT): $(fstlinear_OBJECTS) $(fstlinear_DEPENDENCIES) $(EXTRA_fstlinear_DEPENDENCIES)
+ @rm -f fstlinear$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstlinear_OBJECTS) $(fstlinear_LDADD) $(LIBS)
+
+fstloglinearapply$(EXEEXT): $(fstloglinearapply_OBJECTS) $(fstloglinearapply_DEPENDENCIES) $(EXTRA_fstloglinearapply_DEPENDENCIES)
+ @rm -f fstloglinearapply$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstloglinearapply_OBJECTS) $(fstloglinearapply_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstlinear.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstloglinearapply.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linear-classifier-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linear-tagger-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/linearscript.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(PROGRAMS)
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libfstLTLIBRARIES clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-libfstLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES \
+ uninstall-libfstLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+ clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libfstLTLIBRARIES clean-libtool cscopelist-am ctags \
+ ctags-am distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-binPROGRAMS \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-libLTLIBRARIES \
+ install-libfstLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \
+ uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/linear/linearscript.h>
+
+DEFINE_string(arc_type, "standard", "Output arc type");
+
+DEFINE_string(epsilon_symbol, "<eps>", "Epsilon symbol");
+DEFINE_string(unknown_symbol, "<unk>", "Unknown word symbol");
+
+DEFINE_string(vocab, "", "Path to the vocabulary file");
+DEFINE_string(out, "", "Path to the output binary");
+
+DEFINE_string(save_isymbols, "", "Save input symbol table to file");
+DEFINE_string(save_fsymbols, "", "Save feature symbol table to file");
+DEFINE_string(save_osymbols, "", "Save output symbol table to file");
+
+int main(int argc, char **argv) {
+ // TODO(wuke): more detailed usage
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(argv[0], &argc, &argv, true);
+ fst::script::ValidateDelimiter();
+ fst::script::ValidateEmptySymbol();
+
+ if (argc == 1) {
+ ShowUsage();
+ return 1;
+ }
+
+ fst::script::LinearCompile(FLAGS_arc_type, FLAGS_epsilon_symbol,
+ FLAGS_unknown_symbol, FLAGS_vocab, argv + 1,
+ argc - 1, FLAGS_out, FLAGS_save_isymbols,
+ FLAGS_save_fsymbols, FLAGS_save_osymbols);
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/compat.h>
+#include <fst/extensions/linear/linear-fst.h>
+#include <fst/extensions/linear/loglinear-apply.h>
+#include <fst/vector-fst.h>
+
+DEFINE_bool(normalize, true, "Normalize to get posterior");
+
+int main(int argc, char **argv) {
+ string usage =
+ "Applies an FST to another FST, treating the second as a log-linear "
+ "model.\n\n "
+ "Usage: ";
+ usage += argv[0];
+ usage += " in.fst linear.fst [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ string in_name = strcmp(argv[1], "-") != 0 ? argv[1] : "";
+ string linear_name = (argc > 2 && (strcmp(argv[2], "-") != 0)) ? argv[2] : "";
+ string out_name = argc > 3 ? argv[3] : "";
+
+ if (in_name.empty() && linear_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input.";
+ return 1;
+ }
+
+ fst::StdFst *ifst1 = fst::StdFst::Read(in_name);
+ if (!ifst1) return 1;
+
+ fst::StdFst *ifst2 = fst::StdFst::Read(linear_name);
+ if (!ifst2) return 1;
+
+ fst::StdVectorFst ofst;
+
+ LogLinearApply(*ifst1, *ifst2, &ofst, FLAGS_normalize);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/linear/linear-fst.h>
+#include <fst/register.h>
+
+using fst::LinearClassifierFst;
+using fst::StdArc;
+using fst::LogArc;
+
+REGISTER_FST(LinearClassifierFst, StdArc);
+REGISTER_FST(LinearClassifierFst, LogArc);
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/linear/linear-fst.h>
+#include <fst/register.h>
+
+using fst::LinearTaggerFst;
+using fst::StdArc;
+using fst::LogArc;
+
+REGISTER_FST(LinearTaggerFst, StdArc);
+REGISTER_FST(LinearTaggerFst, LogArc);
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <cctype>
+#include <cstdio>
+#include <set>
+
+#include <fst/compat.h>
+#include <fst/extensions/linear/linearscript.h>
+#include <fst/arc.h>
+#include <fstream>
+#include <fst/script/script-impl.h>
+
+DEFINE_string(delimiter, "|",
+ "Single non-white-space character delimiter inside sequences of "
+ "feature symbols and output symbols");
+DEFINE_string(empty_symbol, "<empty>",
+ "Special symbol that designates an empty sequence");
+
+DEFINE_string(start_symbol, "<s>", "Start of sentence symbol");
+DEFINE_string(end_symbol, "</s>", "End of sentence symbol");
+
+DEFINE_bool(classifier, false,
+ "Treat input model as a classifier instead of a tagger");
+
+namespace fst {
+namespace script {
+
+bool ValidateDelimiter() {
+ if (FLAGS_delimiter.size() == 1 && !std::isspace(FLAGS_delimiter[0]))
+ return true;
+ return false;
+}
+
+bool ValidateEmptySymbol() {
+ bool okay = !FLAGS_empty_symbol.empty();
+ for (size_t i = 0; i < FLAGS_empty_symbol.size(); ++i) {
+ char c = FLAGS_empty_symbol[i];
+ if (std::isspace(c)) okay = false;
+ }
+ return okay;
+}
+
+void LinearCompile(const string &arc_type, const string &epsilon_symbol,
+ const string &unknown_symbol, const string &vocab,
+ char **models, int models_len, const string &out,
+ const string &save_isymbols, const string &save_fsymbols,
+ const string &save_osymbols) {
+ LinearCompileArgs args(epsilon_symbol, unknown_symbol, vocab, models,
+ models_len, out, save_isymbols, save_fsymbols,
+ save_osymbols);
+ Apply<Operation<LinearCompileArgs>>("LinearCompileTpl", arc_type, &args);
+}
+
+// Instantiate templates for common arc types
+REGISTER_FST_LINEAR_OPERATIONS(StdArc);
+REGISTER_FST_LINEAR_OPERATIONS(LogArc);
+
+void SplitByWhitespace(const string &str, std::vector<string> *out) {
+ out->clear();
+ std::istringstream strm(str);
+ string buf;
+ while (strm >> buf) out->push_back(buf);
+}
+
+int ScanNumClasses(char **models, int models_len) {
+ std::set<string> preds;
+ for (int i = 0; i < models_len; ++i) {
+ std::ifstream in(models[i]);
+ if (!in) LOG(FATAL) << "Failed to open " << models[i];
+
+ string line;
+ std::getline(in, line);
+
+ size_t num_line = 1;
+ while (std::getline(in, line)) {
+ ++num_line;
+ std::vector<string> 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
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+libfstdir = @libfstdir@
+libfst_LTLIBRARIES = arc_lookahead-fst.la \
+ilabel_lookahead-fst.la olabel_lookahead-fst.la
+
+lib_LTLIBRARIES = libfstlookahead.la
+
+libfstlookahead_la_SOURCES = arc_lookahead-fst.cc ilabel_lookahead-fst.cc \
+ olabel_lookahead-fst.cc
+libfstlookahead_la_LDFLAGS = -version-info 6:0:0
+libfstlookahead_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+
+arc_lookahead_fst_la_SOURCES = arc_lookahead-fst.cc
+arc_lookahead_fst_la_LDFLAGS = -module
+
+ilabel_lookahead_fst_la_SOURCES = ilabel_lookahead-fst.cc
+ilabel_lookahead_fst_la_LDFLAGS = -module
+
+olabel_lookahead_fst_la_SOURCES = olabel_lookahead-fst.cc
+olabel_lookahead_fst_la_LDFLAGS = -module
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/extensions/lookahead
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES)
+arc_lookahead_fst_la_LIBADD =
+am_arc_lookahead_fst_la_OBJECTS = arc_lookahead-fst.lo
+arc_lookahead_fst_la_OBJECTS = $(am_arc_lookahead_fst_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+arc_lookahead_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(arc_lookahead_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+ilabel_lookahead_fst_la_LIBADD =
+am_ilabel_lookahead_fst_la_OBJECTS = ilabel_lookahead-fst.lo
+ilabel_lookahead_fst_la_OBJECTS = \
+ $(am_ilabel_lookahead_fst_la_OBJECTS)
+ilabel_lookahead_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(ilabel_lookahead_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+am__DEPENDENCIES_1 =
+libfstlookahead_la_DEPENDENCIES = ../../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+am_libfstlookahead_la_OBJECTS = arc_lookahead-fst.lo \
+ ilabel_lookahead-fst.lo olabel_lookahead-fst.lo
+libfstlookahead_la_OBJECTS = $(am_libfstlookahead_la_OBJECTS)
+libfstlookahead_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstlookahead_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+olabel_lookahead_fst_la_LIBADD =
+am_olabel_lookahead_fst_la_OBJECTS = olabel_lookahead-fst.lo
+olabel_lookahead_fst_la_OBJECTS = \
+ $(am_olabel_lookahead_fst_la_OBJECTS)
+olabel_lookahead_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(olabel_lookahead_fst_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(arc_lookahead_fst_la_SOURCES) \
+ $(ilabel_lookahead_fst_la_SOURCES) \
+ $(libfstlookahead_la_SOURCES) \
+ $(olabel_lookahead_fst_la_SOURCES)
+DIST_SOURCES = $(arc_lookahead_fst_la_SOURCES) \
+ $(ilabel_lookahead_fst_la_SOURCES) \
+ $(libfstlookahead_la_SOURCES) \
+ $(olabel_lookahead_fst_la_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+libfst_LTLIBRARIES = arc_lookahead-fst.la \
+ilabel_lookahead-fst.la olabel_lookahead-fst.la
+
+lib_LTLIBRARIES = libfstlookahead.la
+libfstlookahead_la_SOURCES = arc_lookahead-fst.cc ilabel_lookahead-fst.cc \
+ olabel_lookahead-fst.cc
+
+libfstlookahead_la_LDFLAGS = -version-info 6:0:0
+libfstlookahead_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+arc_lookahead_fst_la_SOURCES = arc_lookahead-fst.cc
+arc_lookahead_fst_la_LDFLAGS = -module
+ilabel_lookahead_fst_la_SOURCES = ilabel_lookahead-fst.cc
+ilabel_lookahead_fst_la_LDFLAGS = -module
+olabel_lookahead_fst_la_SOURCES = olabel_lookahead-fst.cc
+olabel_lookahead_fst_la_LDFLAGS = -module
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/lookahead/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/lookahead/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \
+ }
+
+uninstall-libfstLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \
+ done
+
+clean-libfstLTLIBRARIES:
+ -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES)
+ @list='$(libfst_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+arc_lookahead-fst.la: $(arc_lookahead_fst_la_OBJECTS) $(arc_lookahead_fst_la_DEPENDENCIES) $(EXTRA_arc_lookahead_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(arc_lookahead_fst_la_LINK) -rpath $(libfstdir) $(arc_lookahead_fst_la_OBJECTS) $(arc_lookahead_fst_la_LIBADD) $(LIBS)
+
+ilabel_lookahead-fst.la: $(ilabel_lookahead_fst_la_OBJECTS) $(ilabel_lookahead_fst_la_DEPENDENCIES) $(EXTRA_ilabel_lookahead_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(ilabel_lookahead_fst_la_LINK) -rpath $(libfstdir) $(ilabel_lookahead_fst_la_OBJECTS) $(ilabel_lookahead_fst_la_LIBADD) $(LIBS)
+
+libfstlookahead.la: $(libfstlookahead_la_OBJECTS) $(libfstlookahead_la_DEPENDENCIES) $(EXTRA_libfstlookahead_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstlookahead_la_LINK) -rpath $(libdir) $(libfstlookahead_la_OBJECTS) $(libfstlookahead_la_LIBADD) $(LIBS)
+
+olabel_lookahead-fst.la: $(olabel_lookahead_fst_la_OBJECTS) $(olabel_lookahead_fst_la_DEPENDENCIES) $(EXTRA_olabel_lookahead_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(olabel_lookahead_fst_la_LINK) -rpath $(libfstdir) $(olabel_lookahead_fst_la_OBJECTS) $(olabel_lookahead_fst_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arc_lookahead-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ilabel_lookahead-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/olabel_lookahead-fst.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-libfstLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \
+ cscopelist-am ctags ctags-am distclean distclean-compile \
+ distclean-generic distclean-libtool distclean-tags distdir dvi \
+ dvi-am html html-am info info-am install install-am \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-libLTLIBRARIES \
+ install-libfstLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \
+ uninstall-libfstLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/matcher-fst.h>
+
+namespace fst {
+
+static FstRegisterer<StdArcLookAheadFst> ArcLookAheadFst_StdArc_registerer;
+static FstRegisterer<MatcherFst<
+ ConstFst<LogArc>, ArcLookAheadMatcher<SortedMatcher<ConstFst<LogArc>>>,
+ arc_lookahead_fst_type>>
+ ArcLookAheadFst_LogArc_registerer;
+static FstRegisterer<MatcherFst<
+ ConstFst<Log64Arc>, ArcLookAheadMatcher<SortedMatcher<ConstFst<Log64Arc>>>,
+ arc_lookahead_fst_type>>
+ ArcLookAheadFst_Log64Arc_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/matcher-fst.h>
+
+namespace fst {
+
+static FstRegisterer<StdILabelLookAheadFst>
+ ILabelLookAheadFst_StdArc_registerer;
+static FstRegisterer<MatcherFst<
+ ConstFst<LogArc>,
+ LabelLookAheadMatcher<SortedMatcher<ConstFst<LogArc>>,
+ ilabel_lookahead_flags, FastLogAccumulator<LogArc>>,
+ ilabel_lookahead_fst_type, LabelLookAheadRelabeler<LogArc>>>
+ ILabelLookAheadFst_LogArc_registerer;
+static FstRegisterer<MatcherFst<
+ ConstFst<Log64Arc>,
+ LabelLookAheadMatcher<SortedMatcher<ConstFst<Log64Arc>>,
+ ilabel_lookahead_flags, FastLogAccumulator<Log64Arc>>,
+ ilabel_lookahead_fst_type, LabelLookAheadRelabeler<Log64Arc>>>
+ ILabelLookAheadFst_Log64Arc_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/matcher-fst.h>
+
+namespace fst {
+
+static FstRegisterer<StdOLabelLookAheadFst>
+ OLabelLookAheadFst_StdArc_registerer;
+static FstRegisterer<MatcherFst<
+ ConstFst<LogArc>,
+ LabelLookAheadMatcher<SortedMatcher<ConstFst<LogArc>>,
+ olabel_lookahead_flags, FastLogAccumulator<LogArc>>,
+ olabel_lookahead_fst_type, LabelLookAheadRelabeler<LogArc>>>
+ OLabelLookAheadFst_LogArc_registerer;
+static FstRegisterer<MatcherFst<
+ ConstFst<Log64Arc>,
+ LabelLookAheadMatcher<SortedMatcher<ConstFst<Log64Arc>>,
+ olabel_lookahead_flags, FastLogAccumulator<Log64Arc>>,
+ olabel_lookahead_fst_type, LabelLookAheadRelabeler<Log64Arc>>>
+ OLabelLookAheadFst_Log64Arc_registerer;
+
+} // namespace fst
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+if HAVE_BIN
+bin_PROGRAMS = mpdtcompose mpdtexpand mpdtinfo mpdtreverse
+
+LDADD = libfstmpdtscript.la \
+ ../pdt/libfstpdtscript.la \
+ ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+
+mpdtcompose_SOURCES = mpdtcompose.cc
+
+mpdtexpand_SOURCES = mpdtexpand.cc
+
+mpdtinfo_SOURCES = mpdtinfo.cc
+
+mpdtreverse_SOURCES = mpdtreverse.cc
+endif
+
+if HAVE_SCRIPT
+lib_LTLIBRARIES = libfstmpdtscript.la
+libfstmpdtscript_la_SOURCES = mpdtscript.cc
+libfstmpdtscript_la_LDFLAGS = -version-info 6:0:0
+libfstmpdtscript_la_LIBADD = ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+endif
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@HAVE_BIN_TRUE@bin_PROGRAMS = mpdtcompose$(EXEEXT) mpdtexpand$(EXEEXT) \
+@HAVE_BIN_TRUE@ mpdtinfo$(EXEEXT) mpdtreverse$(EXEEXT)
+subdir = src/extensions/mpdt
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_DEPENDENCIES = \
+@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__libfstmpdtscript_la_SOURCES_DIST = mpdtscript.cc
+@HAVE_SCRIPT_TRUE@am_libfstmpdtscript_la_OBJECTS = mpdtscript.lo
+libfstmpdtscript_la_OBJECTS = $(am_libfstmpdtscript_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstmpdtscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstmpdtscript_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_TRUE@am_libfstmpdtscript_la_rpath = -rpath $(libdir)
+PROGRAMS = $(bin_PROGRAMS)
+am__mpdtcompose_SOURCES_DIST = mpdtcompose.cc
+@HAVE_BIN_TRUE@am_mpdtcompose_OBJECTS = mpdtcompose.$(OBJEXT)
+mpdtcompose_OBJECTS = $(am_mpdtcompose_OBJECTS)
+mpdtcompose_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@mpdtcompose_DEPENDENCIES = libfstmpdtscript.la \
+@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__mpdtexpand_SOURCES_DIST = mpdtexpand.cc
+@HAVE_BIN_TRUE@am_mpdtexpand_OBJECTS = mpdtexpand.$(OBJEXT)
+mpdtexpand_OBJECTS = $(am_mpdtexpand_OBJECTS)
+mpdtexpand_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@mpdtexpand_DEPENDENCIES = libfstmpdtscript.la \
+@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__mpdtinfo_SOURCES_DIST = mpdtinfo.cc
+@HAVE_BIN_TRUE@am_mpdtinfo_OBJECTS = mpdtinfo.$(OBJEXT)
+mpdtinfo_OBJECTS = $(am_mpdtinfo_OBJECTS)
+mpdtinfo_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@mpdtinfo_DEPENDENCIES = libfstmpdtscript.la \
+@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__mpdtreverse_SOURCES_DIST = mpdtreverse.cc
+@HAVE_BIN_TRUE@am_mpdtreverse_OBJECTS = mpdtreverse.$(OBJEXT)
+mpdtreverse_OBJECTS = $(am_mpdtreverse_OBJECTS)
+mpdtreverse_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@mpdtreverse_DEPENDENCIES = libfstmpdtscript.la \
+@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstmpdtscript_la_SOURCES) $(mpdtcompose_SOURCES) \
+ $(mpdtexpand_SOURCES) $(mpdtinfo_SOURCES) \
+ $(mpdtreverse_SOURCES)
+DIST_SOURCES = $(am__libfstmpdtscript_la_SOURCES_DIST) \
+ $(am__mpdtcompose_SOURCES_DIST) $(am__mpdtexpand_SOURCES_DIST) \
+ $(am__mpdtinfo_SOURCES_DIST) $(am__mpdtreverse_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+@HAVE_BIN_TRUE@LDADD = libfstmpdtscript.la \
+@HAVE_BIN_TRUE@ ../pdt/libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+@HAVE_BIN_TRUE@mpdtcompose_SOURCES = mpdtcompose.cc
+@HAVE_BIN_TRUE@mpdtexpand_SOURCES = mpdtexpand.cc
+@HAVE_BIN_TRUE@mpdtinfo_SOURCES = mpdtinfo.cc
+@HAVE_BIN_TRUE@mpdtreverse_SOURCES = mpdtreverse.cc
+@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstmpdtscript.la
+@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_SOURCES = mpdtscript.cc
+@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_LDFLAGS = -version-info 6:0:0
+@HAVE_SCRIPT_TRUE@libfstmpdtscript_la_LIBADD = ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/mpdt/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/mpdt/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstmpdtscript.la: $(libfstmpdtscript_la_OBJECTS) $(libfstmpdtscript_la_DEPENDENCIES) $(EXTRA_libfstmpdtscript_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstmpdtscript_la_LINK) $(am_libfstmpdtscript_la_rpath) $(libfstmpdtscript_la_OBJECTS) $(libfstmpdtscript_la_LIBADD) $(LIBS)
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p \
+ || test -f $$p1 \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+
+mpdtcompose$(EXEEXT): $(mpdtcompose_OBJECTS) $(mpdtcompose_DEPENDENCIES) $(EXTRA_mpdtcompose_DEPENDENCIES)
+ @rm -f mpdtcompose$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(mpdtcompose_OBJECTS) $(mpdtcompose_LDADD) $(LIBS)
+
+mpdtexpand$(EXEEXT): $(mpdtexpand_OBJECTS) $(mpdtexpand_DEPENDENCIES) $(EXTRA_mpdtexpand_DEPENDENCIES)
+ @rm -f mpdtexpand$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(mpdtexpand_OBJECTS) $(mpdtexpand_LDADD) $(LIBS)
+
+mpdtinfo$(EXEEXT): $(mpdtinfo_OBJECTS) $(mpdtinfo_DEPENDENCIES) $(EXTRA_mpdtinfo_DEPENDENCIES)
+ @rm -f mpdtinfo$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(mpdtinfo_OBJECTS) $(mpdtinfo_LDADD) $(LIBS)
+
+mpdtreverse$(EXEEXT): $(mpdtreverse_OBJECTS) $(mpdtreverse_DEPENDENCIES) $(EXTRA_mpdtreverse_DEPENDENCIES)
+ @rm -f mpdtreverse$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(mpdtreverse_OBJECTS) $(mpdtreverse_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtcompose.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtexpand.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtinfo.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtreverse.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mpdtscript.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(PROGRAMS)
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+ clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool cscopelist-am ctags ctags-am distclean \
+ distclean-compile distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am html html-am info info-am \
+ install install-am install-binPROGRAMS install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-libLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \
+ uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Composes an MPDT and an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/mpdt/mpdtscript.h>
+#include <fst/extensions/mpdt/read_write_utils.h>
+#include <fst/extensions/pdt/getters.h>
+#include <fst/util.h>
+
+DEFINE_string(mpdt_parentheses, "",
+ "MPDT parenthesis label pairs with assignments");
+DEFINE_bool(left_mpdt, true, "Is the first argument the MPDT?");
+DEFINE_bool(connect, true, "Trim output?");
+DEFINE_string(compose_filter, "paren",
+ "Composition filter, one of: \"expand\", \"expand_paren\", "
+ "\"paren\"");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::MPdtComposeOptions;
+ using fst::PdtComposeFilter;
+ using fst::ReadLabelTriples;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Compose an MPDT and an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt in.fst [out.mpdt]\n";
+ usage += " in.fst in.pdt [out.mpdt]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input.";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ std::vector<int64> assignments;
+ if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false))
+ return 1;
+
+ VectorFstClass ofst(ifst1->ArcType());
+
+ PdtComposeFilter compose_filter;
+ if (!s::GetPdtComposeFilter(FLAGS_compose_filter, &compose_filter)) {
+ LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: "
+ << FLAGS_compose_filter;
+ return 1;
+ }
+
+ const MPdtComposeOptions opts(FLAGS_connect, compose_filter);
+
+ s::MPdtCompose(*ifst1, *ifst2, parens, assignments, &ofst, opts,
+ FLAGS_left_mpdt);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Expands a (bounded-stack) MPDT as an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/mpdt/mpdtscript.h>
+#include <fst/extensions/mpdt/read_write_utils.h>
+#include <fst/util.h>
+
+DEFINE_string(mpdt_parentheses, "",
+ "MPDT parenthesis label pairs with assignments");
+DEFINE_bool(connect, true, "Trim output?");
+DEFINE_bool(keep_parentheses, false, "Keep PDT parentheses in result?");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::ReadLabelTriples;
+ using fst::MPdtExpandOptions;
+
+ string usage = "Expand a (bounded-stack) MPDT as an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ std::vector<int64> assignments;
+ if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false))
+ return 1;
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ const MPdtExpandOptions opts(FLAGS_connect, FLAGS_keep_parentheses);
+
+ s::MPdtExpand(*ifst, parens, assignments, &ofst, opts);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/mpdt/mpdtscript.h>
+#include <fst/extensions/mpdt/read_write_utils.h>
+#include <fst/util.h>
+
+DEFINE_string(mpdt_parentheses, "",
+ "MPDT parenthesis label pairs with assignments");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::ReadLabelTriples;
+
+ string usage = "Prints out information about an MPDT.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 2) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ std::vector<int64> assignments;
+ if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false))
+ return 1;
+
+ s::PrintMPdtInfo(*ifst, parens, assignments);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Reverses an MPDT.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/mpdt/mpdtscript.h>
+#include <fst/extensions/mpdt/read_write_utils.h>
+#include <fst/util.h>
+
+DEFINE_string(mpdt_parentheses, "",
+ "MPDT parenthesis label pairs with assignments.");
+
+DEFINE_string(mpdt_new_parentheses, "",
+ "Output for reassigned parentheses and stacks");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::ReadLabelTriples;
+ using fst::WriteLabelTriples;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Reverse an MPDT.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ std::vector<int64> assignments;
+ if (!ReadLabelTriples(FLAGS_mpdt_parentheses, &parens, &assignments, false))
+ return 1;
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ s::MPdtReverse(*ifst, parens, &assignments, &ofst);
+
+ ofst.Write(out_name);
+
+ if (!WriteLabelTriples(FLAGS_mpdt_new_parentheses, parens, assignments))
+ return 1;
+
+ return 0;
+}
--- /dev/null
+// 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 <string>
+#include <vector>
+
+#include <fst/extensions/mpdt/compose.h>
+#include <fst/extensions/mpdt/expand.h>
+#include <fst/extensions/mpdt/mpdtscript.h>
+#include <fst/extensions/mpdt/reverse.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void MPdtCompose(const FstClass &ifst1, const FstClass &ifst2,
+ const std::vector<LabelPair> &parens,
+ const std::vector<int64> &assignments, MutableFstClass *ofst,
+ const MPdtComposeOptions &copts, bool left_pdt) {
+ if (!ArcTypesMatch(ifst1, ifst2, "MPdtCompose") ||
+ !ArcTypesMatch(ifst1, *ofst, "MPdtCompose")) return;
+ MPdtComposeArgs args(ifst1, ifst2, parens, assignments, ofst, copts,
+ left_pdt);
+ Apply<Operation<MPdtComposeArgs>>("MPdtCompose", ifst1.ArcType(), &args);
+}
+
+void MPdtExpand(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ const std::vector<int64> &assignments, MutableFstClass *ofst,
+ const MPdtExpandOptions &opts) {
+ MPdtExpandArgs args(ifst, parens, assignments, ofst, opts);
+ Apply<Operation<MPdtExpandArgs>>("MPdtExpand", ifst.ArcType(), &args);
+}
+
+void MPdtExpand(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ const std::vector<int64> &assignments, MutableFstClass *ofst,
+ bool connect) {
+ MPdtExpand(ifst, parens, assignments, ofst, MPdtExpandOptions(connect));
+}
+
+void MPdtReverse(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ std::vector<int64> *assignments, MutableFstClass *ofst) {
+ MPdtReverseArgs args(ifst, parens, assignments, ofst);
+ Apply<Operation<MPdtReverseArgs>>("MPdtReverse", ifst.ArcType(), &args);
+}
+
+void PrintMPdtInfo(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ const std::vector<int64> &assignments) {
+ PrintMPdtInfoArgs args(ifst, parens, assignments);
+ Apply<Operation<PrintMPdtInfoArgs>>("PrintMPdtInfo", ifst.ArcType(), &args);
+}
+
+// Register operations for common arc types.
+
+REGISTER_FST_MPDT_OPERATIONS(StdArc);
+REGISTER_FST_MPDT_OPERATIONS(LogArc);
+REGISTER_FST_MPDT_OPERATIONS(Log64Arc);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+libfstdir = @libfstdir@
+libfst_LTLIBRARIES = ngram-fst.la
+
+lib_LTLIBRARIES = libfstngram.la
+
+ngram_fst_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc
+ngram_fst_la_LDFLAGS = -module
+
+libfstngram_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc
+libfstngram_la_LDFLAGS = -version-info 6:0:0
+libfstngram_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/extensions/ngram
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+libfstngram_la_DEPENDENCIES = ../../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+am_libfstngram_la_OBJECTS = bitmap-index.lo ngram-fst.lo nthbit.lo
+libfstngram_la_OBJECTS = $(am_libfstngram_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstngram_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstngram_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+ngram_fst_la_LIBADD =
+am_ngram_fst_la_OBJECTS = bitmap-index.lo ngram-fst.lo nthbit.lo
+ngram_fst_la_OBJECTS = $(am_ngram_fst_la_OBJECTS)
+ngram_fst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(ngram_fst_la_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstngram_la_SOURCES) $(ngram_fst_la_SOURCES)
+DIST_SOURCES = $(libfstngram_la_SOURCES) $(ngram_fst_la_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+libfst_LTLIBRARIES = ngram-fst.la
+lib_LTLIBRARIES = libfstngram.la
+ngram_fst_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc
+ngram_fst_la_LDFLAGS = -module
+libfstngram_la_SOURCES = bitmap-index.cc ngram-fst.cc nthbit.cc
+libfstngram_la_LDFLAGS = -version-info 6:0:0
+libfstngram_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/ngram/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/ngram/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \
+ }
+
+uninstall-libfstLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \
+ done
+
+clean-libfstLTLIBRARIES:
+ -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES)
+ @list='$(libfst_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstngram.la: $(libfstngram_la_OBJECTS) $(libfstngram_la_DEPENDENCIES) $(EXTRA_libfstngram_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstngram_la_LINK) -rpath $(libdir) $(libfstngram_la_OBJECTS) $(libfstngram_la_LIBADD) $(LIBS)
+
+ngram-fst.la: $(ngram_fst_la_OBJECTS) $(ngram_fst_la_DEPENDENCIES) $(EXTRA_ngram_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(ngram_fst_la_LINK) -rpath $(libfstdir) $(ngram_fst_la_OBJECTS) $(ngram_fst_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bitmap-index.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ngram-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nthbit.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libfstLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-libfstLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libLTLIBRARIES clean-libfstLTLIBRARIES clean-libtool \
+ cscopelist-am ctags ctags-am distclean distclean-compile \
+ distclean-generic distclean-libtool distclean-tags distdir dvi \
+ dvi-am html html-am info info-am install install-am \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-libLTLIBRARIES \
+ install-libfstLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES \
+ uninstall-libfstLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/ngram/bitmap-index.h>
+
+#include <algorithm>
+#include <iterator>
+
+#include <fst/extensions/ngram/nthbit.h>
+
+namespace fst {
+namespace {
+const size_t kPrimaryBlockBits =
+ BitmapIndex::kStorageBitSize * BitmapIndex::kSecondaryBlockSize;
+
+// If [begin, begin+size) is a monotonically increasing running sum of
+// popcounts for a bitmap, this will return the index of the word that contains
+// the value'th zero. If value is larger then the number of zeros in the
+// bitmap, size will be returned. The idea is that the number of zerocounts
+// (i.e. the popcount of logical NOT of values) is offset * kStorageBitSize
+// minus the value for each element of the running sum.
+template <size_t BlockSize, typename Iter, typename T>
+Iter InvertedSearch(Iter first, Iter last, T value) {
+ const Iter begin = first;
+ while (first != last) {
+ // Invariant: [first, last) is the search range.
+ Iter mid = first + ((last - first) / 2);
+ size_t mid_value = BlockSize * (1 + (mid - begin)) - *mid;
+ if (mid_value < value) {
+ first = ++mid;
+ } else {
+ last = mid;
+ }
+ }
+ return first;
+}
+} // namespace
+
+size_t BitmapIndex::Rank1(size_t end) const {
+ if (end == 0) return 0;
+ CHECK_LE(end, Bits());
+ const uint32 end_word = (end - 1) >> BitmapIndex::kStorageLogBitSize;
+ const uint32 sum = get_index_ones_count(end_word);
+ const size_t masked = end & kStorageBlockMask;
+ if (masked == 0) {
+ return sum + __builtin_popcountll(bits_[end_word]);
+ } else {
+ const uint64 zero = 0;
+ return sum + __builtin_popcountll(bits_[end_word] &
+ (~zero >> (kStorageBitSize - masked)));
+ }
+}
+
+size_t BitmapIndex::Select1(size_t bit_index) const {
+ if (bit_index >= GetOnesCount()) return Bits();
+ // search primary index for the relevant block
+ uint32 rembits = bit_index + 1;
+ const uint32 block = find_primary_block(bit_index + 1);
+ uint32 offset = 0;
+ if (block > 0) {
+ rembits -= primary_index_[block - 1];
+ offset += block * kSecondaryBlockSize;
+ }
+ // search the secondary index
+ uint32 word = find_secondary_block(offset, rembits);
+ if (word > 0) {
+ rembits -= secondary_index_[offset + word - 1];
+ offset += word;
+ }
+ int nth = nth_bit(bits_[offset], rembits);
+ return (offset << BitmapIndex::kStorageLogBitSize) + nth;
+}
+
+size_t BitmapIndex::Select0(size_t bit_index) const {
+ if (bit_index >= Bits() - GetOnesCount()) return Bits();
+ // search inverted primary index for relevant block
+ uint32 remzeros = bit_index + 1;
+ uint32 offset = 0;
+ const uint32 block = find_inverted_primary_block(bit_index + 1);
+ if (block > 0) {
+ remzeros -= kPrimaryBlockBits * block - primary_index_[block - 1];
+ offset += block * kSecondaryBlockSize;
+ }
+ // search the inverted secondary index
+ uint32 word = find_inverted_secondary_block(offset, remzeros);
+ if (word > 0) {
+ remzeros -= BitmapIndex::kStorageBitSize * word -
+ secondary_index_[offset + word - 1];
+ offset += word;
+ }
+ int nth = nth_bit(~bits_[offset], remzeros);
+ return (offset << BitmapIndex::kStorageLogBitSize) + nth;
+}
+
+std::pair<size_t, size_t> BitmapIndex::Select0s(size_t bit_index) const {
+ const uint64 zero = 0;
+ const uint64 ones = ~zero;
+ size_t zeros_count = Bits() - GetOnesCount();
+ if (bit_index >= zeros_count) return std::make_pair(Bits(), Bits());
+ if (bit_index + 1 >= zeros_count) {
+ return std::make_pair(Select0(bit_index), Bits());
+ }
+ // search inverted primary index for relevant block
+ uint32 remzeros = bit_index + 1;
+ uint32 offset = 0;
+ const uint32 block = find_inverted_primary_block(bit_index + 1);
+ size_t num_zeros_in_block =
+ kPrimaryBlockBits * (1 + block) - primary_index_[block];
+ if (block > 0) {
+ size_t num_zeros_next =
+ kPrimaryBlockBits * block - primary_index_[block - 1];
+ num_zeros_in_block -= num_zeros_next;
+ remzeros -= num_zeros_next;
+ offset += block * kSecondaryBlockSize;
+ }
+ // search the inverted secondary index
+ uint32 word = find_inverted_secondary_block(offset, remzeros);
+ uint32 sum_zeros_next_word = BitmapIndex::kStorageBitSize * (1 + word) -
+ secondary_index_[offset + word];
+ uint32 sum_zeros_this_word = 0;
+ if (word > 0) {
+ sum_zeros_this_word = BitmapIndex::kStorageBitSize * word -
+ secondary_index_[offset + word - 1];
+ remzeros -= sum_zeros_this_word;
+ offset += word;
+ }
+ int nth = nth_bit(~bits_[offset], remzeros);
+ size_t current_zero = (offset << BitmapIndex::kStorageLogBitSize) + nth;
+
+ size_t next_zero;
+ // Does the current block contain the next zero?
+ if (num_zeros_in_block > remzeros + 1) {
+ if (sum_zeros_next_word - sum_zeros_this_word >= remzeros + 1) {
+ // the next zero is in this word
+ next_zero = (offset << BitmapIndex::kStorageLogBitSize) +
+ nth_bit(~bits_[offset], remzeros + 1);
+ } else {
+ // Find the first field that is not all ones by linear scan.
+ // In the worst case, this may scan 8Kbytes. The alternative is
+ // to inspect secondary_index_ looking for a place to jump to, but
+ // that would probably use more cache.
+ while (bits_[++offset] == ones) {
+ }
+ next_zero = (offset << BitmapIndex::kStorageLogBitSize) +
+ __builtin_ctzll(~bits_[offset]);
+ }
+ } else {
+ // the next zero is in a different block, a full search is required.
+ next_zero = Select0(bit_index + 1);
+ }
+ return std::make_pair(current_zero, next_zero);
+}
+
+size_t BitmapIndex::get_index_ones_count(size_t array_index) const {
+ uint32 sum = 0;
+ if (array_index > 0) {
+ sum += secondary_index_[array_index - 1];
+ uint32 end_block = (array_index - 1) / kSecondaryBlockSize;
+ if (end_block > 0) sum += primary_index_[end_block - 1];
+ }
+ return sum;
+}
+
+void BitmapIndex::BuildIndex(const uint64 *bits, size_t size) {
+ bits_ = bits;
+ size_ = size;
+ primary_index_.resize(primary_index_size());
+ secondary_index_.resize(ArraySize());
+ const uint64 zero = 0;
+ const uint64 ones = ~zero;
+ uint32 popcount = 0;
+ for (uint32 block = 0; block * kSecondaryBlockSize < ArraySize(); block++) {
+ uint32 block_popcount = 0;
+ uint32 block_begin = block * kSecondaryBlockSize;
+ uint32 block_end = block_begin + kSecondaryBlockSize;
+ if (block_end > ArraySize()) block_end = ArraySize();
+ for (uint32 j = block_begin; j < block_end; ++j) {
+ uint64 mask = ones;
+ if (j == ArraySize() - 1) {
+ mask = ones >> (-size_ & BitmapIndex::kStorageBlockMask);
+ }
+ block_popcount += __builtin_popcountll(bits_[j] & mask);
+ secondary_index_[j] = block_popcount;
+ }
+ popcount += block_popcount;
+ primary_index_[block] = popcount;
+ }
+}
+
+size_t BitmapIndex::find_secondary_block(size_t block_begin,
+ size_t rem_bit_index) const {
+ size_t block_end = block_begin + kSecondaryBlockSize;
+ if (block_end > ArraySize()) block_end = ArraySize();
+ return std::distance(
+ secondary_index_.begin() + block_begin,
+ std::lower_bound(secondary_index_.begin() + block_begin,
+ secondary_index_.begin() + block_end, rem_bit_index));
+}
+
+size_t BitmapIndex::find_inverted_secondary_block(size_t block_begin,
+ size_t rem_bit_index) const {
+ size_t block_end = block_begin + kSecondaryBlockSize;
+ if (block_end > ArraySize()) block_end = ArraySize();
+ return std::distance(
+ secondary_index_.begin() + block_begin,
+ InvertedSearch<BitmapIndex::kStorageBitSize>(
+ secondary_index_.begin() + block_begin,
+ secondary_index_.begin() + block_end, rem_bit_index));
+}
+
+inline size_t BitmapIndex::find_primary_block(size_t bit_index) const {
+ return std::distance(
+ primary_index_.begin(),
+ std::lower_bound(primary_index_.begin(),
+ primary_index_.begin() + primary_index_size(),
+ bit_index));
+}
+
+size_t BitmapIndex::find_inverted_primary_block(size_t bit_index) const {
+ return std::distance(
+ primary_index_.begin(),
+ InvertedSearch<kPrimaryBlockBits>(primary_index_.begin(),
+ primary_index_.end(), bit_index));
+}
+} // end namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/ngram/ngram-fst.h>
+
+#include <sys/types.h>
+
+#include <fst/fstlib.h>
+
+using fst::NGramFst;
+using fst::StdArc;
+using fst::LogArc;
+
+REGISTER_FST(NGramFst, StdArc);
+REGISTER_FST(NGramFst, LogArc);
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/ngram/nthbit.h>
+
+// This table is generated using:
+//
+// unsigned int nth_bit_scan(uint64 v, unsigned int r) {
+// int i=0;
+// for (; i<64; i++) {
+// if ((r -= v & 1) == 0) return i;
+// v >>= 1;
+// }
+// return i;
+// }
+//
+// for (size_t i = 0; i < 256; ++i) {
+// uint32 offsets = 0;
+// for (size_t b = 1; b <= 8; ++b) {
+// uint32 offset = min<uint32>(nth_bit_scan(i, b), 8);
+// offsets |= (offset << ((b - 1) << 2));
+// }
+// bit_offset = offsets;
+// printf("0x%x, ", bit_offset);
+// if (i % 4 == 3) printf("\n");
+// }
+//
+uint32 nth_bit_bit_offset[] = {
+ 0x88888888, 0x88888880, 0x88888881, 0x88888810, 0x88888882, 0x88888820,
+ 0x88888821, 0x88888210, 0x88888883, 0x88888830, 0x88888831, 0x88888310,
+ 0x88888832, 0x88888320, 0x88888321, 0x88883210, 0x88888884, 0x88888840,
+ 0x88888841, 0x88888410, 0x88888842, 0x88888420, 0x88888421, 0x88884210,
+ 0x88888843, 0x88888430, 0x88888431, 0x88884310, 0x88888432, 0x88884320,
+ 0x88884321, 0x88843210, 0x88888885, 0x88888850, 0x88888851, 0x88888510,
+ 0x88888852, 0x88888520, 0x88888521, 0x88885210, 0x88888853, 0x88888530,
+ 0x88888531, 0x88885310, 0x88888532, 0x88885320, 0x88885321, 0x88853210,
+ 0x88888854, 0x88888540, 0x88888541, 0x88885410, 0x88888542, 0x88885420,
+ 0x88885421, 0x88854210, 0x88888543, 0x88885430, 0x88885431, 0x88854310,
+ 0x88885432, 0x88854320, 0x88854321, 0x88543210, 0x88888886, 0x88888860,
+ 0x88888861, 0x88888610, 0x88888862, 0x88888620, 0x88888621, 0x88886210,
+ 0x88888863, 0x88888630, 0x88888631, 0x88886310, 0x88888632, 0x88886320,
+ 0x88886321, 0x88863210, 0x88888864, 0x88888640, 0x88888641, 0x88886410,
+ 0x88888642, 0x88886420, 0x88886421, 0x88864210, 0x88888643, 0x88886430,
+ 0x88886431, 0x88864310, 0x88886432, 0x88864320, 0x88864321, 0x88643210,
+ 0x88888865, 0x88888650, 0x88888651, 0x88886510, 0x88888652, 0x88886520,
+ 0x88886521, 0x88865210, 0x88888653, 0x88886530, 0x88886531, 0x88865310,
+ 0x88886532, 0x88865320, 0x88865321, 0x88653210, 0x88888654, 0x88886540,
+ 0x88886541, 0x88865410, 0x88886542, 0x88865420, 0x88865421, 0x88654210,
+ 0x88886543, 0x88865430, 0x88865431, 0x88654310, 0x88865432, 0x88654320,
+ 0x88654321, 0x86543210, 0x88888887, 0x88888870, 0x88888871, 0x88888710,
+ 0x88888872, 0x88888720, 0x88888721, 0x88887210, 0x88888873, 0x88888730,
+ 0x88888731, 0x88887310, 0x88888732, 0x88887320, 0x88887321, 0x88873210,
+ 0x88888874, 0x88888740, 0x88888741, 0x88887410, 0x88888742, 0x88887420,
+ 0x88887421, 0x88874210, 0x88888743, 0x88887430, 0x88887431, 0x88874310,
+ 0x88887432, 0x88874320, 0x88874321, 0x88743210, 0x88888875, 0x88888750,
+ 0x88888751, 0x88887510, 0x88888752, 0x88887520, 0x88887521, 0x88875210,
+ 0x88888753, 0x88887530, 0x88887531, 0x88875310, 0x88887532, 0x88875320,
+ 0x88875321, 0x88753210, 0x88888754, 0x88887540, 0x88887541, 0x88875410,
+ 0x88887542, 0x88875420, 0x88875421, 0x88754210, 0x88887543, 0x88875430,
+ 0x88875431, 0x88754310, 0x88875432, 0x88754320, 0x88754321, 0x87543210,
+ 0x88888876, 0x88888760, 0x88888761, 0x88887610, 0x88888762, 0x88887620,
+ 0x88887621, 0x88876210, 0x88888763, 0x88887630, 0x88887631, 0x88876310,
+ 0x88887632, 0x88876320, 0x88876321, 0x88763210, 0x88888764, 0x88887640,
+ 0x88887641, 0x88876410, 0x88887642, 0x88876420, 0x88876421, 0x88764210,
+ 0x88887643, 0x88876430, 0x88876431, 0x88764310, 0x88876432, 0x88764320,
+ 0x88764321, 0x87643210, 0x88888765, 0x88887650, 0x88887651, 0x88876510,
+ 0x88887652, 0x88876520, 0x88876521, 0x88765210, 0x88887653, 0x88876530,
+ 0x88876531, 0x88765310, 0x88876532, 0x88765320, 0x88765321, 0x87653210,
+ 0x88887654, 0x88876540, 0x88876541, 0x88765410, 0x88876542, 0x88765420,
+ 0x88765421, 0x87654210, 0x88876543, 0x88765430, 0x88765431, 0x87654310,
+ 0x88765432, 0x87654320, 0x87654321, 0x76543210,
+};
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+if HAVE_BIN
+bin_PROGRAMS = pdtcompose pdtexpand pdtinfo pdtreplace pdtreverse \
+ pdtshortestpath
+
+LDADD = libfstpdtscript.la \
+ ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+
+pdtcompose_SOURCES = pdtcompose.cc
+
+pdtexpand_SOURCES = pdtexpand.cc
+
+pdtinfo_SOURCES = pdtinfo.cc
+
+pdtreplace_SOURCES = pdtreplace.cc
+
+pdtreverse_SOURCES = pdtreverse.cc
+
+pdtshortestpath_SOURCES = pdtshortestpath.cc
+endif
+
+if HAVE_SCRIPT
+lib_LTLIBRARIES = libfstpdtscript.la
+libfstpdtscript_la_SOURCES = getters.cc pdtscript.cc
+libfstpdtscript_la_LDFLAGS = -version-info 6:0:0
+libfstpdtscript_la_LIBADD = ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+endif
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@HAVE_BIN_TRUE@bin_PROGRAMS = pdtcompose$(EXEEXT) pdtexpand$(EXEEXT) \
+@HAVE_BIN_TRUE@ pdtinfo$(EXEEXT) pdtreplace$(EXEEXT) \
+@HAVE_BIN_TRUE@ pdtreverse$(EXEEXT) pdtshortestpath$(EXEEXT)
+subdir = src/extensions/pdt
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+@HAVE_SCRIPT_TRUE@libfstpdtscript_la_DEPENDENCIES = \
+@HAVE_SCRIPT_TRUE@ ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__libfstpdtscript_la_SOURCES_DIST = getters.cc pdtscript.cc
+@HAVE_SCRIPT_TRUE@am_libfstpdtscript_la_OBJECTS = getters.lo \
+@HAVE_SCRIPT_TRUE@ pdtscript.lo
+libfstpdtscript_la_OBJECTS = $(am_libfstpdtscript_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstpdtscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstpdtscript_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_TRUE@am_libfstpdtscript_la_rpath = -rpath $(libdir)
+PROGRAMS = $(bin_PROGRAMS)
+am__pdtcompose_SOURCES_DIST = pdtcompose.cc
+@HAVE_BIN_TRUE@am_pdtcompose_OBJECTS = pdtcompose.$(OBJEXT)
+pdtcompose_OBJECTS = $(am_pdtcompose_OBJECTS)
+pdtcompose_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@pdtcompose_DEPENDENCIES = libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__pdtexpand_SOURCES_DIST = pdtexpand.cc
+@HAVE_BIN_TRUE@am_pdtexpand_OBJECTS = pdtexpand.$(OBJEXT)
+pdtexpand_OBJECTS = $(am_pdtexpand_OBJECTS)
+pdtexpand_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@pdtexpand_DEPENDENCIES = libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__pdtinfo_SOURCES_DIST = pdtinfo.cc
+@HAVE_BIN_TRUE@am_pdtinfo_OBJECTS = pdtinfo.$(OBJEXT)
+pdtinfo_OBJECTS = $(am_pdtinfo_OBJECTS)
+pdtinfo_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@pdtinfo_DEPENDENCIES = libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__pdtreplace_SOURCES_DIST = pdtreplace.cc
+@HAVE_BIN_TRUE@am_pdtreplace_OBJECTS = pdtreplace.$(OBJEXT)
+pdtreplace_OBJECTS = $(am_pdtreplace_OBJECTS)
+pdtreplace_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@pdtreplace_DEPENDENCIES = libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__pdtreverse_SOURCES_DIST = pdtreverse.cc
+@HAVE_BIN_TRUE@am_pdtreverse_OBJECTS = pdtreverse.$(OBJEXT)
+pdtreverse_OBJECTS = $(am_pdtreverse_OBJECTS)
+pdtreverse_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@pdtreverse_DEPENDENCIES = libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am__pdtshortestpath_SOURCES_DIST = pdtshortestpath.cc
+@HAVE_BIN_TRUE@am_pdtshortestpath_OBJECTS = pdtshortestpath.$(OBJEXT)
+pdtshortestpath_OBJECTS = $(am_pdtshortestpath_OBJECTS)
+pdtshortestpath_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@pdtshortestpath_DEPENDENCIES = libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstpdtscript_la_SOURCES) $(pdtcompose_SOURCES) \
+ $(pdtexpand_SOURCES) $(pdtinfo_SOURCES) $(pdtreplace_SOURCES) \
+ $(pdtreverse_SOURCES) $(pdtshortestpath_SOURCES)
+DIST_SOURCES = $(am__libfstpdtscript_la_SOURCES_DIST) \
+ $(am__pdtcompose_SOURCES_DIST) $(am__pdtexpand_SOURCES_DIST) \
+ $(am__pdtinfo_SOURCES_DIST) $(am__pdtreplace_SOURCES_DIST) \
+ $(am__pdtreverse_SOURCES_DIST) \
+ $(am__pdtshortestpath_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+@HAVE_BIN_TRUE@LDADD = libfstpdtscript.la \
+@HAVE_BIN_TRUE@ ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+@HAVE_BIN_TRUE@pdtcompose_SOURCES = pdtcompose.cc
+@HAVE_BIN_TRUE@pdtexpand_SOURCES = pdtexpand.cc
+@HAVE_BIN_TRUE@pdtinfo_SOURCES = pdtinfo.cc
+@HAVE_BIN_TRUE@pdtreplace_SOURCES = pdtreplace.cc
+@HAVE_BIN_TRUE@pdtreverse_SOURCES = pdtreverse.cc
+@HAVE_BIN_TRUE@pdtshortestpath_SOURCES = pdtshortestpath.cc
+@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstpdtscript.la
+@HAVE_SCRIPT_TRUE@libfstpdtscript_la_SOURCES = getters.cc pdtscript.cc
+@HAVE_SCRIPT_TRUE@libfstpdtscript_la_LDFLAGS = -version-info 6:0:0
+@HAVE_SCRIPT_TRUE@libfstpdtscript_la_LIBADD = ../../script/libfstscript.la \
+@HAVE_SCRIPT_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/pdt/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/pdt/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstpdtscript.la: $(libfstpdtscript_la_OBJECTS) $(libfstpdtscript_la_DEPENDENCIES) $(EXTRA_libfstpdtscript_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstpdtscript_la_LINK) $(am_libfstpdtscript_la_rpath) $(libfstpdtscript_la_OBJECTS) $(libfstpdtscript_la_LIBADD) $(LIBS)
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p \
+ || test -f $$p1 \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+
+pdtcompose$(EXEEXT): $(pdtcompose_OBJECTS) $(pdtcompose_DEPENDENCIES) $(EXTRA_pdtcompose_DEPENDENCIES)
+ @rm -f pdtcompose$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(pdtcompose_OBJECTS) $(pdtcompose_LDADD) $(LIBS)
+
+pdtexpand$(EXEEXT): $(pdtexpand_OBJECTS) $(pdtexpand_DEPENDENCIES) $(EXTRA_pdtexpand_DEPENDENCIES)
+ @rm -f pdtexpand$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(pdtexpand_OBJECTS) $(pdtexpand_LDADD) $(LIBS)
+
+pdtinfo$(EXEEXT): $(pdtinfo_OBJECTS) $(pdtinfo_DEPENDENCIES) $(EXTRA_pdtinfo_DEPENDENCIES)
+ @rm -f pdtinfo$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(pdtinfo_OBJECTS) $(pdtinfo_LDADD) $(LIBS)
+
+pdtreplace$(EXEEXT): $(pdtreplace_OBJECTS) $(pdtreplace_DEPENDENCIES) $(EXTRA_pdtreplace_DEPENDENCIES)
+ @rm -f pdtreplace$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(pdtreplace_OBJECTS) $(pdtreplace_LDADD) $(LIBS)
+
+pdtreverse$(EXEEXT): $(pdtreverse_OBJECTS) $(pdtreverse_DEPENDENCIES) $(EXTRA_pdtreverse_DEPENDENCIES)
+ @rm -f pdtreverse$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(pdtreverse_OBJECTS) $(pdtreverse_LDADD) $(LIBS)
+
+pdtshortestpath$(EXEEXT): $(pdtshortestpath_OBJECTS) $(pdtshortestpath_DEPENDENCIES) $(EXTRA_pdtshortestpath_DEPENDENCIES)
+ @rm -f pdtshortestpath$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(pdtshortestpath_OBJECTS) $(pdtshortestpath_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtcompose.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtexpand.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtinfo.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreplace.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtreverse.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtscript.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdtshortestpath.Po@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(PROGRAMS)
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+ clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libtool cscopelist-am ctags ctags-am distclean \
+ distclean-compile distclean-generic distclean-libtool \
+ distclean-tags distdir dvi dvi-am html html-am info info-am \
+ install install-am install-binPROGRAMS install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-libLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \
+ uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/pdt/getters.h>
+
+namespace fst {
+namespace script {
+
+bool GetPdtComposeFilter(const string &str, PdtComposeFilter *cf) {
+ if (str == "expand") {
+ *cf = EXPAND_FILTER;
+ } else if (str == "expand_paren") {
+ *cf = EXPAND_PAREN_FILTER;
+ } else if (str == "paren") {
+ *cf = PAREN_FILTER;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetPdtParserType(const string &str, PdtParserType *pt) {
+ if (str == "left") {
+ *pt = PDT_LEFT_PARSER;
+ } else if (str == "left_sr") {
+ *pt = PDT_LEFT_SR_PARSER;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Composes a PDT and an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/pdt/getters.h>
+#include <fst/extensions/pdt/pdtscript.h>
+#include <fst/util.h>
+
+DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs");
+DEFINE_bool(left_pdt, true, "Is the first argument the PDT?");
+DEFINE_bool(connect, true, "Trim output?");
+DEFINE_string(compose_filter, "paren",
+ "Composition filter, one of: \"expand\", \"expand_paren\", "
+ "\"paren\"");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::ReadLabelPairs;
+ using fst::PdtComposeFilter;
+ using fst::PdtComposeOptions;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Compose a PDT and an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt in.fst [out.pdt]\n";
+ usage += " in.fst in.pdt [out.pdt]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 3 || argc > 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in1_name = strcmp(argv[1], "-") == 0 ? "" : argv[1];
+ const string in2_name = strcmp(argv[2], "-") == 0 ? "" : argv[2];
+ const string out_name = argc > 3 ? argv[3] : "";
+
+ if (in1_name.empty() && in2_name.empty()) {
+ LOG(ERROR) << argv[0] << ": Can't take both inputs from standard input.";
+ return 1;
+ }
+
+ std::unique_ptr<FstClass> ifst1(FstClass::Read(in1_name));
+ if (!ifst1) return 1;
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1;
+
+ VectorFstClass ofst(ifst1->ArcType());
+
+ PdtComposeFilter compose_filter;
+ if (!s::GetPdtComposeFilter(FLAGS_compose_filter, &compose_filter)) {
+ LOG(ERROR) << argv[0] << ": Unknown or unsupported compose filter type: "
+ << FLAGS_compose_filter;
+ return 1;
+ }
+
+ const PdtComposeOptions copts(FLAGS_connect, compose_filter);
+
+ s::PdtCompose(*ifst1, *ifst2, parens, &ofst, copts, FLAGS_left_pdt);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Expands a (bounded-stack) PDT as an FST.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/pdt/pdtscript.h>
+#include <fst/util.h>
+
+DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs");
+DEFINE_bool(connect, true, "Trim output?");
+DEFINE_bool(keep_parentheses, false, "Keep PDT parentheses in result?");
+DEFINE_string(weight, "", "Weight threshold");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::script::WeightClass;
+ using fst::ReadLabelPairs;
+
+ string usage = "Expand a (bounded-stack) PDT as an FST.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1;
+
+ const auto weight_threshold =
+ FLAGS_weight.empty() ? WeightClass::Zero(ifst->WeightType())
+ : WeightClass(ifst->WeightType(), FLAGS_weight);
+
+ VectorFstClass ofst(ifst->ArcType());
+ s::PdtExpand(*ifst, parens, &ofst,
+ s::PdtExpandOptions(FLAGS_connect, FLAGS_keep_parentheses,
+ weight_threshold));
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/pdt/pdtscript.h>
+#include <fst/util.h>
+
+DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::ReadLabelPairs;
+ using fst::script::FstClass;
+
+ string usage = "Prints out information about a PDT.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 2) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1;
+
+ s::PrintPdtInfo(*ifst, parens);
+
+ return 0;
+}
--- /dev/null
+// 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 <cstring>
+
+#include <string>
+#include <vector>
+
+#include <fst/extensions/pdt/getters.h>
+#include <fst/extensions/pdt/pdtscript.h>
+#include <fst/util.h>
+#include <fst/vector-fst.h>
+
+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 main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::PdtParserType;
+ using fst::WriteLabelPairs;
+
+ string usage = "Converts an RTN represented by FSTs";
+ usage += " and non-terminal labels into PDT.\n\n Usage: ";
+ usage += argv[0];
+ usage += " root.fst rootlabel [rule1.fst label1 ...] [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc < 4) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name = argv[1];
+ const string out_name = argc % 2 == 0 ? argv[argc - 1] : "";
+
+ // Replace takes ownership of the pointer of FST arrays, deleting all such
+ // pointers when the underlying ReplaceFst is destroyed.
+ 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;
+ return 1;
+ }
+
+ std::vector<s::LabelFstClassPair> 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) 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<s::LabelPair> parens;
+ s::PdtReplace(pairs, &ofst, &parens, root, parser_type,
+ FLAGS_start_paren_labels, FLAGS_left_paren_prefix,
+ FLAGS_right_paren_prefix);
+
+ if (!FLAGS_pdt_parentheses.empty()) {
+ if (!WriteLabelPairs(FLAGS_pdt_parentheses, parens)) return 1;
+ }
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Reverses a PDT.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/pdt/pdtscript.h>
+#include <fst/util.h>
+
+DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::ReadLabelPairs;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+
+ string usage = "Reverse a PDT.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1;
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ s::PdtReverse(*ifst, parens, &ofst);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+// 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 <string>
+#include <vector>
+
+#include <fst/extensions/pdt/compose.h>
+#include <fst/extensions/pdt/expand.h>
+#include <fst/extensions/pdt/pdtscript.h>
+#include <fst/extensions/pdt/replace.h>
+#include <fst/extensions/pdt/reverse.h>
+#include <fst/extensions/pdt/shortest-path.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void PdtCompose(const FstClass &ifst1, const FstClass &ifst2,
+ const std::vector<LabelPair> &parens,
+ MutableFstClass *ofst, const PdtComposeOptions &copts,
+ bool left_pdt) {
+ if (!ArcTypesMatch(ifst1, ifst2, "PdtCompose") ||
+ !ArcTypesMatch(ifst1, *ofst, "PdtCompose"))
+ return;
+ PdtComposeArgs args(ifst1, ifst2, parens, ofst, copts, left_pdt);
+ Apply<Operation<PdtComposeArgs>>("PdtCompose", ifst1.ArcType(), &args);
+}
+
+void PdtExpand(const FstClass &ifst,
+ const std::vector<LabelPair> &parens,
+ MutableFstClass *ofst, const PdtExpandOptions &opts) {
+ PdtExpandArgs args(ifst, parens, ofst, opts);
+ Apply<Operation<PdtExpandArgs>>("PdtExpand", ifst.ArcType(), &args);
+}
+
+void PdtExpand(const FstClass &ifst,
+ const std::vector<std::pair<int64, int64>> &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<LabelFstClassPair> &pairs,
+ MutableFstClass *ofst, std::vector<LabelPair> *parens,
+ int64 root, PdtParserType parser_type, int64 start_paren_labels,
+ const string &left_paren_prefix,
+ const string &right_paren_prefix) {
+ for (auto i = 0; i < pairs.size() - 1; ++i) {
+ if (!ArcTypesMatch(*pairs[i].second, *pairs[i + 1].second, "PdtReplace"))
+ return;
+ }
+ if (!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<Operation<PdtReplaceArgs>>("PdtReplace", ofst->ArcType(), &args);
+}
+
+void PdtReverse(const FstClass &ifst,
+ const std::vector<LabelPair> &parens,
+ MutableFstClass *ofst) {
+ PdtReverseArgs args(ifst, parens, ofst);
+ Apply<Operation<PdtReverseArgs>>("PdtReverse", ifst.ArcType(), &args);
+}
+
+void PdtShortestPath(const FstClass &ifst,
+ const std::vector<LabelPair> &parens,
+ MutableFstClass *ofst,
+ const PdtShortestPathOptions &opts) {
+ PdtShortestPathArgs args(ifst, parens, ofst, opts);
+ Apply<Operation<PdtShortestPathArgs>>("PdtShortestPath", ifst.ArcType(),
+ &args);
+}
+
+void PrintPdtInfo(const FstClass &ifst,
+ const std::vector<LabelPair> &parens) {
+ PrintPdtInfoArgs args(ifst, parens);
+ Apply<Operation<PrintPdtInfoArgs>>("PrintPdtInfo", ifst.ArcType(), &args);
+}
+
+// Register operations for common arc types.
+
+REGISTER_FST_PDT_OPERATIONS(StdArc);
+REGISTER_FST_PDT_OPERATIONS(LogArc);
+REGISTER_FST_PDT_OPERATIONS(Log64Arc);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Returns the shortest path in a (bounded-stack) PDT.
+
+#include <cstring>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/pdt/pdtscript.h>
+#include <fst/util.h>
+
+DEFINE_bool(keep_parentheses, false, "Keep PDT parentheses in result?");
+DEFINE_string(queue_type, "fifo",
+ "Queue type: one of: "
+ "\"fifo\", \"lifo\", \"state\"");
+DEFINE_bool(path_gc, true, "Garbage collect shortest path data?");
+DEFINE_string(pdt_parentheses, "", "PDT parenthesis label pairs");
+
+int main(int argc, char **argv) {
+ namespace s = fst::script;
+ using fst::script::FstClass;
+ using fst::script::VectorFstClass;
+ using fst::QueueType;
+ using fst::ReadLabelPairs;
+
+ string usage = "Shortest path in a (bounded-stack) PDT.\n\n Usage: ";
+ usage += argv[0];
+ usage += " in.pdt [out.fst]\n";
+
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(usage.c_str(), &argc, &argv, true);
+ if (argc > 3) {
+ ShowUsage();
+ return 1;
+ }
+
+ const string in_name =
+ (argc > 1 && (strcmp(argv[1], "-") != 0)) ? argv[1] : "";
+ const string out_name = argc > 2 ? argv[2] : "";
+
+ std::unique_ptr<FstClass> 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<s::LabelPair> parens;
+ if (!ReadLabelPairs(FLAGS_pdt_parentheses, &parens, false)) return 1;
+
+ VectorFstClass ofst(ifst->ArcType());
+
+ QueueType qt;
+ if (FLAGS_queue_type == "fifo") {
+ qt = fst::FIFO_QUEUE;
+ } else if (FLAGS_queue_type == "lifo") {
+ qt = fst::LIFO_QUEUE;
+ } else if (FLAGS_queue_type == "state") {
+ qt = fst::STATE_ORDER_QUEUE;
+ } else {
+ LOG(ERROR) << "Unknown queue type: " << FLAGS_queue_type;
+ return 1;
+ }
+
+ const s::PdtShortestPathOptions opts(qt, FLAGS_keep_parentheses,
+ FLAGS_path_gc);
+
+ s::PdtShortestPath(*ifst, parens, &ofst, opts);
+
+ ofst.Write(out_name);
+
+ return 0;
+}
--- /dev/null
+# NB: we use the Cython-generated .cc files rather than the *.pxd/.pyx sources
+# used to generate them. Consequently, modifications to the .pyx files will not
+# influence the build unless the .cc files are regenerated using Cython.
+
+python_LTLIBRARIES = pywrapfst.la
+
+pyexec_LTILIBRARIES = pywrapfst.la
+
+pywrapfst_la_SOURCES = pywrapfst.cc
+pywrapfst_la_CPPFLAGS = -I$(srcdir)/../../include $(PYTHON_CPPFLAGS)
+pywrapfst_la_LDFLAGS = $(PYTHON_LDFLAGS) -avoid-version -module
+pywrapfst_la_LIBADD = ../far/libfstfarscript.la ../far/libfstfar.la \
+ ../../script/libfstscript.la ../../lib/libfst.la \
+ -lm $(DL_LIBS)
+
+# Exports the *.pxd/*.pxd source files.
+EXTRA_DIST = basictypes.pxd fst.pxd ios.pxd memory.pxd pywrapfst.pxd \
+ pywrapfst.pyx
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# NB: we use the Cython-generated .cc files rather than the *.pxd/.pyx sources
+# used to generate them. Consequently, modifications to the .pyx files will not
+# influence the build unless the .cc files are regenerated using Cython.
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/extensions/python
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(pythondir)"
+LTLIBRARIES = $(python_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+pywrapfst_la_DEPENDENCIES = ../far/libfstfarscript.la \
+ ../far/libfstfar.la ../../script/libfstscript.la \
+ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+am_pywrapfst_la_OBJECTS = pywrapfst_la-pywrapfst.lo
+pywrapfst_la_OBJECTS = $(am_pywrapfst_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+pywrapfst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(pywrapfst_la_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(pywrapfst_la_SOURCES)
+DIST_SOURCES = $(pywrapfst_la_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+python_LTLIBRARIES = pywrapfst.la
+pyexec_LTILIBRARIES = pywrapfst.la
+pywrapfst_la_SOURCES = pywrapfst.cc
+pywrapfst_la_CPPFLAGS = -I$(srcdir)/../../include $(PYTHON_CPPFLAGS)
+pywrapfst_la_LDFLAGS = $(PYTHON_LDFLAGS) -avoid-version -module
+pywrapfst_la_LIBADD = ../far/libfstfarscript.la ../far/libfstfar.la \
+ ../../script/libfstscript.la ../../lib/libfst.la \
+ -lm $(DL_LIBS)
+
+
+# Exports the *.pxd/*.pxd source files.
+EXTRA_DIST = basictypes.pxd fst.pxd ios.pxd memory.pxd pywrapfst.pxd \
+ pywrapfst.pyx
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/python/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/python/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-pythonLTLIBRARIES: $(python_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(python_LTLIBRARIES)'; test -n "$(pythondir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(pythondir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(pythondir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(pythondir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(pythondir)"; \
+ }
+
+uninstall-pythonLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(python_LTLIBRARIES)'; test -n "$(pythondir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(pythondir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(pythondir)/$$f"; \
+ done
+
+clean-pythonLTLIBRARIES:
+ -test -z "$(python_LTLIBRARIES)" || rm -f $(python_LTLIBRARIES)
+ @list='$(python_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+pywrapfst.la: $(pywrapfst_la_OBJECTS) $(pywrapfst_la_DEPENDENCIES) $(EXTRA_pywrapfst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(pywrapfst_la_LINK) -rpath $(pythondir) $(pywrapfst_la_OBJECTS) $(pywrapfst_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pywrapfst_la-pywrapfst.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+pywrapfst_la-pywrapfst.lo: pywrapfst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(pywrapfst_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT pywrapfst_la-pywrapfst.lo -MD -MP -MF $(DEPDIR)/pywrapfst_la-pywrapfst.Tpo -c -o pywrapfst_la-pywrapfst.lo `test -f 'pywrapfst.cc' || echo '$(srcdir)/'`pywrapfst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/pywrapfst_la-pywrapfst.Tpo $(DEPDIR)/pywrapfst_la-pywrapfst.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='pywrapfst.cc' object='pywrapfst_la-pywrapfst.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(pywrapfst_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o pywrapfst_la-pywrapfst.lo `test -f 'pywrapfst.cc' || echo '$(srcdir)/'`pywrapfst.cc
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+ for dir in "$(DESTDIR)$(pythondir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-pythonLTLIBRARIES \
+ mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-pythonLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-pythonLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libtool clean-pythonLTLIBRARIES cscopelist-am ctags \
+ ctags-am distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-man install-pdf install-pdf-am \
+ install-ps install-ps-am install-pythonLTLIBRARIES \
+ install-strip installcheck installcheck-am installdirs \
+ maintainer-clean maintainer-clean-generic mostlyclean \
+ mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+ pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \
+ uninstall-pythonLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+# See www.openfst.org for extensive documentation on this weighted
+# finite-state transducer library.
+
+
+from libc.stdint cimport *
+
+
+cdef extern from "<fst/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
--- /dev/null
+# See www.openfst.org for extensive documentation on this weighted
+# finite-state transducer library.
+
+
+from libc.time cimport time_t
+from libc.time cimport time
+
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+
+from basictypes cimport int32
+from basictypes cimport int64
+from basictypes cimport uint32
+from basictypes cimport uint64
+from libcpp.string cimport string
+from ios cimport istream
+from ios cimport ostream
+
+
+cdef extern from "<fst/util.h>" nogil:
+
+ # Note that this is a copy, so it should be viewed as read-only.
+
+ bool FLAGS_fst_error_fatal
+
+
+cdef extern from "<fst/fstlib.h>" namespace "fst" nogil:
+
+ 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
+
+ # Default argument constants.
+ const float kDelta
+ const int64 kNoStateId
+
+ # EncodeMapper flags.
+ const uint32 kEncodeLabels
+ const uint32 kEncodeWeights
+ const uint32 kEncodeFlags
+
+ # Push flags.
+ const uint32 kPushLabels
+ const uint32 kPushRemoveCommonAffix
+ const uint32 kPushRemoveTotalWeight
+ const uint32 kPushWeights
+
+
+ enum ClosureType:
+ CLOSURE_STAR
+ CLOSURE_PLUS
+
+
+ enum ComposeFilter:
+ AUTO_FILTER
+ NULL_FILTER
+ SEQUENCE_FILTER
+ ALT_SEQUENCE_FILTER
+ MATCH_FILTER
+ TRIVIAL_FILTER
+
+
+ enum DeterminizeType:
+ DETERMINIZE_FUNCTIONAL
+ DETERMINIZE_NONFUNCTIONAL
+ DETERMINIZE_DISAMBIGUATE
+
+
+ enum EncodeType:
+ DECODE
+ ENCODE
+
+
+ enum EpsNormalizeType:
+ EPS_NORM_INPUT
+ EPS_NORM_OUTPUT
+
+
+ enum ProjectType:
+ PROJECT_INPUT
+ PROJECT_OUTPUT
+
+
+ enum QueueType:
+ TRIVIAL_QUEUE
+ FIFO_QUEUE
+ LIFO_QUEUE
+ SHORTEST_FIRST_QUEUE
+ TOP_ORDER_QUEUE
+ STATE_ORDER_QUEUE
+ SCC_QUEUE
+ AUTO_QUEUE
+ OTHER_QUEUE
+
+
+ # This is a templated struct at the C++ level, but Cython does not support
+ # templated structs unless we pretend they are full-blown classes.
+ cdef cppclass RandGenOptions[RandArcSelection]:
+
+ RandGenOptions(const RandArcSelection &, int32, int32, bool, bool)
+
+
+ enum ReplaceLabelType:
+ REPLACE_LABEL_NEITHER
+ REPLACE_LABEL_INPUT
+ REPLACE_LABEL_OUTPUT
+ REPLACE_LABEL_BOTH
+
+
+ enum ReweightType:
+ REWEIGHT_TO_INITIAL
+ REWEIGHT_TO_FINAL
+
+
+ cdef cppclass SymbolTableTextOptions:
+
+ SymbolTableTextOptions(bool)
+
+
+ # Symbol tables.
+ cdef cppclass SymbolTable:
+
+ SymbolTable()
+
+ SymbolTable(const string &)
+
+ @staticmethod
+ SymbolTable *Read(const string &)
+
+ @staticmethod
+ SymbolTable *ReadText(const string &, const SymbolTableTextOptions &)
+
+ int64 AddSymbol(const string &, int64)
+
+ int64 AddSymbol(const string &)
+
+ SymbolTable *Copy()
+
+ # Aliased so the Cython transpiler can sort out the overloading.
+
+ string FindSymbol "Find"(int64)
+
+ int64 FindIndex "Find"(string)
+
+ # Aliased so the Cython transpiler can sort out the overloading.
+
+ bool MemberSymbol "Member"(string)
+
+ bool MemberIndex "Member"(int64)
+
+ void AddTable(const SymbolTable &)
+
+ int64 GetNthKey(ssize_t)
+
+ const string &Name()
+
+ void SetName(const string &)
+
+ string CheckSum()
+
+ string LabeledCheckSum()
+
+ bool Write(const string &)
+
+ bool WriteText(const string &)
+
+ int64 AvailableKey()
+
+ size_t NumSymbols()
+
+
+ SymbolTable *CompactSymbolTable(const SymbolTable &syms)
+
+ SymbolTable *MergeSymbolTable(const SymbolTable &, const SymbolTable &,
+ bool *)
+
+ SymbolTable *FstReadSymbols(const string &, bool)
+
+
+ cdef cppclass SymbolTableIterator:
+
+ SymbolTableIterator(const SymbolTable &)
+
+ bool Done()
+
+ void Next()
+
+ void Reset()
+
+ string Symbol()
+
+ int64 Value()
+
+
+cdef extern from "<fst/script/fstscript.h>" namespace "fst::script" nogil:
+
+
+ # Weights.
+ cdef cppclass WeightClass:
+
+ WeightClass()
+
+ WeightClass(const WeightClass &)
+
+ WeightClass(const string &, const string &)
+
+ const string &Type()
+
+ string ToString()
+
+ @staticmethod
+ const WeightClass &Zero(const string &)
+
+ @staticmethod
+ const WeightClass &One(const string &)
+
+ @staticmethod
+ const WeightClass &NoWeight(const string &)
+
+ cdef WeightClass Plus(const WeightClass &, const WeightClass &)
+
+ cdef WeightClass Times(const WeightClass &, const WeightClass &)
+
+ cdef WeightClass Divide(const WeightClass &, const WeightClass &)
+
+ cdef WeightClass Power(const WeightClass &, size_t)
+
+ # Arcs.
+ cdef cppclass ArcClass:
+
+ ArcClass(const ArcClass &)
+
+ ArcClass(int64, int64, const WeightClass &, int64)
+
+ int64 ilabel
+ int64 olabel
+ WeightClass weight
+ int64 nextstate
+
+
+ # FSTs.
+
+
+ cdef cppclass FstClass:
+
+ FstClass(const FstClass &)
+
+ @staticmethod
+ FstClass *Read(const string &)
+
+ @staticmethod
+ FstClass *ReadFromString(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 &)
+
+ const string WriteToString()
+
+ uint64 Properties(uint64, bool)
+
+ bool ValidStateId(int64)
+
+
+ cdef cppclass MutableFstClass(FstClass):
+
+ bool AddArc(int64, const ArcClass &)
+
+ int64 AddState()
+
+ bool DeleteArcs(int64, size_t)
+
+ bool DeleteArcs(int64)
+
+ bool DeleteStates(const vector[int64] &)
+
+ void DeleteStates()
+
+ SymbolTable *MutableInputSymbols()
+
+ SymbolTable *MutableOutputSymbols()
+
+ int64 NumStates()
+
+ bool ReserveArcs(int64, size_t)
+
+ void ReserveStates(int64)
+
+ bool SetStart(int64)
+
+ bool SetFinal(int64, const WeightClass &)
+
+ void SetInputSymbols(SymbolTable *)
+
+ void SetOutputSymbols(SymbolTable *)
+
+ void SetProperties(uint64, uint64)
+
+ cdef cppclass VectorFstClass(MutableFstClass):
+
+ VectorFstClass(const FstClass &)
+
+ VectorFstClass(const string &)
+
+
+ # EncodeMapper.
+ cdef cppclass EncodeMapperClass:
+
+ EncodeMapperClass(const string &, uint32, EncodeType)
+
+ # Aliases this to "__call__", since Cython doesn't have good support for
+ # this C++ operator.
+ ArcClass __call__ "operator()"(const ArcClass &)
+
+ const string &ArcType()
+
+ uint32 Flags()
+
+ uint64 Properties(uint64)
+
+ EncodeType Type()
+
+ const SymbolTable *InputSymbols()
+
+ const SymbolTable *OutputSymbols()
+
+ void SetInputSymbols(const SymbolTable *)
+
+ void SetOutputSymbols(const SymbolTable *)
+
+ const string &WeightType()
+
+
+ # Iterators.
+
+
+ cdef cppclass ArcIteratorClass:
+
+ ArcIteratorClass(const FstClass &, int64)
+
+ bool Done()
+
+ ArcClass Value()
+
+ void Next()
+
+ void Reset()
+
+ void Seek(size_t)
+
+ size_t Position()
+
+ uint32 Flags()
+
+ void SetFlags(uint32, uint32)
+
+ cdef cppclass MutableArcIteratorClass:
+
+ MutableArcIteratorClass(MutableFstClass *, int64)
+
+ bool Done()
+
+ ArcClass Value()
+
+ void Next()
+
+ void Reset()
+
+ void Seek(size_t)
+
+ void SetValue(const ArcClass &)
+
+ size_t Position()
+
+ uint32 Flags()
+
+ void SetFlags(uint32, uint32)
+
+ cdef cppclass StateIteratorClass:
+
+ StateIteratorClass(const FstClass &)
+
+ bool Done()
+
+ int64 Value()
+
+ void Next()
+
+ void Reset()
+
+
+ctypedef pair[int64, const FstClass *] LabelFstClassPair
+
+ctypedef pair[int64, int64] LabelPair
+
+
+cdef extern from "<fst/script/fstscript.h>" 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 cppclass ComposeOptions:
+
+ ComposeOptions(bool, ComposeFilter)
+
+ cdef void Compose(FstClass &, FstClass &, MutableFstClass *,
+ const ComposeOptions &)
+
+ cdef void Concat(MutableFstClass *, const FstClass &)
+
+ cdef void Connect(MutableFstClass *)
+
+ cdef FstClass *Convert(const FstClass &, const string &)
+
+ cdef void Decode(MutableFstClass *, const EncodeMapperClass &)
+
+ cdef cppclass DeterminizeOptions:
+
+ DeterminizeOptions(float, const WeightClass &, int64, int64,
+ DeterminizeType, bool)
+
+ cdef void Determinize(const FstClass &, MutableFstClass *,
+ const DeterminizeOptions &)
+
+ cdef cppclass DisambiguateOptions:
+
+ DisambiguateOptions(float, const WeightClass &, int64, int64)
+
+ cdef void Disambiguate(const FstClass &, MutableFstClass *,
+ const DisambiguateOptions &)
+
+ cdef void Difference(const FstClass &, const FstClass &, MutableFstClass *,
+ const ComposeOptions &)
+
+ cdef void DrawFst(const FstClass &fst, const SymbolTable *,
+ const SymbolTable *, const SymbolTable *, bool,
+ const string &, float, float, bool, bool, float, float, int,
+ int, 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, bool *)
+
+ 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, const WeightClass &)
+
+ cdef void Minimize(MutableFstClass *, MutableFstClass *, float, bool)
+
+ cdef ProjectType GetProjectType(bool)
+
+ cdef void Project(MutableFstClass *, ProjectType)
+
+ cdef void PrintFst(const FstClass &, ostream &, const string &,
+ const SymbolTable *, const SymbolTable *,
+ const SymbolTable *, bool, bool, const string &)
+
+ cdef void Prune(const FstClass &, MutableFstClass *, const WeightClass &,
+ int64, float)
+
+ cdef void Prune(MutableFstClass *, const WeightClass &, int64, float)
+
+ cdef void Push(const FstClass &, MutableFstClass *, uint32 flags,
+ ReweightType, float)
+
+ cdef void Push(MutableFstClass *, ReweightType, float, bool)
+
+ enum RandArcSelection:
+ UNIFORM_ARC_SELECTOR
+ LOG_PROB_ARC_SELECTOR
+ FAST_LOG_PROB_ARC_SELECTOR
+
+ cdef bool RandEquivalent(const FstClass &, const FstClass &, int32, float,
+ time_t, const RandGenOptions[RandArcSelection] &,
+ bool *)
+
+ cdef void RandGen(const FstClass &, MutableFstClass *, time_t,
+ const RandGenOptions[RandArcSelection] &)
+
+ cdef void Relabel(MutableFstClass *,
+ const SymbolTable *, const SymbolTable *, bool,
+ const SymbolTable *, const SymbolTable *, bool)
+
+ cdef void Relabel(MutableFstClass *, const vector[LabelPair] &,
+ const vector[LabelPair] &)
+
+ cdef void Relabel(MutableFstClass *, const SymbolTable *, const SymbolTable *)
+
+ 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, float, bool, const WeightClass &, int64)
+
+ cdef void RmEpsilon(const FstClass &, MutableFstClass *, bool,
+ const RmEpsilonOptions &)
+
+ cdef void RmEpsilon(MutableFstClass *, bool, const WeightClass &, int64,
+ float)
+
+ 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, bool, float, bool,
+ const WeightClass &, int64)
+
+ cdef void ShortestPath(const FstClass &, MutableFstClass *,
+ vector[WeightClass] *, const ShortestPathOptions &)
+
+ cdef void Synchronize(const FstClass &, MutableFstClass *)
+
+ cdef bool TopSort(MutableFstClass *)
+
+ cdef void Union(MutableFstClass *, const FstClass &)
+
+ cdef bool Verify(const FstClass &)
+
+
+cdef extern from "nlp/fst/script/getters.h" namespace "fst::script" nogil:
+
+ cdef bool GetArcSortType(const string &, ArcSortType *)
+
+ cdef bool GetComposeFilter(const string &, ComposeFilter *)
+
+ cdef bool GetDeterminizeType(const string &, DeterminizeType *)
+
+ cdef uint32 GetEncodeFlags(bool, bool)
+
+ cdef bool GetMapType(const string &, MapType *)
+
+ cdef uint32 GetPushFlags(bool, bool, bool, bool)
+
+ cdef bool GetQueueType(const string &, QueueType *)
+
+ cdef bool GetRandArcSelection(const string &, RandArcSelection *)
+
+ cdef bool GetReplaceLabelType(string, bool, ReplaceLabelType *)
+
+ cdef ReweightType GetReweightType(bool)
+
+
+cdef extern from "<fst/extensions/far/far.h>" namespace "fst" nogil:
+
+ enum FarType:
+ FAR_DEFAULT
+ FAR_STTABLE
+ FAR_STLIST
+ FAR_FST
+ FAR_SSTABLE
+
+cdef extern from "<fst/extensions/far/getters.h>" \
+ namespace "fst" nogil:
+
+ string GetFarTypeString(FarType)
+
+
+cdef extern from "<fst/extensions/far/getters.h>" \
+ namespace "fst::script" nogil:
+
+ FarType GetFarType(const string &)
+
+
+cdef extern from "<fst/extensions/far/far-class.h>" \
+ 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)
--- /dev/null
+# See www.openfst.org for extensive documentation on this weighted
+# finite-state transducer library.
+
+
+from basictypes cimport int8
+from basictypes cimport int16
+from basictypes cimport int32
+from basictypes cimport int64
+from basictypes cimport uint8
+from basictypes cimport uint16
+from basictypes cimport uint32
+from basictypes cimport uint64
+from libcpp.string cimport string
+
+
+cdef extern from "<iostream>" 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 "<fstream>" namespace "std" nogil:
+
+ cdef cppclass ifstream(istream):
+
+ ifstream(const char *)
+
+ cdef cppclass ofstream(ostream):
+
+ ofstream(const char *)
+
+
+cdef extern from "<sstream>" namespace "std" nogil:
+
+ cdef cppclass stringstream(istream, ostream):
+
+ stringstream()
+
+ string str()
+
+ stringstream &operator<<(const string &)
+
+ stringstream &operator<<(bool)
+
+ # We define these in terms of the Google basictypes.
+
+ stringstream &operator<<(int8)
+
+ stringstream &operator<<(uint8)
+
+ stringstream &operator<<(int16)
+
+ stringstream &operator<<(uint16)
+
+ stringstream &operator<<(int32)
+
+ stringstream &operator<<(uint32)
+
+ stringstream &operator<<(int64)
+
+ stringstream &operator<<(uint64)
+
+ stringstream &operator<<(double)
+
+ stringstream &operator<<(long double)
--- /dev/null
+# See www.openfst.org for extensive documentation on this weighted
+# finite-state transducer library.
+
+
+from libcpp.memory cimport shared_ptr
+
+
+# This is mysteriously missing from libcpp.memory.
+
+cdef extern from "<memory>" namespace "std" nogil:
+
+ shared_ptr[T] static_pointer_cast[T, U](const shared_ptr[U] &)
--- /dev/null
+/* Generated by Cython 0.25.2 */
+
+#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 < 0x03020000)
+ #error Cython requires Python 2.6+ or Python 3.2+.
+#else
+#define CYTHON_ABI "0_25_2"
+#include <stddef.h>
+#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
+#ifndef HAVE_LONG_LONG
+ #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && 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_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #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
+#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_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
+#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_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
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+ #include "longintrepr.h"
+ #undef SHIFT
+ #undef BASE
+ #undef MASK
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+ #define Py_OptimizeFlag 0
+#endif
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+ #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+ #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+ #define __Pyx_DefaultClassType PyClass_Type
+#else
+ #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+ #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+ #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+ #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+ #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+ #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+ #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_FASTCALL
+ #define METH_FASTCALL 0x80
+ typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args,
+ Py_ssize_t nargs, PyObject *kwnames);
+#else
+ #define __Pyx_PyCFunctionFast _PyCFunctionFast
+#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)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+ #define CYTHON_PEP393_ENABLED 1
+ #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\
+ 0 : _PyUnicode_Ready((PyObject *)(op)))
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)
+ #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)
+ #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
+ #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch)
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+#else
+ #define CYTHON_PEP393_ENABLED 0
+ #define PyUnicode_1BYTE_KIND 1
+ #define PyUnicode_2BYTE_KIND 2
+ #define PyUnicode_4BYTE_KIND 4
+ #define __Pyx_PyUnicode_READY(op) (0)
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
+ #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))
+ #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
+ #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+ #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)
+#else
+ #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
+ #define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
+ #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+ #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+ #define PyObject_Malloc(s) PyMem_Malloc(s)
+ #define PyObject_Free(p) PyMem_Free(p)
+ #define PyObject_Realloc(p) PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_PYSTON
+ #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co)
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#else
+ #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)
+#endif
+#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)
+#else
+ #define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+ #define PyObject_ASCII(o) PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyBaseString_Type PyUnicode_Type
+ #define PyStringObject PyUnicodeObject
+ #define PyString_Type PyUnicode_Type
+ #define PyString_Check PyUnicode_Check
+ #define PyString_CheckExact PyUnicode_CheckExact
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+ #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+ #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+ #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+ #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)
+#endif
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+#if PY_MAJOR_VERSION >= 3
+ #define PyIntObject PyLongObject
+ #define PyInt_Type PyLong_Type
+ #define PyInt_Check(op) PyLong_Check(op)
+ #define PyInt_CheckExact(op) PyLong_CheckExact(op)
+ #define PyInt_FromString PyLong_FromString
+ #define PyInt_FromUnicode PyLong_FromUnicode
+ #define PyInt_FromLong PyLong_FromLong
+ #define PyInt_FromSize_t PyLong_FromSize_t
+ #define PyInt_FromSsize_t PyLong_FromSsize_t
+ #define PyInt_AsLong PyLong_AsLong
+ #define PyInt_AS_LONG PyLong_AS_LONG
+ #define PyInt_AsSsize_t PyLong_AsSsize_t
+ #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
+ #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+ #define PyNumber_Int PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyBoolObject PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+ #ifndef PyUnicode_InternFromString
+ #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+ #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+ typedef long Py_hash_t;
+ #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+ #define __Pyx_PyInt_AsHash_t PyInt_AsLong
+#else
+ #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+ #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
+#else
+ #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
+#endif
+#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
+ typedef struct {
+ unaryfunc am_await;
+ unaryfunc am_aiter;
+ unaryfunc am_anext;
+ } __Pyx_PyAsyncMethodsStruct;
+ #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+ #endif
+#else
+ #define __Pyx_PyType_AsAsync(obj) NULL
+#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<class T> 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)
+
+#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<typename T>
+void __Pyx_call_destructor(T& x) {
+ x.~T();
+}
+template<typename T>
+class __Pyx_FakeReference {
+ public:
+ __Pyx_FakeReference() : ptr(NULL) { }
+ __Pyx_FakeReference(const T& ref) : ptr(const_cast<T*>(&ref)) { }
+ T *operator->() { return ptr; }
+ T *operator&() { return ptr; }
+ operator T&() { return *ptr; }
+ template<typename U> bool operator ==(U other) { return *ptr == other; }
+ template<typename U> bool operator !=(U other) { return *ptr != other; }
+ private:
+ T *ptr;
+};
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+ #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+ float value;
+ memset(&value, 0xFF, sizeof(value));
+ return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+{ \
+ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
+}
+
+#if PY_MAJOR_VERSION >= 3
+ #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
+
+#ifndef __PYX_EXTERN_C
+ #ifdef __cplusplus
+ #define __PYX_EXTERN_C extern "C"
+ #else
+ #define __PYX_EXTERN_C extern
+ #endif
+#endif
+
+#define __PYX_HAVE__pywrapfst
+#define __PYX_HAVE_API__pywrapfst
+#include <stddef.h>
+#include <time.h>
+#include <memory>
+#include "ios"
+#include "new"
+#include "stdexcept"
+#include "typeinfo"
+#include <utility>
+#include <vector>
+#include <stdint.h>
+#include <string.h>
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <fst/util.h>
+#include <fst/fstlib.h>
+#include <fst/script/fstscript.h>
+#include <fst/script/getters.h>
+#include <fst/extensions/far/far.h>
+#include <fst/extensions/far/getters.h>
+#include <fst/extensions/far/far-class.h>
+#include <sys/types.h>
+#include <unistd.h>
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#ifdef PYREX_WITHOUT_ASSERTIONS
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+ const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\
+ (sizeof(type) < sizeof(Py_ssize_t)) ||\
+ (sizeof(type) > sizeof(Py_ssize_t) &&\
+ likely(v < (type)PY_SSIZE_T_MAX ||\
+ v == (type)PY_SSIZE_T_MAX) &&\
+ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+ v == (type)PY_SSIZE_T_MIN))) ||\
+ (sizeof(type) == sizeof(Py_ssize_t) &&\
+ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+ v == (type)PY_SSIZE_T_MAX))) )
+#if defined (__cplusplus) && __cplusplus >= 201103L
+ #include <cstdlib>
+ #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) && defined (_M_X64)
+ #define __Pyx_sst_abs(value) _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 char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE 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_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s) ((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)
+#if PY_MAJOR_VERSION < 3
+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);
+}
+#else
+#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
+#endif
+#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+ PyObject* sys;
+ PyObject* default_encoding = NULL;
+ PyObject* ascii_chars_u = NULL;
+ PyObject* ascii_chars_b = NULL;
+ const char* default_encoding_c;
+ sys = PyImport_ImportModule("sys");
+ if (!sys) goto bad;
+ default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+ Py_DECREF(sys);
+ if (!default_encoding) goto bad;
+ default_encoding_c = PyBytes_AsString(default_encoding);
+ if (!default_encoding_c) goto bad;
+ if (strcmp(default_encoding_c, "ascii") == 0) {
+ __Pyx_sys_getdefaultencoding_not_ascii = 0;
+ } else {
+ char ascii_chars[128];
+ int c;
+ for (c = 0; c < 128; c++) {
+ ascii_chars[c] = c;
+ }
+ __Pyx_sys_getdefaultencoding_not_ascii = 1;
+ ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+ if (!ascii_chars_u) goto bad;
+ ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+ if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+ PyErr_Format(
+ PyExc_ValueError,
+ "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+ default_encoding_c);
+ goto bad;
+ }
+ Py_DECREF(ascii_chars_u);
+ Py_DECREF(ascii_chars_b);
+ }
+ Py_DECREF(default_encoding);
+ return 0;
+bad:
+ Py_XDECREF(default_encoding);
+ Py_XDECREF(ascii_chars_u);
+ Py_XDECREF(ascii_chars_b);
+ return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+ PyObject* sys;
+ PyObject* default_encoding = NULL;
+ char* default_encoding_c;
+ sys = PyImport_ImportModule("sys");
+ if (!sys) goto bad;
+ default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+ Py_DECREF(sys);
+ if (!default_encoding) goto bad;
+ default_encoding_c = PyBytes_AsString(default_encoding);
+ if (!default_encoding_c) goto bad;
+ __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
+ if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+ strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+ Py_DECREF(default_encoding);
+ return 0;
+bad:
+ Py_XDECREF(default_encoding);
+ return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+ #define likely(x) __builtin_expect(!!(x), 1)
+ #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+ #define likely(x) (x)
+ #define unlikely(x) (x)
+#endif /* __GNUC__ */
+
+static PyObject *__pyx_m;
+static PyObject *__pyx_d;
+static PyObject *__pyx_b;
+static PyObject *__pyx_empty_tuple;
+static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+
+static const char *__pyx_f[] = {
+ "pywrapfst.pyx",
+ "stringsource",
+};
+
+/* "basictypes.pxd":22
+ *
+ *
+ * ctypedef int8_t int8 # <<<<<<<<<<<<<<
+ * ctypedef int16_t int16
+ * ctypedef int32_t int32
+ */
+typedef int8_t __pyx_t_10basictypes_int8;
+
+/* "basictypes.pxd":23
+ *
+ * ctypedef int8_t int8
+ * ctypedef int16_t int16 # <<<<<<<<<<<<<<
+ * ctypedef int32_t int32
+ * ctypedef int64_t int64
+ */
+typedef int16_t __pyx_t_10basictypes_int16;
+
+/* "basictypes.pxd":24
+ * ctypedef int8_t int8
+ * ctypedef int16_t int16
+ * ctypedef int32_t int32 # <<<<<<<<<<<<<<
+ * ctypedef int64_t int64
+ * ctypedef uint8_t uint8
+ */
+typedef int32_t __pyx_t_10basictypes_int32;
+
+/* "basictypes.pxd":25
+ * ctypedef int16_t int16
+ * ctypedef int32_t int32
+ * ctypedef int64_t int64 # <<<<<<<<<<<<<<
+ * ctypedef uint8_t uint8
+ * ctypedef uint16_t uint16
+ */
+typedef int64_t __pyx_t_10basictypes_int64;
+
+/* "basictypes.pxd":26
+ * ctypedef int32_t int32
+ * ctypedef int64_t int64
+ * ctypedef uint8_t uint8 # <<<<<<<<<<<<<<
+ * ctypedef uint16_t uint16
+ * ctypedef uint32_t uint32
+ */
+typedef uint8_t __pyx_t_10basictypes_uint8;
+
+/* "basictypes.pxd":27
+ * ctypedef int64_t int64
+ * ctypedef uint8_t uint8
+ * ctypedef uint16_t uint16 # <<<<<<<<<<<<<<
+ * ctypedef uint32_t uint32
+ * ctypedef uint64_t uint64
+ */
+typedef uint16_t __pyx_t_10basictypes_uint16;
+
+/* "basictypes.pxd":28
+ * ctypedef uint8_t uint8
+ * ctypedef uint16_t uint16
+ * ctypedef uint32_t uint32 # <<<<<<<<<<<<<<
+ * ctypedef uint64_t uint64
+ */
+typedef uint32_t __pyx_t_10basictypes_uint32;
+
+/* "basictypes.pxd":29
+ * ctypedef uint16_t uint16
+ * ctypedef uint32_t uint32
+ * ctypedef uint64_t uint64 # <<<<<<<<<<<<<<
+ */
+typedef uint64_t __pyx_t_10basictypes_uint64;
+
+/*--- Type declarations ---*/
+struct __pyx_obj_9pywrapfst_Weight;
+struct __pyx_obj_9pywrapfst__SymbolTable;
+struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable;
+struct __pyx_obj_9pywrapfst__FstSymbolTable;
+struct __pyx_obj_9pywrapfst__MutableSymbolTable;
+struct __pyx_obj_9pywrapfst__MutableFstSymbolTable;
+struct __pyx_obj_9pywrapfst_SymbolTable;
+struct __pyx_obj_9pywrapfst_SymbolTableIterator;
+struct __pyx_obj_9pywrapfst_EncodeMapper;
+struct __pyx_obj_9pywrapfst__Fst;
+struct __pyx_obj_9pywrapfst__MutableFst;
+struct __pyx_obj_9pywrapfst_Arc;
+struct __pyx_obj_9pywrapfst_ArcIterator;
+struct __pyx_obj_9pywrapfst_MutableArcIterator;
+struct __pyx_obj_9pywrapfst_StateIterator;
+struct __pyx_obj_9pywrapfst_Compiler;
+struct __pyx_obj_9pywrapfst_FarReader;
+struct __pyx_obj_9pywrapfst_FarWriter;
+
+/* "fst.pxd":480
+ *
+ *
+ * ctypedef pair[int64, const FstClass *] LabelFstClassPair # <<<<<<<<<<<<<<
+ *
+ * ctypedef pair[int64, int64] LabelPair
+ */
+typedef std::pair<__pyx_t_10basictypes_int64,fst::script::FstClass const *> __pyx_t_3fst_LabelFstClassPair;
+
+/* "fst.pxd":482
+ * ctypedef pair[int64, const FstClass *] LabelFstClassPair
+ *
+ * ctypedef pair[int64, int64] LabelPair # <<<<<<<<<<<<<<
+ *
+ *
+ */
+typedef std::pair<__pyx_t_10basictypes_int64,__pyx_t_10basictypes_int64> __pyx_t_3fst_LabelPair;
+struct __pyx_opt_args_9pywrapfst_tostring;
+struct __pyx_opt_args_9pywrapfst_weighttostring;
+struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol;
+struct __pyx_opt_args_9pywrapfst_4_Fst_draw;
+struct __pyx_opt_args_9pywrapfst_4_Fst_text;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__project;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__push;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon;
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final;
+struct __pyx_opt_args_9pywrapfst__create_Fst;
+struct __pyx_opt_args_9pywrapfst__read_Fst;
+struct __pyx_opt_args_9pywrapfst__deserialize_Fst;
+struct __pyx_opt_args_9pywrapfst__map;
+struct __pyx_opt_args_9pywrapfst_arcmap;
+struct __pyx_opt_args_9pywrapfst_compose;
+struct __pyx_opt_args_9pywrapfst_convert;
+struct __pyx_opt_args_9pywrapfst_determinize;
+struct __pyx_opt_args_9pywrapfst_difference;
+struct __pyx_opt_args_9pywrapfst_disambiguate;
+struct __pyx_opt_args_9pywrapfst_epsnormalize;
+struct __pyx_opt_args_9pywrapfst_equal;
+struct __pyx_opt_args_9pywrapfst_equivalent;
+struct __pyx_opt_args_9pywrapfst_intersect;
+struct __pyx_opt_args_9pywrapfst_isomorphic;
+struct __pyx_opt_args_9pywrapfst_prune;
+struct __pyx_opt_args_9pywrapfst_push;
+struct __pyx_opt_args_9pywrapfst_randequivalent;
+struct __pyx_opt_args_9pywrapfst_randgen;
+struct __pyx_opt_args_9pywrapfst_replace;
+struct __pyx_opt_args_9pywrapfst_reverse;
+struct __pyx_opt_args_9pywrapfst_rmepsilon;
+struct __pyx_opt_args_9pywrapfst__shortestdistance;
+struct __pyx_opt_args_9pywrapfst_shortestpath;
+
+/* "pywrapfst.pxd":40
+ *
+ *
+ * cdef string tostring(data, encoding=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef string weighttostring(data, encoding=?) except *
+ */
+struct __pyx_opt_args_9pywrapfst_tostring {
+ int __pyx_n;
+ PyObject *encoding;
+};
+
+/* "pywrapfst.pxd":42
+ * cdef string tostring(data, encoding=?) except *
+ *
+ * cdef string weighttostring(data, encoding=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef fst.ComposeFilter _get_compose_filter(const string &cf) except *
+ */
+struct __pyx_opt_args_9pywrapfst_weighttostring {
+ int __pyx_n;
+ PyObject *encoding;
+};
+
+/* "pywrapfst.pxd":96
+ * # SymbolTable.
+ *
+ * ctypedef fst.SymbolTable * SymbolTable_ptr # <<<<<<<<<<<<<<
+ *
+ *
+ */
+typedef fst::SymbolTable *__pyx_t_9pywrapfst_SymbolTable_ptr;
+
+/* "pywrapfst.pxd":136
+ * cdef class _MutableSymbolTable(_SymbolTable):
+ *
+ * cpdef int64 add_symbol(self, symbol, int64 key=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef void add_table(self, _SymbolTable syms)
+ */
+struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol {
+ int __pyx_n;
+ __pyx_t_10basictypes_int64 key;
+};
+
+/* "pywrapfst.pxd":212
+ *
+ *
+ * ctypedef fst.FstClass * FstClass_ptr # <<<<<<<<<<<<<<
+ * ctypedef fst.MutableFstClass * MutableFstClass_ptr
+ * ctypedef fst.VectorFstClass * VectorFstClass_ptr
+ */
+typedef fst::script::FstClass *__pyx_t_9pywrapfst_FstClass_ptr;
+
+/* "pywrapfst.pxd":213
+ *
+ * ctypedef fst.FstClass * FstClass_ptr
+ * ctypedef fst.MutableFstClass * MutableFstClass_ptr # <<<<<<<<<<<<<<
+ * ctypedef fst.VectorFstClass * VectorFstClass_ptr
+ *
+ */
+typedef fst::script::MutableFstClass *__pyx_t_9pywrapfst_MutableFstClass_ptr;
+
+/* "pywrapfst.pxd":214
+ * ctypedef fst.FstClass * FstClass_ptr
+ * ctypedef fst.MutableFstClass * MutableFstClass_ptr
+ * ctypedef fst.VectorFstClass * VectorFstClass_ptr # <<<<<<<<<<<<<<
+ *
+ *
+ */
+typedef fst::script::VectorFstClass *__pyx_t_9pywrapfst_VectorFstClass_ptr;
+
+/* "pywrapfst.pxd":227
+ * cpdef _Fst copy(self)
+ *
+ * cpdef void draw(self, filename, _SymbolTable isymbols=?, # <<<<<<<<<<<<<<
+ * _SymbolTable osymbols=?, SymbolTable ssymbols=?,
+ * bool acceptor=?, title=?, double width=?,
+ */
+struct __pyx_opt_args_9pywrapfst_4_Fst_draw {
+ int __pyx_n;
+ struct __pyx_obj_9pywrapfst__SymbolTable *isymbols;
+ struct __pyx_obj_9pywrapfst__SymbolTable *osymbols;
+ struct __pyx_obj_9pywrapfst_SymbolTable *ssymbols;
+ bool acceptor;
+ PyObject *title;
+ double width;
+ double height;
+ bool portrait;
+ bool vertical;
+ double ranksep;
+ double nodesep;
+ __pyx_t_10basictypes_int32 fontsize;
+ __pyx_t_10basictypes_int32 precision;
+ bool show_weight_one;
+};
+
+/* "pywrapfst.pxd":254
+ * cpdef StateIterator states(self)
+ *
+ * cpdef string text(self, _SymbolTable isymbols=?, _SymbolTable osymbols=?, # <<<<<<<<<<<<<<
+ * _SymbolTable ssymbols=?, bool acceptor=?,
+ * bool show_weight_one=?, missing_sym=?)
+ */
+struct __pyx_opt_args_9pywrapfst_4_Fst_text {
+ int __pyx_n;
+ struct __pyx_obj_9pywrapfst__SymbolTable *isymbols;
+ struct __pyx_obj_9pywrapfst__SymbolTable *osymbols;
+ struct __pyx_obj_9pywrapfst__SymbolTable *ssymbols;
+ bool acceptor;
+ bool show_weight_one;
+ PyObject *missing_sym;
+};
+
+/* "pywrapfst.pxd":277
+ * cpdef int64 add_state(self) except *
+ *
+ * cdef void _arcsort(self, st=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _closure(self, bool closure_plus=?) except *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort {
+ int __pyx_n;
+ PyObject *st;
+};
+
+/* "pywrapfst.pxd":279
+ * cdef void _arcsort(self, st=?) except *
+ *
+ * cdef void _closure(self, bool closure_plus=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _concat(self, _Fst ifst) except *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure {
+ int __pyx_n;
+ bool closure_plus;
+};
+
+/* "pywrapfst.pxd":287
+ * cdef void _decode(self, EncodeMapper) except *
+ *
+ * cdef void _delete_arcs(self, int64 state, size_t n=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _delete_states(self, states=?) except *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs {
+ int __pyx_n;
+ size_t n;
+};
+
+/* "pywrapfst.pxd":289
+ * cdef void _delete_arcs(self, int64 state, size_t n=?) except *
+ *
+ * cdef void _delete_states(self, states=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _encode(self, EncodeMapper) except *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states {
+ int __pyx_n;
+ PyObject *states;
+};
+
+/* "pywrapfst.pxd":295
+ * cdef void _invert(self) except *
+ *
+ * cdef void _minimize(self, float delta=?, bool allow_nondet=?) except * # <<<<<<<<<<<<<<
+ *
+ * cpdef MutableArcIterator mutable_arcs(self, int64 state)
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize {
+ int __pyx_n;
+ float delta;
+ bool allow_nondet;
+};
+
+/* "pywrapfst.pxd":301
+ * cpdef int64 num_states(self)
+ *
+ * cdef void _project(self, bool project_output=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__project {
+ int __pyx_n;
+ bool project_output;
+};
+
+/* "pywrapfst.pxd":303
+ * cdef void _project(self, bool project_output=?) except *
+ *
+ * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _push(self, float delta=?, bool remove_total_weight=?,
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune {
+ int __pyx_n;
+ float delta;
+ __pyx_t_10basictypes_int64 nstate;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":305
+ * cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except *
+ *
+ * cdef void _push(self, float delta=?, bool remove_total_weight=?, # <<<<<<<<<<<<<<
+ * bool to_final=?) except *
+ *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__push {
+ int __pyx_n;
+ float delta;
+ bool remove_total_weight;
+ bool to_final;
+};
+
+/* "pywrapfst.pxd":308
+ * bool to_final=?) except *
+ *
+ * cdef void _relabel_pairs(self, ipairs=?, opairs=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _relabel_tables(self, _SymbolTable old_isymbols=?,
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs {
+ int __pyx_n;
+ PyObject *ipairs;
+ PyObject *opairs;
+};
+
+/* "pywrapfst.pxd":310
+ * cdef void _relabel_pairs(self, ipairs=?, opairs=?) except *
+ *
+ * cdef void _relabel_tables(self, _SymbolTable old_isymbols=?, # <<<<<<<<<<<<<<
+ * _SymbolTable new_isymbols=?, bool attach_new_isymbols=?,
+ * _SymbolTable old_osymbols=?, _SymbolTable new_osymbols=?,
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables {
+ int __pyx_n;
+ struct __pyx_obj_9pywrapfst__SymbolTable *old_isymbols;
+ struct __pyx_obj_9pywrapfst__SymbolTable *new_isymbols;
+ bool attach_new_isymbols;
+ struct __pyx_obj_9pywrapfst__SymbolTable *old_osymbols;
+ struct __pyx_obj_9pywrapfst__SymbolTable *new_osymbols;
+ bool attach_new_osymbols;
+};
+
+/* "pywrapfst.pxd":319
+ * cdef void _reserve_states(self, int64 n) except *
+ *
+ * cdef void _reweight(self, potentials, bool to_final=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _rmepsilon(self, bool connect=?, float delta=?, int64 nstate=?,
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight {
+ int __pyx_n;
+ bool to_final;
+};
+
+/* "pywrapfst.pxd":321
+ * cdef void _reweight(self, potentials, bool to_final=?) except *
+ *
+ * cdef void _rmepsilon(self, bool connect=?, float delta=?, int64 nstate=?, # <<<<<<<<<<<<<<
+ * weight=?) except *
+ *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon {
+ int __pyx_n;
+ bool connect;
+ float delta;
+ __pyx_t_10basictypes_int64 nstate;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":324
+ * weight=?) except *
+ *
+ * cdef void _set_final(self, int64 state, weight=?) except * # <<<<<<<<<<<<<<
+ *
+ * cdef void _set_properties(self, uint64 props, uint64 mask) except *
+ */
+struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final {
+ int __pyx_n;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":348
+ * cdef _Fst _init_XFst(FstClass_ptr tfst)
+ *
+ * cdef _MutableFst _create_Fst(arc_type=?) # <<<<<<<<<<<<<<
+ *
+ * cdef _Fst _read_Fst(filename, fst_type=?)
+ */
+struct __pyx_opt_args_9pywrapfst__create_Fst {
+ int __pyx_n;
+ PyObject *arc_type;
+};
+
+/* "pywrapfst.pxd":350
+ * cdef _MutableFst _create_Fst(arc_type=?)
+ *
+ * cdef _Fst _read_Fst(filename, fst_type=?) # <<<<<<<<<<<<<<
+ *
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=?)
+ */
+struct __pyx_opt_args_9pywrapfst__read_Fst {
+ int __pyx_n;
+ PyObject *fst_type;
+};
+
+/* "pywrapfst.pxd":352
+ * cdef _Fst _read_Fst(filename, fst_type=?)
+ *
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=?) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+struct __pyx_opt_args_9pywrapfst__deserialize_Fst {
+ int __pyx_n;
+ PyObject *fst_type;
+};
+
+/* "pywrapfst.pxd":431
+ *
+ *
+ * cdef _Fst _map(_Fst ifst, float delta=?, mt=?, weight=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef _Fst arcmap(_Fst ifst, float delta=?, mt=?, weight=?)
+ */
+struct __pyx_opt_args_9pywrapfst__map {
+ int __pyx_n;
+ float delta;
+ PyObject *mt;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":433
+ * cdef _Fst _map(_Fst ifst, float delta=?, mt=?, weight=?)
+ *
+ * cpdef _Fst arcmap(_Fst ifst, float delta=?, mt=?, weight=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef _MutableFst compose(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?)
+ */
+struct __pyx_opt_args_9pywrapfst_arcmap {
+ int __pyx_n;
+ float delta;
+ PyObject *mt;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":435
+ * cpdef _Fst arcmap(_Fst ifst, float delta=?, mt=?, weight=?)
+ *
+ * cpdef _MutableFst compose(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef _Fst convert(_Fst ifst, fst_type=?)
+ */
+struct __pyx_opt_args_9pywrapfst_compose {
+ int __pyx_n;
+ PyObject *cf;
+ bool connect;
+};
+
+/* "pywrapfst.pxd":437
+ * cpdef _MutableFst compose(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?)
+ *
+ * cpdef _Fst convert(_Fst ifst, fst_type=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef _MutableFst determinize(_Fst ifst, float delta=?, dt=?,
+ */
+struct __pyx_opt_args_9pywrapfst_convert {
+ int __pyx_n;
+ PyObject *fst_type;
+};
+
+/* "pywrapfst.pxd":439
+ * cpdef _Fst convert(_Fst ifst, fst_type=?)
+ *
+ * cpdef _MutableFst determinize(_Fst ifst, float delta=?, dt=?, # <<<<<<<<<<<<<<
+ * int64 nstate=?, int64 subsequential_label=?,
+ * weight=?, bool increment_subsequential_label=?)
+ */
+struct __pyx_opt_args_9pywrapfst_determinize {
+ int __pyx_n;
+ float delta;
+ PyObject *dt;
+ __pyx_t_10basictypes_int64 nstate;
+ __pyx_t_10basictypes_int64 subsequential_label;
+ PyObject *weight;
+ bool increment_subsequential_label;
+};
+
+/* "pywrapfst.pxd":443
+ * weight=?, bool increment_subsequential_label=?)
+ *
+ * cpdef _MutableFst difference(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef _MutableFst disambiguate(_Fst ifst, float delta=?, int64 nstate=?,
+ */
+struct __pyx_opt_args_9pywrapfst_difference {
+ int __pyx_n;
+ PyObject *cf;
+ bool connect;
+};
+
+/* "pywrapfst.pxd":445
+ * cpdef _MutableFst difference(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?)
+ *
+ * cpdef _MutableFst disambiguate(_Fst ifst, float delta=?, int64 nstate=?, # <<<<<<<<<<<<<<
+ * int64 subsequential_label=?, weight=?)
+ *
+ */
+struct __pyx_opt_args_9pywrapfst_disambiguate {
+ int __pyx_n;
+ float delta;
+ __pyx_t_10basictypes_int64 nstate;
+ __pyx_t_10basictypes_int64 subsequential_label;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":448
+ * int64 subsequential_label=?, weight=?)
+ *
+ * cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=?)
+ */
+struct __pyx_opt_args_9pywrapfst_epsnormalize {
+ int __pyx_n;
+ bool eps_norm_output;
+};
+
+/* "pywrapfst.pxd":450
+ * 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":452
+ * 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, cf=?, bool connect=?)
+ */
+struct __pyx_opt_args_9pywrapfst_equivalent {
+ int __pyx_n;
+ float delta;
+};
+
+/* "pywrapfst.pxd":454
+ * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=?) except *
+ *
+ * cpdef _MutableFst intersect(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=?)
+ */
+struct __pyx_opt_args_9pywrapfst_intersect {
+ int __pyx_n;
+ PyObject *cf;
+ bool connect;
+};
+
+/* "pywrapfst.pxd":456
+ * cpdef _MutableFst intersect(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?)
+ *
+ * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef _MutableFst prune(_Fst ifst, float delta=?, int64 nstate=?,
+ */
+struct __pyx_opt_args_9pywrapfst_isomorphic {
+ int __pyx_n;
+ float delta;
+};
+
+/* "pywrapfst.pxd":458
+ * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=?)
+ *
+ * cpdef _MutableFst prune(_Fst ifst, float delta=?, int64 nstate=?, # <<<<<<<<<<<<<<
+ * weight=?)
+ *
+ */
+struct __pyx_opt_args_9pywrapfst_prune {
+ int __pyx_n;
+ float delta;
+ __pyx_t_10basictypes_int64 nstate;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":461
+ * weight=?)
+ *
+ * cpdef _MutableFst push(_Fst ifst, float delta=?, bool push_weights=?, # <<<<<<<<<<<<<<
+ * bool push_labels=?, bool remove_common_affix=?,
+ * bool remove_total_weight=?, bool to_final=?)
+ */
+struct __pyx_opt_args_9pywrapfst_push {
+ int __pyx_n;
+ float delta;
+ bool push_weights;
+ bool push_labels;
+ bool remove_common_affix;
+ bool remove_total_weight;
+ bool to_final;
+};
+
+/* "pywrapfst.pxd":465
+ * bool remove_total_weight=?, bool to_final=?)
+ *
+ * cpdef bool randequivalent(_Fst ifst1, _Fst ifst2, int32 npath=?, # <<<<<<<<<<<<<<
+ * float delta=?, time_t seed=?, select=?,
+ * int32 max_length=?) except *
+ */
+struct __pyx_opt_args_9pywrapfst_randequivalent {
+ int __pyx_n;
+ __pyx_t_10basictypes_int32 npath;
+ float delta;
+ time_t seed;
+ PyObject *select;
+ __pyx_t_10basictypes_int32 max_length;
+};
+
+/* "pywrapfst.pxd":469
+ * int32 max_length=?) except *
+ *
+ * cpdef _MutableFst randgen(_Fst ifst, int32 npath=?, time_t seed=?, # <<<<<<<<<<<<<<
+ * select=?, int32 max_length=?,
+ * bool remove_total_weight=?, bool weighted=?)
+ */
+struct __pyx_opt_args_9pywrapfst_randgen {
+ int __pyx_n;
+ __pyx_t_10basictypes_int32 npath;
+ time_t seed;
+ PyObject *select;
+ __pyx_t_10basictypes_int32 max_length;
+ bool remove_total_weight;
+ bool weighted;
+};
+
+/* "pywrapfst.pxd":476
+ * bool epsilon_on_replace) except *
+ *
+ * cpdef _MutableFst replace(pairs, call_arc_labeling=?, # <<<<<<<<<<<<<<
+ * return_arc_labeling=?, bool epsilon_on_replace=?,
+ * int64 return_label=?)
+ */
+struct __pyx_opt_args_9pywrapfst_replace {
+ int __pyx_n;
+ PyObject *call_arc_labeling;
+ PyObject *return_arc_labeling;
+ bool epsilon_on_replace;
+ __pyx_t_10basictypes_int64 return_label;
+};
+
+/* "pywrapfst.pxd":480
+ * int64 return_label=?)
+ *
+ * cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=?) # <<<<<<<<<<<<<<
+ *
+ * cpdef _MutableFst rmepsilon(_Fst ifst, bool connect=?, float delta=?,
+ */
+struct __pyx_opt_args_9pywrapfst_reverse {
+ int __pyx_n;
+ bool require_superinitial;
+};
+
+/* "pywrapfst.pxd":482
+ * cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=?)
+ *
+ * cpdef _MutableFst rmepsilon(_Fst ifst, bool connect=?, float delta=?, # <<<<<<<<<<<<<<
+ * int64 nstate=?, qt=?, bool reverse=?,
+ * weight=?)
+ */
+struct __pyx_opt_args_9pywrapfst_rmepsilon {
+ int __pyx_n;
+ bool connect;
+ float delta;
+ __pyx_t_10basictypes_int64 nstate;
+ PyObject *qt;
+ bool reverse;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":486
+ * weight=?)
+ *
+ * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, float delta=?, # <<<<<<<<<<<<<<
+ * int64 nstate=?, qt=?,
+ * bool reverse=?) except *
+ */
+struct __pyx_opt_args_9pywrapfst__shortestdistance {
+ int __pyx_n;
+ float delta;
+ __pyx_t_10basictypes_int64 nstate;
+ PyObject *qt;
+ bool reverse;
+};
+
+/* "pywrapfst.pxd":490
+ * bool reverse=?) except *
+ *
+ * cpdef _MutableFst shortestpath(_Fst ifst, float delta=?, int32 nshortest=?, # <<<<<<<<<<<<<<
+ * int64 nstate=?, qt=?, bool unique=?,
+ * weight=?)
+ */
+struct __pyx_opt_args_9pywrapfst_shortestpath {
+ int __pyx_n;
+ float delta;
+ __pyx_t_10basictypes_int32 nshortest;
+ __pyx_t_10basictypes_int64 nstate;
+ PyObject *qt;
+ bool unique;
+ PyObject *weight;
+};
+
+/* "pywrapfst.pxd":66
+ *
+ *
+ * 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<fst::script::WeightClass> _weight;
+};
+
+
+/* "pywrapfst.pxd":99
+ *
+ *
+ * cdef class _SymbolTable(object): # <<<<<<<<<<<<<<
+ *
+ * cdef fst.SymbolTable *_table
+ */
+struct __pyx_obj_9pywrapfst__SymbolTable {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_9pywrapfst__SymbolTable *__pyx_vtab;
+ fst::SymbolTable *_table;
+};
+
+
+/* "pywrapfst.pxd":124
+ *
+ *
+ * cdef class _EncodeMapperSymbolTable(_SymbolTable): # <<<<<<<<<<<<<<
+ *
+ * cdef shared_ptr[fst.EncodeMapperClass] _encoder
+ */
+struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable {
+ struct __pyx_obj_9pywrapfst__SymbolTable __pyx_base;
+ std::shared_ptr<fst::script::EncodeMapperClass> _encoder;
+};
+
+
+/* "pywrapfst.pxd":129
+ *
+ *
+ * cdef class _FstSymbolTable(_SymbolTable): # <<<<<<<<<<<<<<
+ *
+ * cdef shared_ptr[fst.FstClass] _fst
+ */
+struct __pyx_obj_9pywrapfst__FstSymbolTable {
+ struct __pyx_obj_9pywrapfst__SymbolTable __pyx_base;
+ std::shared_ptr<fst::script::FstClass> _fst;
+};
+
+
+/* "pywrapfst.pxd":134
+ *
+ *
+ * cdef class _MutableSymbolTable(_SymbolTable): # <<<<<<<<<<<<<<
+ *
+ * cpdef int64 add_symbol(self, symbol, int64 key=?)
+ */
+struct __pyx_obj_9pywrapfst__MutableSymbolTable {
+ struct __pyx_obj_9pywrapfst__SymbolTable __pyx_base;
+};
+
+
+/* "pywrapfst.pxd":143
+ *
+ *
+ * cdef class _MutableFstSymbolTable(_MutableSymbolTable): # <<<<<<<<<<<<<<
+ *
+ * cdef shared_ptr[fst.MutableFstClass] _mfst
+ */
+struct __pyx_obj_9pywrapfst__MutableFstSymbolTable {
+ struct __pyx_obj_9pywrapfst__MutableSymbolTable __pyx_base;
+ std::shared_ptr<fst::script::MutableFstClass> _mfst;
+};
+
+
+/* "pywrapfst.pxd":148
+ *
+ *
+ * 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<fst::SymbolTable> _smart_table;
+};
+
+
+/* "pywrapfst.pxd":169
+ *
+ *
+ * cdef class SymbolTableIterator(object): # <<<<<<<<<<<<<<
+ *
+ * cdef shared_ptr[fst.SymbolTable] _table
+ */
+struct __pyx_obj_9pywrapfst_SymbolTableIterator {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *__pyx_vtab;
+ std::shared_ptr<fst::SymbolTable> _table;
+ std::unique_ptr<fst::SymbolTableIterator> _siter;
+};
+
+
+/* "pywrapfst.pxd":188
+ *
+ *
+ * cdef class EncodeMapper(object): # <<<<<<<<<<<<<<
+ *
+ * cdef shared_ptr[fst.EncodeMapperClass] _encoder
+ */
+struct __pyx_obj_9pywrapfst_EncodeMapper {
+ PyObject_HEAD
+ struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *__pyx_vtab;
+ std::shared_ptr<fst::script::EncodeMapperClass> _encoder;
+};
+
+
+/* "pywrapfst.pxd":217
+ *
+ *
+ * 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::script::FstClass> _fst;
+};
+
+
+/* "pywrapfst.pxd":267
+ *
+ *
+ * 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<fst::script::MutableFstClass> _mfst;
+};
+
+
+/* "pywrapfst.pxd":358
+ *
+ *
+ * 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<fst::script::ArcClass> _arc;
+};
+
+
+/* "pywrapfst.pxd":368
+ *
+ *
+ * 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::script::FstClass> _fst;
+ std::unique_ptr<fst::script::ArcIteratorClass> _aiter;
+};
+
+
+/* "pywrapfst.pxd":390
+ *
+ *
+ * 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<fst::script::MutableFstClass> _mfst;
+ std::unique_ptr<fst::script::MutableArcIteratorClass> _aiter;
+};
+
+
+/* "pywrapfst.pxd":414
+ *
+ *
+ * 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::script::FstClass> _fst;
+ std::unique_ptr<fst::script::StateIteratorClass> _siter;
+};
+
+
+/* "pywrapfst.pxd":502
+ *
+ *
+ * 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<std::stringstream> _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":523
+ * # 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<fst::script::FarReaderClass> _reader;
+};
+
+
+/* "pywrapfst.pxd":548
+ * # 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<fst::script::FarWriterClass> _writer;
+};
+
+
+
+/* "pywrapfst.pyx":344
+ *
+ *
+ * cdef class Weight(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_Weight {
+ void (*_check_weight)(struct __pyx_obj_9pywrapfst_Weight *);
+ struct __pyx_obj_9pywrapfst_Weight *(*copy)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch);
+ std::string (*to_string)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch);
+ std::string (*type)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_Weight *__pyx_vtabptr_9pywrapfst_Weight;
+
+
+/* "pywrapfst.pyx":665
+ *
+ *
+ * cdef class _SymbolTable(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst__SymbolTable {
+ __pyx_t_10basictypes_int64 (*available_key)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ std::string (*checksum)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst_SymbolTable *(*copy)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_int64 (*get_nth_key)(struct __pyx_obj_9pywrapfst__SymbolTable *, Py_ssize_t, int __pyx_skip_dispatch);
+ std::string (*labeled_checksum)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ bool (*member)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch);
+ std::string (*name)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ size_t (*num_symbols)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ void (*write)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch);
+ void (*write_text)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst__SymbolTable *__pyx_vtabptr_9pywrapfst__SymbolTable;
+
+
+/* "pywrapfst.pyx":817
+ *
+ *
+ * cdef class _EncodeMapperSymbolTable(_SymbolTable): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable {
+ struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_base;
+};
+static struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable *__pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable;
+
+
+/* "pywrapfst.pyx":837
+ *
+ *
+ * cdef class _FstSymbolTable(_SymbolTable): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable {
+ struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_base;
+};
+static struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable *__pyx_vtabptr_9pywrapfst__FstSymbolTable;
+
+
+/* "pywrapfst.pyx":856
+ *
+ *
+ * cdef class _MutableSymbolTable(_SymbolTable): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable {
+ struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_base;
+ __pyx_t_10basictypes_int64 (*add_symbol)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args);
+ void (*add_table)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ void (*set_name)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable *__pyx_vtabptr_9pywrapfst__MutableSymbolTable;
+
+
+/* "pywrapfst.pyx":907
+ *
+ *
+ * cdef class _MutableFstSymbolTable(_MutableSymbolTable): # <<<<<<<<<<<<<<
+ * """
+ * (No constructor.)
+ */
+
+struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable {
+ struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable __pyx_base;
+};
+static struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable *__pyx_vtabptr_9pywrapfst__MutableFstSymbolTable;
+
+
+/* "pywrapfst.pyx":927
+ *
+ *
+ * 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":1117
+ *
+ *
+ * cdef class SymbolTableIterator(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator {
+ bool (*done)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch);
+ void (*next)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch);
+ void (*reset)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch);
+ std::string (*symbol)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_int64 (*value)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *__pyx_vtabptr_9pywrapfst_SymbolTableIterator;
+
+
+/* "pywrapfst.pyx":1217
+ *
+ *
+ * cdef class EncodeMapper(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_EncodeMapper {
+ std::string (*arc_type)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_uint32 (*flags)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*input_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*output_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_uint64 (*properties)(struct __pyx_obj_9pywrapfst_EncodeMapper *, __pyx_t_10basictypes_uint64, int __pyx_skip_dispatch);
+ void (*set_input_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ void (*set_output_symbols)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch);
+ std::string (*weight_type)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_EncodeMapper *__pyx_vtabptr_9pywrapfst_EncodeMapper;
+
+
+/* "pywrapfst.pyx":1348
+ *
+ *
+ * cdef class _Fst(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst__Fst {
+ std::string (*arc_type)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst_ArcIterator *(*arcs)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst__Fst *(*copy)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ void (*draw)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args);
+ struct __pyx_obj_9pywrapfst_Weight *(*final)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch);
+ std::string (*fst_type)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *(*input_symbols)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ size_t (*num_arcs)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch);
+ size_t (*num_input_epsilons)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch);
+ size_t (*num_output_epsilons)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *(*output_symbols)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_uint64 (*properties)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_uint64, bool, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_int64 (*start)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst_StateIterator *(*states)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ std::string (*text)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args);
+ bool (*verify)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ std::string (*weight_type)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ void (*write)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch);
+ std::string (*WriteToString)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst__Fst *__pyx_vtabptr_9pywrapfst__Fst;
+
+
+/* "pywrapfst.pyx":1711
+ *
+ *
+ * cdef class _MutableFst(_Fst): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst__MutableFst {
+ struct __pyx_vtabstruct_9pywrapfst__Fst __pyx_base;
+ void (*_check_mutating_imethod)(struct __pyx_obj_9pywrapfst__MutableFst *);
+ void (*_add_arc)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_obj_9pywrapfst_Arc *);
+ __pyx_t_10basictypes_int64 (*add_state)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch);
+ void (*_arcsort)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args);
+ void (*_closure)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args);
+ void (*_concat)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *);
+ void (*_connect)(struct __pyx_obj_9pywrapfst__MutableFst *);
+ void (*_decode)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *);
+ void (*_delete_arcs)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args);
+ void (*_delete_states)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args);
+ void (*_encode)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *);
+ void (*_invert)(struct __pyx_obj_9pywrapfst__MutableFst *);
+ void (*_minimize)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args);
+ struct __pyx_obj_9pywrapfst_MutableArcIterator *(*mutable_arcs)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_int64 (*num_states)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch);
+ void (*_project)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args);
+ void (*_prune)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args);
+ void (*_push)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args);
+ void (*_relabel_pairs)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args);
+ void (*_relabel_tables)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args);
+ void (*_reserve_arcs)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, size_t);
+ void (*_reserve_states)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64);
+ void (*_reweight)(struct __pyx_obj_9pywrapfst__MutableFst *, PyObject *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args);
+ void (*_rmepsilon)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args);
+ void (*_set_final)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args);
+ void (*_set_properties)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_uint64, __pyx_t_10basictypes_uint64);
+ void (*_set_start)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64);
+ void (*_set_input_symbols)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *);
+ void (*_set_output_symbols)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *);
+ void (*_topsort)(struct __pyx_obj_9pywrapfst__MutableFst *);
+ void (*_union)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *);
+};
+static struct __pyx_vtabstruct_9pywrapfst__MutableFst *__pyx_vtabptr_9pywrapfst__MutableFst;
+
+
+/* "pywrapfst.pyx":2779
+ *
+ *
+ * cdef class Arc(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_Arc {
+ struct __pyx_obj_9pywrapfst_Arc *(*copy)(struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_Arc *__pyx_vtabptr_9pywrapfst_Arc;
+
+
+/* "pywrapfst.pyx":2847
+ *
+ *
+ * cdef class ArcIterator(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_ArcIterator {
+ bool (*done)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_uint32 (*flags)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch);
+ void (*next)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch);
+ size_t (*position)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch);
+ void (*reset)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch);
+ void (*seek)(struct __pyx_obj_9pywrapfst_ArcIterator *, size_t, int __pyx_skip_dispatch);
+ void (*set_flags)(struct __pyx_obj_9pywrapfst_ArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch);
+ PyObject *(*value)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_ArcIterator *__pyx_vtabptr_9pywrapfst_ArcIterator;
+
+
+/* "pywrapfst.pyx":2984
+ *
+ *
+ * cdef class MutableArcIterator(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator {
+ bool (*done)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_uint32 (*flags)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch);
+ void (*next)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch);
+ size_t (*position)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch);
+ void (*reset)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch);
+ void (*seek)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, size_t, int __pyx_skip_dispatch);
+ void (*set_flags)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch);
+ void (*set_value)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch);
+ PyObject *(*value)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *__pyx_vtabptr_9pywrapfst_MutableArcIterator;
+
+
+/* "pywrapfst.pyx":3136
+ *
+ *
+ * cdef class StateIterator(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_StateIterator {
+ bool (*done)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch);
+ void (*next)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch);
+ void (*reset)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch);
+ __pyx_t_10basictypes_int64 (*value)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_StateIterator *__pyx_vtabptr_9pywrapfst_StateIterator;
+
+
+/* "pywrapfst.pyx":4083
+ *
+ *
+ * cdef class Compiler(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_Compiler {
+ struct __pyx_obj_9pywrapfst__Fst *(*compile)(struct __pyx_obj_9pywrapfst_Compiler *, int __pyx_skip_dispatch);
+ void (*write)(struct __pyx_obj_9pywrapfst_Compiler *, PyObject *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_Compiler *__pyx_vtabptr_9pywrapfst_Compiler;
+
+
+/* "pywrapfst.pyx":4209
+ *
+ *
+ * cdef class FarReader(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_FarReader {
+ std::string (*arc_type)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+ bool (*done)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+ bool (*error)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+ std::string (*far_type)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+ bool (*find)(struct __pyx_obj_9pywrapfst_FarReader *, PyObject *, int __pyx_skip_dispatch);
+ struct __pyx_obj_9pywrapfst__Fst *(*get_fst)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+ std::string (*get_key)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+ void (*next)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+ void (*reset)(struct __pyx_obj_9pywrapfst_FarReader *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_FarReader *__pyx_vtabptr_9pywrapfst_FarReader;
+
+
+/* "pywrapfst.pyx":4383
+ *
+ *
+ * cdef class FarWriter(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+
+struct __pyx_vtabstruct_9pywrapfst_FarWriter {
+ std::string (*arc_type)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch);
+ void (*_close)(struct __pyx_obj_9pywrapfst_FarWriter *);
+ void (*add)(struct __pyx_obj_9pywrapfst_FarWriter *, PyObject *, struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch);
+ bool (*error)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch);
+ std::string (*far_type)(struct __pyx_obj_9pywrapfst_FarWriter *, int __pyx_skip_dispatch);
+};
+static struct __pyx_vtabstruct_9pywrapfst_FarWriter *__pyx_vtabptr_9pywrapfst_FarWriter;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+ #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+ typedef struct {
+ void (*INCREF)(void*, PyObject*, int);
+ void (*DECREF)(void*, PyObject*, int);
+ void (*GOTREF)(void*, PyObject*, int);
+ void (*GIVEREF)(void*, PyObject*, int);
+ void* (*SetupContext)(const char*, int, const char*);
+ void (*FinishContext)(void**);
+ } __Pyx_RefNannyAPIStruct;
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+ #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+ if (acquire_gil) {\
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+ PyGILState_Release(__pyx_gilstate_save);\
+ } else {\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+ }
+#else
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+ #define __Pyx_RefNannyFinishContext()\
+ __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+ #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
+ #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
+ #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
+ #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+#else
+ #define __Pyx_RefNannyDeclarations
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)
+ #define __Pyx_RefNannyFinishContext()
+ #define __Pyx_INCREF(r) Py_INCREF(r)
+ #define __Pyx_DECREF(r) Py_DECREF(r)
+ #define __Pyx_GOTREF(r)
+ #define __Pyx_GIVEREF(r)
+ #define __Pyx_XINCREF(r) Py_XINCREF(r)
+ #define __Pyx_XDECREF(r) Py_XDECREF(r)
+ #define __Pyx_XGOTREF(r)
+ #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+ PyObject *tmp = (PyObject *) r;\
+ r = v; __Pyx_XDECREF(tmp);\
+ } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+ PyObject *tmp = (PyObject *) r;\
+ r = v; __Pyx_DECREF(tmp);\
+ } while (0)
+#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+ PyTypeObject* tp = Py_TYPE(obj);
+ if (likely(tp->tp_getattro))
+ return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+ if (likely(tp->tp_getattr))
+ return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+ return PyObject_GetAttr(obj, attr_name);
+}
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* PyCFunctionFastCall.proto */
+#if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
+#else
+#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL)
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs);
+#else
+#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* GetModuleGlobalName.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET();
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#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);
+#else
+#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
+#endif
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+ Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
+ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+ const char* function_name);
+
+/* PyObjectCallNoArg.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+#else
+#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
+#endif
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* ArgTypeTest.proto */
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+ 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 CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
+#else
+#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\
+ PyObject_RichCompare(op1, op2, Py_EQ)
+ #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
+
+/* IncludeStringH.proto */
+#include <string.h>
+
+/* BytesEquals.proto */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* IterFinish.proto */
+static CYTHON_INLINE int __Pyx_IterFinish(void);
+
+/* UnpackItemEndCheck.proto */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
+
+/* IterNext.proto */
+#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL)
+static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *);
+
+/* ListAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
+ PyListObject* L = (PyListObject*) list;
+ Py_ssize_t len = Py_SIZE(list);
+ if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
+ Py_INCREF(x);
+ PyList_SET_ITEM(list, len, x);
+ Py_SIZE(list) = len+1;
+ return 0;
+ }
+ return PyList_Append(list, x);
+}
+#else
+#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* ListCompAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+ PyListObject* L = (PyListObject*) list;
+ Py_ssize_t len = Py_SIZE(list);
+ if (likely(L->allocated > len)) {
+ Py_INCREF(x);
+ PyList_SET_ITEM(list, len, x);
+ Py_SIZE(list) = len+1;
+ return 0;
+ }
+ return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* SetVTable.proto */
+static int __Pyx_SetVtable(PyObject *dict, void *vtable);
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* CalculateMetaclass.proto */
+static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
+
+/* Py3ClassCreate.proto */
+static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
+ PyObject *mkw, PyObject *modname, PyObject *doc);
+static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
+ PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass);
+
+/* GetNameInClass.proto */
+static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name);
+
+/* ClassMethod.proto */
+#include "descrobject.h"
+static PyObject* __Pyx_Method_ClassMethod(PyObject *method);
+
+/* FetchCommonType.proto */
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+
+/* CythonFunction.proto */
+#define __Pyx_CyFunction_USED 1
+#include <structmember.h>
+#define __Pyx_CYFUNCTION_STATICMETHOD 0x01
+#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02
+#define __Pyx_CYFUNCTION_CCLASS 0x04
+#define __Pyx_CyFunction_GetClosure(f)\
+ (((__pyx_CyFunctionObject *) (f))->func_closure)
+#define __Pyx_CyFunction_GetClassObj(f)\
+ (((__pyx_CyFunctionObject *) (f))->func_classobj)
+#define __Pyx_CyFunction_Defaults(type, f)\
+ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
+#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
+ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
+typedef struct {
+ PyCFunctionObject func;
+#if PY_VERSION_HEX < 0x030500A0
+ PyObject *func_weakreflist;
+#endif
+ PyObject *func_dict;
+ PyObject *func_name;
+ PyObject *func_qualname;
+ PyObject *func_doc;
+ PyObject *func_globals;
+ PyObject *func_code;
+ PyObject *func_closure;
+ PyObject *func_classobj;
+ void *defaults;
+ int defaults_pyobjects;
+ int flags;
+ PyObject *defaults_tuple;
+ PyObject *defaults_kwdict;
+ PyObject *(*defaults_getter)(PyObject *);
+ PyObject *func_annotations;
+} __pyx_CyFunctionObject;
+static PyTypeObject *__pyx_CyFunctionType = 0;
+#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\
+ __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code)
+static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml,
+ int flags, PyObject* qualname,
+ PyObject *self,
+ PyObject *module, PyObject *globals,
+ PyObject* code);
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
+ size_t size,
+ int pyobjects);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
+ PyObject *tuple);
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
+ PyObject *dict);
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
+ PyObject *dict);
+static int __pyx_CyFunction_init(void);
+
+/* 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 <new>
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value);
+
+/* 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_uint32_t(uint32_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__fst_3a__3a_script_3a__3a_ArcSortType(enum fst::script::ArcSortType value);
+
+/* CppExceptionConversion.proto */
+#ifndef __Pyx_CppExn2PyErr
+#include <new>
+#include <typeinfo>
+#include <stdexcept>
+#include <ios>
+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
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__fst_3a__3a_script_3a__3a_MapType(enum fst::script::MapType value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* FunctionExport.proto */
+static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+static void __pyx_f_9pywrapfst_6Weight__check_weight(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_6Weight_copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_6Weight_to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_6Weight_type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_12_SymbolTable_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_12_SymbolTable_copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_12_SymbolTable_member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_12_SymbolTable_name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static size_t __pyx_f_9pywrapfst_12_SymbolTable_num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_12_SymbolTable_write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_12_SymbolTable_write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_19_MutableSymbolTable_set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_19SymbolTableIterator_done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_19SymbolTableIterator_next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_19SymbolTableIterator_reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_19SymbolTableIterator_symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19SymbolTableIterator_value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_12EncodeMapper_arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_12EncodeMapper_flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_12EncodeMapper_properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_12EncodeMapper_weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_f_9pywrapfst_4_Fst_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_4_Fst_copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_4_Fst_draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args); /* proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_4_Fst_final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static size_t __pyx_f_9pywrapfst_4_Fst_num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/
+static size_t __pyx_f_9pywrapfst_4_Fst_num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/
+static size_t __pyx_f_9pywrapfst_4_Fst_num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_4_Fst_properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_4_Fst_start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst_StateIterator *__pyx_f_9pywrapfst_4_Fst_states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args); /* proto*/
+static bool __pyx_f_9pywrapfst_4_Fst_verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_4_Fst_write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_WriteToString(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__check_mutating_imethod(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args); /* proto*/
+static struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto*/
+static void __pyx_f_9pywrapfst_11_MutableFst__union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto*/
+static struct __pyx_obj_9pywrapfst_Arc *__pyx_f_9pywrapfst_3Arc_copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_11ArcIterator_done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_11ArcIterator_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static size_t __pyx_f_9pywrapfst_11ArcIterator_position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch); /* proto*/
+static PyObject *__pyx_f_9pywrapfst_11ArcIterator_value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_18MutableArcIterator_done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_18MutableArcIterator_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static size_t __pyx_f_9pywrapfst_18MutableArcIterator_position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc, int __pyx_skip_dispatch); /* proto*/
+static PyObject *__pyx_f_9pywrapfst_18MutableArcIterator_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_13StateIterator_done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_13StateIterator_next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_13StateIterator_reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_13StateIterator_value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_8Compiler_compile(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_8Compiler_write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_9FarReader_arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_9FarReader_done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_9FarReader_error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_9FarReader_far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_9FarReader_find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch); /* proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_9FarReader_get_fst(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_9FarReader_get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_9FarReader_next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_9FarReader_reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static void __pyx_f_9pywrapfst_9FarWriter__close(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto*/
+static void __pyx_f_9pywrapfst_9FarWriter_add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_9FarWriter_arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static bool __pyx_f_9pywrapfst_9FarWriter_error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+static std::string __pyx_f_9pywrapfst_9FarWriter_far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch); /* proto*/
+
+/* Module declarations from 'libc.stddef' */
+
+/* Module declarations from 'libc.time' */
+
+/* Module declarations from 'libcpp' */
+
+/* Module declarations from 'libcpp.memory' */
+
+/* Module declarations from 'libcpp.utility' */
+
+/* Module declarations from 'libcpp.vector' */
+
+/* Module declarations from 'libc.stdint' */
+
+/* Module declarations from 'basictypes' */
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libcpp.string' */
+
+/* Module declarations from 'ios' */
+
+/* Module declarations from 'fst' */
+
+/* Module declarations from 'posix.types' */
+
+/* Module declarations from 'posix.unistd' */
+
+/* Module declarations from 'libcpp.cast' */
+
+/* Module declarations from 'memory' */
+
+/* Module declarations from 'pywrapfst' */
+static PyTypeObject *__pyx_ptype_9pywrapfst_Weight = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst__SymbolTable = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst__EncodeMapperSymbolTable = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst__FstSymbolTable = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst__MutableSymbolTable = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst__MutableFstSymbolTable = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_SymbolTable = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_SymbolTableIterator = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_EncodeMapper = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst__Fst = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst__MutableFst = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_Arc = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_ArcIterator = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_MutableArcIterator = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_StateIterator = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_Compiler = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_FarReader = 0;
+static PyTypeObject *__pyx_ptype_9pywrapfst_FarWriter = 0;
+static std::string __pyx_f_9pywrapfst_tostring(PyObject *, struct __pyx_opt_args_9pywrapfst_tostring *__pyx_optional_args); /*proto*/
+static std::string __pyx_f_9pywrapfst_weighttostring(PyObject *, struct __pyx_opt_args_9pywrapfst_weighttostring *__pyx_optional_args); /*proto*/
+static enum fst::ComposeFilter __pyx_f_9pywrapfst__get_compose_filter(std::string const &); /*proto*/
+static enum fst::QueueType __pyx_f_9pywrapfst__get_queue_type(std::string const &); /*proto*/
+static enum fst::script::RandArcSelection __pyx_f_9pywrapfst__get_rand_arc_selection(std::string const &); /*proto*/
+static enum fst::ReplaceLabelType __pyx_f_9pywrapfst__get_replace_label_type(std::string const &, bool); /*proto*/
+static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_One(std::string const &, PyObject *); /*proto*/
+static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_Zero(std::string const &, PyObject *); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Weight_Zero(PyObject *); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Weight_One(PyObject *); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Weight_NoWeight(PyObject *); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__plus(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__times(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__divide(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__power(struct __pyx_obj_9pywrapfst_Weight *, size_t); /*proto*/
+static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(fst::SymbolTable *, std::shared_ptr<fst::script::EncodeMapperClass> ); /*proto*/
+static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst__init_FstSymbolTable(fst::SymbolTable *, std::shared_ptr<fst::script::FstClass> ); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_f_9pywrapfst__init_MutableFstSymbolTable(fst::SymbolTable *, std::shared_ptr<fst::script::MutableFstClass> ); /*proto*/
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__init_SymbolTable(fst::SymbolTable *); /*proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_Fst(__pyx_t_9pywrapfst_FstClass_ptr); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__init_MutableFst(__pyx_t_9pywrapfst_MutableFstClass_ptr); /*proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_XFst(__pyx_t_9pywrapfst_FstClass_ptr); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__create_Fst(struct __pyx_opt_args_9pywrapfst__create_Fst *__pyx_optional_args); /*proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__read_Fst(PyObject *, struct __pyx_opt_args_9pywrapfst__read_Fst *__pyx_optional_args); /*proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__deserialize_Fst(PyObject *, struct __pyx_opt_args_9pywrapfst__deserialize_Fst *__pyx_optional_args); /*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 struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_rmepsilon(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_rmepsilon *__pyx_optional_args); /*proto*/
+static std::vector<fst::script::WeightClass> *__pyx_f_9pywrapfst__shortestdistance(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_opt_args_9pywrapfst__shortestdistance *__pyx_optional_args); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_shortestpath(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_shortestpath *__pyx_optional_args); /*proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_statemap(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_synchronize(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch); /*proto*/
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_compact_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); /*proto*/
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_merge_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch); /*proto*/
+static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &); /*proto*/
+static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &); /*proto*/
+static std::vector<__pyx_t_10basictypes_int64> __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(PyObject *); /*proto*/
+static std::vector<std::string> __pyx_convert_vector_from_py_std_3a__3a_string(PyObject *); /*proto*/
+#define __Pyx_MODULE_NAME "pywrapfst"
+int __pyx_module_is_main_pywrapfst = 0;
+
+/* Implementation of 'pywrapfst' */
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_IndexError;
+static PyObject *__pyx_builtin_IOError;
+static PyObject *__pyx_builtin_object;
+static PyObject *__pyx_builtin_staticmethod;
+static PyObject *__pyx_builtin_id;
+static PyObject *__pyx_builtin_NotImplementedError;
+static PyObject *__pyx_builtin_KeyError;
+static PyObject *__pyx_builtin_StopIteration;
+static const char __pyx_k_[] = "";
+static const char __pyx_k_n[] = "n";
+static const char __pyx_k_w[] = "w";
+static const char __pyx_k_cf[] = "cf";
+static const char __pyx_k_dt[] = "dt";
+static const char __pyx_k_id[] = "id";
+static const char __pyx_k_it[] = "it";
+static const char __pyx_k_mt[] = "mt";
+static const char __pyx_k_qt[] = "qt";
+static const char __pyx_k_st[] = "st";
+static const char __pyx_k_Fst[] = "Fst";
+static const char __pyx_k_One[] = "One";
+static const char __pyx_k_add[] = "add";
+static const char __pyx_k_arc[] = "arc";
+static const char __pyx_k_cls[] = "cls";
+static const char __pyx_k_doc[] = "__doc__";
+static const char __pyx_k_dot[] = "dot";
+static const char __pyx_k_key[] = "key";
+static const char __pyx_k_lhs[] = "lhs";
+static const char __pyx_k_new[] = "__new__";
+static const char __pyx_k_rhs[] = "rhs";
+static const char __pyx_k_PIPE[] = "PIPE";
+static const char __pyx_k_Tsvg[] = "-Tsvg";
+static const char __pyx_k_Zero[] = "Zero";
+static const char __pyx_k_arcs[] = "arcs";
+static const char __pyx_k_auto[] = "auto";
+static const char __pyx_k_copy[] = "copy";
+static const char __pyx_k_done[] = "done";
+static const char __pyx_k_draw[] = "draw";
+static const char __pyx_k_find[] = "find";
+static const char __pyx_k_ifst[] = "ifst";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_mask[] = "mask";
+static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_next[] = "next";
+static const char __pyx_k_open[] = "open";
+static const char __pyx_k_plus[] = "plus";
+static const char __pyx_k_read[] = "read";
+static const char __pyx_k_seed[] = "seed";
+static const char __pyx_k_seek[] = "seek";
+static const char __pyx_k_syms[] = "syms";
+static const char __pyx_k_test[] = "test";
+static const char __pyx_k_text[] = "text";
+static const char __pyx_k_type[] = "type";
+static const char __pyx_k_utf8[] = "utf8";
+static const char __pyx_k_ERROR[] = "ERROR";
+static const char __pyx_k_Popen[] = "Popen";
+static const char __pyx_k_class[] = "__class__";
+static const char __pyx_k_delta[] = "delta";
+static const char __pyx_k_error[] = "error";
+static const char __pyx_k_final[] = "final";
+static const char __pyx_k_flags[] = "flags";
+static const char __pyx_k_ifst1[] = "ifst1";
+static const char __pyx_k_ifst2[] = "ifst2";
+static const char __pyx_k_input[] = "input";
+static const char __pyx_k_npath[] = "npath";
+static const char __pyx_k_pairs[] = "pairs";
+static const char __pyx_k_power[] = "power";
+static const char __pyx_k_props[] = "props";
+static const char __pyx_k_reset[] = "reset";
+static const char __pyx_k_start[] = "start";
+static const char __pyx_k_state[] = "state";
+static const char __pyx_k_stdin[] = "stdin";
+static const char __pyx_k_times[] = "times";
+static const char __pyx_k_title[] = "title";
+static const char __pyx_k_value[] = "value";
+static const char __pyx_k_width[] = "width";
+static const char __pyx_k_write[] = "write";
+static const char __pyx_k_CYCLIC[] = "CYCLIC";
+static const char __pyx_k_Number[] = "Number";
+static const char __pyx_k_STRING[] = "STRING";
+static const char __pyx_k_atexit[] = "atexit";
+static const char __pyx_k_create[] = "create";
+static const char __pyx_k_decode[] = "decode";
+static const char __pyx_k_divide[] = "divide";
+static const char __pyx_k_encode[] = "encode";
+static const char __pyx_k_format[] = "format";
+static const char __pyx_k_height[] = "height";
+static const char __pyx_k_ilabel[] = "ilabel";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_ipairs[] = "ipairs";
+static const char __pyx_k_member[] = "member";
+static const char __pyx_k_module[] = "__module__";
+static const char __pyx_k_name_2[] = "name";
+static const char __pyx_k_nstate[] = "nstate";
+static const char __pyx_k_object[] = "object";
+static const char __pyx_k_olabel[] = "olabel";
+static const char __pyx_k_opairs[] = "opairs";
+static const char __pyx_k_result[] = "result";
+static const char __pyx_k_select[] = "select";
+static const char __pyx_k_states[] = "states";
+static const char __pyx_k_stderr[] = "stderr";
+static const char __pyx_k_stdout[] = "stdout";
+static const char __pyx_k_symbol[] = "symbol";
+static const char __pyx_k_test_2[] = "__test__";
+static const char __pyx_k_unique[] = "unique";
+static const char __pyx_k_vector[] = "vector";
+static const char __pyx_k_verify[] = "verify";
+static const char __pyx_k_weight[] = "weight";
+static const char __pyx_k_ACYCLIC[] = "ACYCLIC";
+static const char __pyx_k_IOError[] = "IOError";
+static const char __pyx_k_MUTABLE[] = "MUTABLE";
+static const char __pyx_k_compile[] = "compile";
+static const char __pyx_k_connect[] = "connect";
+static const char __pyx_k_default[] = "default";
+static const char __pyx_k_get_fst[] = "get_fst";
+static const char __pyx_k_get_key[] = "get_key";
+static const char __pyx_k_logging[] = "logging";
+static const char __pyx_k_neither[] = "neither";
+static const char __pyx_k_nodesep[] = "nodesep";
+static const char __pyx_k_numbers[] = "numbers";
+static const char __pyx_k_prepare[] = "__prepare__";
+static const char __pyx_k_ranksep[] = "ranksep";
+static const char __pyx_k_reverse[] = "reverse";
+static const char __pyx_k_uniform[] = "uniform";
+static const char __pyx_k_warning[] = "warning";
+static const char __pyx_k_ACCEPTOR[] = "ACCEPTOR";
+static const char __pyx_k_DOT_TSVG[] = "_DOT_TSVG";
+static const char __pyx_k_EPSILONS[] = "EPSILONS";
+static const char __pyx_k_EXPANDED[] = "EXPANDED";
+static const char __pyx_k_FstError[] = "FstError";
+static const char __pyx_k_Fst_read[] = "Fst.read";
+static const char __pyx_k_KeyError[] = "KeyError";
+static const char __pyx_k_NoWeight[] = "NoWeight";
+static const char __pyx_k_WEIGHTED[] = "WEIGHTED";
+static const char __pyx_k_acceptor[] = "acceptor";
+static const char __pyx_k_arc_type[] = "arc_type";
+static const char __pyx_k_checksum[] = "checksum";
+static const char __pyx_k_distance[] = "distance";
+static const char __pyx_k_far_type[] = "far_type";
+static const char __pyx_k_filename[] = "filename";
+static const char __pyx_k_fontsize[] = "fontsize";
+static const char __pyx_k_fst_type[] = "fst_type";
+static const char __pyx_k_identity[] = "identity";
+static const char __pyx_k_isymbols[] = "isymbols";
+static const char __pyx_k_num_arcs[] = "num_arcs";
+static const char __pyx_k_osymbols[] = "osymbols";
+static const char __pyx_k_portrait[] = "portrait";
+static const char __pyx_k_position[] = "position";
+static const char __pyx_k_qualname[] = "__qualname__";
+static const char __pyx_k_read_fst[] = "read_fst";
+static const char __pyx_k_register[] = "register";
+static const char __pyx_k_repr_svg[] = "_repr_svg";
+static const char __pyx_k_set_name[] = "set_name";
+static const char __pyx_k_ssymbols[] = "ssymbols";
+static const char __pyx_k_standard[] = "standard";
+static const char __pyx_k_to_final[] = "to_final";
+static const char __pyx_k_tropical[] = "tropical";
+static const char __pyx_k_vertical[] = "vertical";
+static const char __pyx_k_weighted[] = "weighted";
+static const char __pyx_k_Fst___new[] = "Fst.__new__";
+static const char __pyx_k_add_state[] = "add_state";
+static const char __pyx_k_add_table[] = "add_table";
+static const char __pyx_k_metaclass[] = "__metaclass__";
+static const char __pyx_k_nextstate[] = "nextstate";
+static const char __pyx_k_nshortest[] = "nshortest";
+static const char __pyx_k_precision[] = "precision";
+static const char __pyx_k_pywrapfst[] = "<pywrapfst>";
+static const char __pyx_k_read_text[] = "read_text";
+static const char __pyx_k_set_flags[] = "set_flags";
+static const char __pyx_k_set_value[] = "set_value";
+static const char __pyx_k_to_string[] = "to_string";
+static const char __pyx_k_ACCESSIBLE[] = "ACCESSIBLE";
+static const char __pyx_k_FstIOError[] = "FstIOError";
+static const char __pyx_k_FstOpError[] = "FstOpError";
+static const char __pyx_k_I_EPSILONS[] = "I_EPSILONS";
+static const char __pyx_k_IndexError[] = "IndexError";
+static const char __pyx_k_NOT_STRING[] = "NOT_STRING";
+static const char __pyx_k_O_EPSILONS[] = "O_EPSILONS";
+static const char __pyx_k_TOP_SORTED[] = "TOP_SORTED";
+static const char __pyx_k_UNWEIGHTED[] = "UNWEIGHTED";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_add_symbol[] = "add_symbol";
+static const char __pyx_k_fst_string[] = "fst_string";
+static const char __pyx_k_functional[] = "functional";
+static const char __pyx_k_max_length[] = "max_length";
+static const char __pyx_k_num_states[] = "num_states";
+static const char __pyx_k_potentials[] = "potentials";
+static const char __pyx_k_properties[] = "properties";
+static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
+static const char __pyx_k_returncode[] = "returncode";
+static const char __pyx_k_subprocess[] = "subprocess";
+static const char __pyx_k_write_text[] = "write_text";
+static const char __pyx_k_Arc_at_0x_x[] = "<Arc at 0x{:x}>";
+static const char __pyx_k_FstArgError[] = "FstArgError";
+static const char __pyx_k_Fst_at_0x_x[] = "<{} Fst at 0x{:x}>";
+static const char __pyx_k_NO_EPSILONS[] = "NO_EPSILONS";
+static const char __pyx_k_communicate[] = "communicate";
+static const char __pyx_k_get_nth_key[] = "get_nth_key";
+static const char __pyx_k_input_table[] = "input_table";
+static const char __pyx_k_missing_sym[] = "missing_sym";
+static const char __pyx_k_num_symbols[] = "num_symbols";
+static const char __pyx_k_push_labels[] = "push_labels";
+static const char __pyx_k_pywrapfst_2[] = "pywrapfst";
+static const char __pyx_k_unspecified[] = "<unspecified>";
+static const char __pyx_k_weight_type[] = "weight_type";
+static const char __pyx_k_COACCESSIBLE[] = "COACCESSIBLE";
+static const char __pyx_k_NOT_ACCEPTOR[] = "NOT_ACCEPTOR";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_allow_nondet[] = "allow_nondet";
+static const char __pyx_k_closure_plus[] = "closure_plus";
+static const char __pyx_k_mutable_arcs[] = "mutable_arcs";
+static const char __pyx_k_new_isymbols[] = "new_isymbols";
+static const char __pyx_k_new_osymbols[] = "new_osymbols";
+static const char __pyx_k_old_isymbols[] = "old_isymbols";
+static const char __pyx_k_old_osymbols[] = "old_osymbols";
+static const char __pyx_k_push_weights[] = "push_weights";
+static const char __pyx_k_return_label[] = "return_label";
+static const char __pyx_k_staticmethod[] = "staticmethod";
+static const char __pyx_k_FstIndexError[] = "FstIndexError";
+static const char __pyx_k_NO_I_EPSILONS[] = "NO_I_EPSILONS";
+static const char __pyx_k_NO_O_EPSILONS[] = "NO_O_EPSILONS";
+static const char __pyx_k_Open_failed_r[] = "Open failed: {!r}";
+static const char __pyx_k_Read_failed_r[] = "Read failed: {!r}";
+static const char __pyx_k_StopIteration[] = "StopIteration";
+static const char __pyx_k_WriteToString[] = "WriteToString";
+static const char __pyx_k_available_key[] = "available_key";
+static const char __pyx_k_encode_labels[] = "encode_labels";
+static const char __pyx_k_input_symbols[] = "input_symbols";
+static const char __pyx_k_keep_isymbols[] = "keep_isymbols";
+static const char __pyx_k_keep_osymbols[] = "keep_osymbols";
+static const char __pyx_k_FST_PROPERTIES[] = "FST_PROPERTIES";
+static const char __pyx_k_INITIAL_CYCLIC[] = "INITIAL_CYCLIC";
+static const char __pyx_k_I_LABEL_SORTED[] = "I_LABEL_SORTED";
+static const char __pyx_k_NOT_ACCESSIBLE[] = "NOT_ACCESSIBLE";
+static const char __pyx_k_NOT_TOP_SORTED[] = "NOT_TOP_SORTED";
+static const char __pyx_k_O_LABEL_SORTED[] = "O_LABEL_SORTED";
+static const char __pyx_k_Weight_at_0x_x[] = "<{} Weight {} at 0x{:x}>";
+static const char __pyx_k_Write_failed_r[] = "Write failed: {!r}";
+static const char __pyx_k_encode_weights[] = "encode_weights";
+static const char __pyx_k_output_symbols[] = "output_symbols";
+static const char __pyx_k_project_output[] = "project_output";
+static const char __pyx_k_COPY_PROPERTIES[] = "COPY_PROPERTIES";
+static const char __pyx_k_INITIAL_ACYCLIC[] = "INITIAL_ACYCLIC";
+static const char __pyx_k_I_DETERMINISTIC[] = "I_DETERMINISTIC";
+static const char __pyx_k_NULL_PROPERTIES[] = "NULL_PROPERTIES";
+static const char __pyx_k_O_DETERMINISTIC[] = "O_DETERMINISTIC";
+static const char __pyx_k_WEIGHTED_CYCLES[] = "WEIGHTED_CYCLES";
+static const char __pyx_k_eps_norm_output[] = "eps_norm_output";
+static const char __pyx_k_show_weight_one[] = "show_weight_one";
+static const char __pyx_k_Cannot_construct[] = "Cannot construct {}";
+static const char __pyx_k_Key_out_of_order[] = "Key out of order";
+static const char __pyx_k_NOT_COACCESSIBLE[] = "NOT_COACCESSIBLE";
+static const char __pyx_k_Operation_failed[] = "Operation failed";
+static const char __pyx_k_labeled_checksum[] = "labeled_checksum";
+static const char __pyx_k_read_from_string[] = "read_from_string";
+static const char __pyx_k_shortestdistance[] = "shortestdistance";
+static const char __pyx_k_BINARY_PROPERTIES[] = "BINARY_PROPERTIES";
+static const char __pyx_k_FarReader_at_0x_x[] = "<{} FarReader at 0x{:x}>";
+static const char __pyx_k_FarWriter_at_0x_x[] = "<{} FarWriter at 0x{:x}>";
+static const char __pyx_k_FstBadWeightError[] = "FstBadWeightError";
+static const char __pyx_k_UNWEIGHTED_CYCLES[] = "UNWEIGHTED_CYCLES";
+static const char __pyx_k_call_arc_labeling[] = "call_arc_labeling";
+static const char __pyx_k_set_input_symbols[] = "set_input_symbols";
+static const char __pyx_k_ADD_ARC_PROPERTIES[] = "ADD_ARC_PROPERTIES";
+static const char __pyx_k_CalledProcessError[] = "CalledProcessError";
+static const char __pyx_k_Compilation_failed[] = "Compilation failed";
+static const char __pyx_k_Invalid_operator_r[] = "Invalid operator {!r}";
+static const char __pyx_k_NOT_I_LABEL_SORTED[] = "NOT_I_LABEL_SORTED";
+static const char __pyx_k_NOT_O_LABEL_SORTED[] = "NOT_O_LABEL_SORTED";
+static const char __pyx_k_SET_ARC_PROPERTIES[] = "SET_ARC_PROPERTIES";
+static const char __pyx_k_TRINARY_PROPERTIES[] = "TRINARY_PROPERTIES";
+static const char __pyx_k_Unknown_arc_type_r[] = "Unknown arc type: {!r}";
+static const char __pyx_k_Unknown_map_type_r[] = "Unknown map type: {!r}";
+static const char __pyx_k_epsilon_on_replace[] = "epsilon_on_replace";
+static const char __pyx_k_num_input_epsilons[] = "num_input_epsilons";
+static const char __pyx_k_set_output_symbols[] = "set_output_symbols";
+static const char __pyx_k_ARC_SORT_PROPERTIES[] = "ARC_SORT_PROPERTIES";
+static const char __pyx_k_ArcIterator_at_0x_x[] = "<ArcIterator at 0x{:x}>";
+static const char __pyx_k_NON_I_DETERMINISTIC[] = "NON_I_DETERMINISTIC";
+static const char __pyx_k_NON_O_DETERMINISTIC[] = "NON_O_DETERMINISTIC";
+static const char __pyx_k_NotImplementedError[] = "NotImplementedError";
+static const char __pyx_k_Unknown_sort_type_r[] = "Unknown sort type {!r}";
+static const char __pyx_k_attach_new_isymbols[] = "attach_new_isymbols";
+static const char __pyx_k_attach_new_osymbols[] = "attach_new_osymbols";
+static const char __pyx_k_fst_error_fatal_old[] = "_fst_error_fatal_old";
+static const char __pyx_k_num_output_epsilons[] = "num_output_epsilons";
+static const char __pyx_k_remove_common_affix[] = "remove_common_affix";
+static const char __pyx_k_remove_total_weight[] = "remove_total_weight";
+static const char __pyx_k_return_arc_labeling[] = "return_arc_labeling";
+static const char __pyx_k_subsequential_label[] = "subsequential_label";
+static const char __pyx_k_ADD_STATE_PROPERTIES[] = "ADD_STATE_PROPERTIES";
+static const char __pyx_k_EXTRINSIC_PROPERTIES[] = "EXTRINSIC_PROPERTIES";
+static const char __pyx_k_EncodeMapper_at_0x_x[] = "<EncodeMapper at 0x{:x}>";
+static const char __pyx_k_Fst_read_from_string[] = "Fst.read_from_string";
+static const char __pyx_k_INTRINSIC_PROPERTIES[] = "INTRINSIC_PROPERTIES";
+static const char __pyx_k_SET_FINAL_PROPERTIES[] = "SET_FINAL_PROPERTIES";
+static const char __pyx_k_SET_START_PROPERTIES[] = "SET_START_PROPERTIES";
+static const char __pyx_k_Unknown_queue_type_r[] = "Unknown queue type: {!r}";
+static const char __pyx_k_keep_state_numbering[] = "keep_state_numbering";
+static const char __pyx_k_require_superinitial[] = "require_superinitial";
+static const char __pyx_k_DELETE_ARC_PROPERTIES[] = "DELETE_ARC_PROPERTIES";
+static const char __pyx_k_STATE_SORT_PROPERTIES[] = "STATE_SORT_PROPERTIES";
+static const char __pyx_k_StateIterator_at_0x_x[] = "<StateIterator at 0x{:x}>";
+static const char __pyx_k_SymbolTable_r_at_0x_x[] = "<SymbolTable {!r} at 0x{:x}>";
+static const char __pyx_k_allow_negative_labels[] = "allow_negative_labels";
+static const char __pyx_k_reset_fst_error_fatal[] = "_reset_fst_error_fatal";
+static const char __pyx_k_Conversion_to_r_failed[] = "Conversion to {!r} failed.";
+static const char __pyx_k_NEG_TRINARY_PROPERTIES[] = "NEG_TRINARY_PROPERTIES";
+static const char __pyx_k_POS_TRINARY_PROPERTIES[] = "POS_TRINARY_PROPERTIES";
+static const char __pyx_k_DELETE_STATE_PROPERTIES[] = "DELETE_STATE_PROPERTIES";
+static const char __pyx_k_Conversion_to_r_failed_2[] = "Conversion to {!r} failed";
+static const char __pyx_k_RM_SUPERFINAL_PROPERTIES[] = "RM_SUPERFINAL_PROPERTIES";
+static const char __pyx_k_State_index_out_of_range[] = "State index out of range";
+static const char __pyx_k_ADD_SUPERFINAL_PROPERTIES[] = "ADD_SUPERFINAL_PROPERTIES";
+static const char __pyx_k_Cannot_encode_as_string_r[] = "Cannot encode as string: {!r}";
+static const char __pyx_k_Cannot_topsort_cyclic_FST[] = "Cannot topsort cyclic FST.";
+static const char __pyx_k_FstUnknownWeightTypeError[] = "FstUnknownWeightTypeError";
+static const char __pyx_k_Fst_SymbolTable_r_at_0x_x[] = "<Fst SymbolTable {!r} at 0x{:x}>";
+static const char __pyx_k_FstDeletedConstructorError[] = "FstDeletedConstructorError";
+static const char __pyx_k_MutableArcIterator_at_0x_x[] = "<MutableArcIterator at 0x{:x}>";
+static const char __pyx_k_SymbolTableIterator_at_0x_x[] = "<SymbolTableIterator at 0x{:x}>";
+static const char __pyx_k_WEIGHT_INVARIANT_PROPERTIES[] = "WEIGHT_INVARIANT_PROPERTIES";
+static const char __pyx_k_I_LABEL_INVARIANT_PROPERTIES[] = "I_LABEL_INVARIANT_PROPERTIES";
+static const char __pyx_k_O_LABEL_INVARIANT_PROPERTIES[] = "O_LABEL_INVARIANT_PROPERTIES";
+static const char __pyx_k_Unknown_replace_label_type_r[] = "Unknown replace label type: {!r}";
+static const char __pyx_k_No_new_SymbolTables_specified[] = "No new SymbolTables specified";
+static const char __pyx_k_No_relabeling_pairs_specified[] = "No relabeling pairs specified.";
+static const char __pyx_k_Unknown_compose_filter_type_r[] = "Unknown compose filter type: {!r}";
+static const char __pyx_k_increment_subsequential_label[] = "increment_subsequential_label";
+static const char __pyx_k_Unknown_determinization_type_r[] = "Unknown determinization type: {!r}";
+static const char __pyx_k_const_EncodeMapper_SymbolTable[] = "<const EncodeMapper SymbolTable {!r} at 0x{:x}>";
+static const char __pyx_k_incompatible_or_invalid_weight[] = "incompatible or invalid weight";
+static const char __pyx_k_Fst_arc_type_standard_Construct[] = "\n Fst(arc_type=\"standard\")\n\n Constructs an empty FST.\n\n Args:\n arc_type: A string indicating the arc type.\n\n Raises:\n FstError: Unknown arc type.\n\n Raises:\n FstOpError: operation failed.\n ";
+static const char __pyx_k_const_Fst_SymbolTable_r_at_0x_x[] = "<const Fst SymbolTable {!r} at 0x{:x}>";
+static const char __pyx_k_usr_local_google_home_kbg_scrat[] = "/usr/local/google/home/kbg/scratch/pynini/src/pywrapfst.pyx";
+static const char __pyx_k_Equivalence_test_encountered_err[] = "Equivalence test encountered error";
+static const char __pyx_k_Incompatible_or_invalid_arc_type[] = "Incompatible or invalid arc type";
+static const char __pyx_k_Incompatible_or_invalid_weight_t[] = "Incompatible or invalid weight type";
+static const char __pyx_k_Python_interface_to_the_FST_scri[] = "Python interface to the FST scripting API.\n\nOperations which construct new FSTs are implemented as traditional functions, as\nare two-argument boolean functions like `equal` and `equivalent`. Destructive\noperations---those that mutate an FST, in place---are instance methods, as is\n`write`. Operator overloading is not used. The following example, based on\nMohri et al. 2002, shows the construction of an ASR system given a pronunciation\nlexicon L, grammar G, a transducer from context-dependent phones to\ncontext-independent phones C, and an HMM set H:\n\n L = fst.Fst.read(\"L.fst\")\n G = fst.Fst.read(\"G.fst\")\n C = fst.Fst.read(\"C.fst\")\n H = fst.Fst.read(\"H.fst\")\n LG = fst.determinize(fst.compose(L, G))\n CLG = fst.determinize(fst.compose(C, LG))\n HCLG = fst.determinize(fst.compose(H, CLG))\n HCLG.minimize() # NB: works in-place.\n\nPython variables here use snake_case and constants are in all caps, minus the\nnormal `k` prefix.\n";
+static const char __pyx_k_Random_equivalence_test_encounte[] = "Random equivalence test encountered error";
+static const char __pyx_k_Unknown_random_arc_selection_typ[] = "Unknown random arc selection type: {!r}";
+static PyObject *__pyx_kp_b_;
+static PyObject *__pyx_n_s_ACCEPTOR;
+static PyObject *__pyx_n_s_ACCESSIBLE;
+static PyObject *__pyx_n_s_ACYCLIC;
+static PyObject *__pyx_n_s_ADD_ARC_PROPERTIES;
+static PyObject *__pyx_n_s_ADD_STATE_PROPERTIES;
+static PyObject *__pyx_n_s_ADD_SUPERFINAL_PROPERTIES;
+static PyObject *__pyx_n_s_ARC_SORT_PROPERTIES;
+static PyObject *__pyx_kp_s_ArcIterator_at_0x_x;
+static PyObject *__pyx_kp_s_Arc_at_0x_x;
+static PyObject *__pyx_n_s_BINARY_PROPERTIES;
+static PyObject *__pyx_n_s_COACCESSIBLE;
+static PyObject *__pyx_n_s_COPY_PROPERTIES;
+static PyObject *__pyx_n_s_CYCLIC;
+static PyObject *__pyx_n_s_CalledProcessError;
+static PyObject *__pyx_kp_s_Cannot_construct;
+static PyObject *__pyx_kp_s_Cannot_encode_as_string_r;
+static PyObject *__pyx_kp_s_Cannot_topsort_cyclic_FST;
+static PyObject *__pyx_kp_s_Compilation_failed;
+static PyObject *__pyx_kp_s_Conversion_to_r_failed;
+static PyObject *__pyx_kp_s_Conversion_to_r_failed_2;
+static PyObject *__pyx_n_s_DELETE_ARC_PROPERTIES;
+static PyObject *__pyx_n_s_DELETE_STATE_PROPERTIES;
+static PyObject *__pyx_n_s_DOT_TSVG;
+static PyObject *__pyx_n_s_EPSILONS;
+static PyObject *__pyx_n_s_ERROR;
+static PyObject *__pyx_n_s_EXPANDED;
+static PyObject *__pyx_n_s_EXTRINSIC_PROPERTIES;
+static PyObject *__pyx_kp_s_EncodeMapper_at_0x_x;
+static PyObject *__pyx_kp_s_Equivalence_test_encountered_err;
+static PyObject *__pyx_n_s_FST_PROPERTIES;
+static PyObject *__pyx_kp_s_FarReader_at_0x_x;
+static PyObject *__pyx_kp_s_FarWriter_at_0x_x;
+static PyObject *__pyx_n_s_Fst;
+static PyObject *__pyx_n_s_FstArgError;
+static PyObject *__pyx_n_s_FstBadWeightError;
+static PyObject *__pyx_n_s_FstDeletedConstructorError;
+static PyObject *__pyx_n_s_FstError;
+static PyObject *__pyx_n_s_FstIOError;
+static PyObject *__pyx_n_s_FstIndexError;
+static PyObject *__pyx_n_s_FstOpError;
+static PyObject *__pyx_n_s_FstUnknownWeightTypeError;
+static PyObject *__pyx_kp_s_Fst_SymbolTable_r_at_0x_x;
+static PyObject *__pyx_n_s_Fst___new;
+static PyObject *__pyx_kp_s_Fst_arc_type_standard_Construct;
+static PyObject *__pyx_kp_s_Fst_at_0x_x;
+static PyObject *__pyx_n_s_Fst_read;
+static PyObject *__pyx_n_s_Fst_read_from_string;
+static PyObject *__pyx_n_s_INITIAL_ACYCLIC;
+static PyObject *__pyx_n_s_INITIAL_CYCLIC;
+static PyObject *__pyx_n_s_INTRINSIC_PROPERTIES;
+static PyObject *__pyx_n_s_IOError;
+static PyObject *__pyx_n_s_I_DETERMINISTIC;
+static PyObject *__pyx_n_s_I_EPSILONS;
+static PyObject *__pyx_n_s_I_LABEL_INVARIANT_PROPERTIES;
+static PyObject *__pyx_n_s_I_LABEL_SORTED;
+static PyObject *__pyx_kp_s_Incompatible_or_invalid_arc_type;
+static PyObject *__pyx_kp_s_Incompatible_or_invalid_weight_t;
+static PyObject *__pyx_n_s_IndexError;
+static PyObject *__pyx_kp_s_Invalid_operator_r;
+static PyObject *__pyx_n_s_KeyError;
+static PyObject *__pyx_kp_s_Key_out_of_order;
+static PyObject *__pyx_n_s_MUTABLE;
+static PyObject *__pyx_kp_s_MutableArcIterator_at_0x_x;
+static PyObject *__pyx_n_s_NEG_TRINARY_PROPERTIES;
+static PyObject *__pyx_n_s_NON_I_DETERMINISTIC;
+static PyObject *__pyx_n_s_NON_O_DETERMINISTIC;
+static PyObject *__pyx_n_s_NOT_ACCEPTOR;
+static PyObject *__pyx_n_s_NOT_ACCESSIBLE;
+static PyObject *__pyx_n_s_NOT_COACCESSIBLE;
+static PyObject *__pyx_n_s_NOT_I_LABEL_SORTED;
+static PyObject *__pyx_n_s_NOT_O_LABEL_SORTED;
+static PyObject *__pyx_n_s_NOT_STRING;
+static PyObject *__pyx_n_s_NOT_TOP_SORTED;
+static PyObject *__pyx_n_s_NO_EPSILONS;
+static PyObject *__pyx_n_s_NO_I_EPSILONS;
+static PyObject *__pyx_n_s_NO_O_EPSILONS;
+static PyObject *__pyx_n_s_NULL_PROPERTIES;
+static PyObject *__pyx_n_s_NoWeight;
+static PyObject *__pyx_kp_s_No_new_SymbolTables_specified;
+static PyObject *__pyx_kp_s_No_relabeling_pairs_specified;
+static PyObject *__pyx_n_s_NotImplementedError;
+static PyObject *__pyx_n_s_Number;
+static PyObject *__pyx_n_s_O_DETERMINISTIC;
+static PyObject *__pyx_n_s_O_EPSILONS;
+static PyObject *__pyx_n_s_O_LABEL_INVARIANT_PROPERTIES;
+static PyObject *__pyx_n_s_O_LABEL_SORTED;
+static PyObject *__pyx_n_s_One;
+static PyObject *__pyx_kp_s_Open_failed_r;
+static PyObject *__pyx_kp_s_Operation_failed;
+static PyObject *__pyx_n_s_PIPE;
+static PyObject *__pyx_n_s_POS_TRINARY_PROPERTIES;
+static PyObject *__pyx_n_s_Popen;
+static PyObject *__pyx_n_s_RM_SUPERFINAL_PROPERTIES;
+static PyObject *__pyx_kp_s_Random_equivalence_test_encounte;
+static PyObject *__pyx_kp_s_Read_failed_r;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_n_s_SET_ARC_PROPERTIES;
+static PyObject *__pyx_n_s_SET_FINAL_PROPERTIES;
+static PyObject *__pyx_n_s_SET_START_PROPERTIES;
+static PyObject *__pyx_n_s_STATE_SORT_PROPERTIES;
+static PyObject *__pyx_n_s_STRING;
+static PyObject *__pyx_kp_s_StateIterator_at_0x_x;
+static PyObject *__pyx_kp_s_State_index_out_of_range;
+static PyObject *__pyx_n_s_StopIteration;
+static PyObject *__pyx_kp_s_SymbolTableIterator_at_0x_x;
+static PyObject *__pyx_kp_s_SymbolTable_r_at_0x_x;
+static PyObject *__pyx_n_s_TOP_SORTED;
+static PyObject *__pyx_n_s_TRINARY_PROPERTIES;
+static PyObject *__pyx_kp_s_Tsvg;
+static PyObject *__pyx_n_s_UNWEIGHTED;
+static PyObject *__pyx_n_s_UNWEIGHTED_CYCLES;
+static PyObject *__pyx_kp_s_Unknown_arc_type_r;
+static PyObject *__pyx_kp_s_Unknown_compose_filter_type_r;
+static PyObject *__pyx_kp_s_Unknown_determinization_type_r;
+static PyObject *__pyx_kp_s_Unknown_map_type_r;
+static PyObject *__pyx_kp_s_Unknown_queue_type_r;
+static PyObject *__pyx_kp_s_Unknown_random_arc_selection_typ;
+static PyObject *__pyx_kp_s_Unknown_replace_label_type_r;
+static PyObject *__pyx_kp_s_Unknown_sort_type_r;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_n_s_WEIGHTED;
+static PyObject *__pyx_n_s_WEIGHTED_CYCLES;
+static PyObject *__pyx_n_s_WEIGHT_INVARIANT_PROPERTIES;
+static PyObject *__pyx_kp_s_Weight_at_0x_x;
+static PyObject *__pyx_n_s_WriteToString;
+static PyObject *__pyx_kp_s_Write_failed_r;
+static PyObject *__pyx_n_s_Zero;
+static PyObject *__pyx_n_s_acceptor;
+static PyObject *__pyx_n_s_add;
+static PyObject *__pyx_n_s_add_state;
+static PyObject *__pyx_n_s_add_symbol;
+static PyObject *__pyx_n_s_add_table;
+static PyObject *__pyx_n_s_allow_negative_labels;
+static PyObject *__pyx_n_s_allow_nondet;
+static PyObject *__pyx_n_s_arc;
+static PyObject *__pyx_n_s_arc_type;
+static PyObject *__pyx_n_s_arcs;
+static PyObject *__pyx_n_s_atexit;
+static PyObject *__pyx_n_s_attach_new_isymbols;
+static PyObject *__pyx_n_s_attach_new_osymbols;
+static PyObject *__pyx_n_b_auto;
+static PyObject *__pyx_n_s_available_key;
+static PyObject *__pyx_n_s_call_arc_labeling;
+static PyObject *__pyx_n_s_cf;
+static PyObject *__pyx_n_s_checksum;
+static PyObject *__pyx_n_s_class;
+static PyObject *__pyx_n_s_closure_plus;
+static PyObject *__pyx_n_s_cls;
+static PyObject *__pyx_n_s_communicate;
+static PyObject *__pyx_n_s_compile;
+static PyObject *__pyx_n_s_connect;
+static PyObject *__pyx_kp_s_const_EncodeMapper_SymbolTable;
+static PyObject *__pyx_kp_s_const_Fst_SymbolTable_r_at_0x_x;
+static PyObject *__pyx_n_s_copy;
+static PyObject *__pyx_n_s_create;
+static PyObject *__pyx_n_s_decode;
+static PyObject *__pyx_n_b_default;
+static PyObject *__pyx_n_s_delta;
+static PyObject *__pyx_n_s_distance;
+static PyObject *__pyx_n_s_divide;
+static PyObject *__pyx_n_s_doc;
+static PyObject *__pyx_n_s_done;
+static PyObject *__pyx_n_s_dot;
+static PyObject *__pyx_n_s_draw;
+static PyObject *__pyx_n_s_dt;
+static PyObject *__pyx_n_s_encode;
+static PyObject *__pyx_n_s_encode_labels;
+static PyObject *__pyx_n_s_encode_weights;
+static PyObject *__pyx_n_s_eps_norm_output;
+static PyObject *__pyx_n_s_epsilon_on_replace;
+static PyObject *__pyx_n_s_error;
+static PyObject *__pyx_n_s_far_type;
+static PyObject *__pyx_n_s_filename;
+static PyObject *__pyx_n_s_final;
+static PyObject *__pyx_n_s_find;
+static PyObject *__pyx_n_s_flags;
+static PyObject *__pyx_n_s_fontsize;
+static PyObject *__pyx_n_s_format;
+static PyObject *__pyx_n_s_fst_error_fatal_old;
+static PyObject *__pyx_n_s_fst_string;
+static PyObject *__pyx_n_s_fst_type;
+static PyObject *__pyx_n_b_functional;
+static PyObject *__pyx_n_s_get_fst;
+static PyObject *__pyx_n_s_get_key;
+static PyObject *__pyx_n_s_get_nth_key;
+static PyObject *__pyx_n_s_height;
+static PyObject *__pyx_n_s_id;
+static PyObject *__pyx_n_b_identity;
+static PyObject *__pyx_n_s_ifst;
+static PyObject *__pyx_n_s_ifst1;
+static PyObject *__pyx_n_s_ifst2;
+static PyObject *__pyx_n_b_ilabel;
+static PyObject *__pyx_n_s_ilabel;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_kp_s_incompatible_or_invalid_weight;
+static PyObject *__pyx_n_s_increment_subsequential_label;
+static PyObject *__pyx_n_b_input;
+static PyObject *__pyx_n_s_input_symbols;
+static PyObject *__pyx_n_s_input_table;
+static PyObject *__pyx_n_s_ipairs;
+static PyObject *__pyx_n_s_isymbols;
+static PyObject *__pyx_n_s_it;
+static PyObject *__pyx_n_s_keep_isymbols;
+static PyObject *__pyx_n_s_keep_osymbols;
+static PyObject *__pyx_n_s_keep_state_numbering;
+static PyObject *__pyx_n_s_key;
+static PyObject *__pyx_n_s_labeled_checksum;
+static PyObject *__pyx_n_s_lhs;
+static PyObject *__pyx_n_s_logging;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_n_s_mask;
+static PyObject *__pyx_n_s_max_length;
+static PyObject *__pyx_n_s_member;
+static PyObject *__pyx_n_s_metaclass;
+static PyObject *__pyx_n_s_missing_sym;
+static PyObject *__pyx_n_s_module;
+static PyObject *__pyx_n_s_mt;
+static PyObject *__pyx_n_s_mutable_arcs;
+static PyObject *__pyx_n_s_n;
+static PyObject *__pyx_n_s_name;
+static PyObject *__pyx_n_s_name_2;
+static PyObject *__pyx_n_b_neither;
+static PyObject *__pyx_n_s_new;
+static PyObject *__pyx_n_s_new_isymbols;
+static PyObject *__pyx_n_s_new_osymbols;
+static PyObject *__pyx_n_s_next;
+static PyObject *__pyx_n_s_nextstate;
+static PyObject *__pyx_n_s_nodesep;
+static PyObject *__pyx_n_s_npath;
+static PyObject *__pyx_n_s_nshortest;
+static PyObject *__pyx_n_s_nstate;
+static PyObject *__pyx_n_s_num_arcs;
+static PyObject *__pyx_n_s_num_input_epsilons;
+static PyObject *__pyx_n_s_num_output_epsilons;
+static PyObject *__pyx_n_s_num_states;
+static PyObject *__pyx_n_s_num_symbols;
+static PyObject *__pyx_n_s_numbers;
+static PyObject *__pyx_n_s_object;
+static PyObject *__pyx_n_s_olabel;
+static PyObject *__pyx_n_s_old_isymbols;
+static PyObject *__pyx_n_s_old_osymbols;
+static PyObject *__pyx_n_s_opairs;
+static PyObject *__pyx_n_s_open;
+static PyObject *__pyx_n_s_osymbols;
+static PyObject *__pyx_n_s_output_symbols;
+static PyObject *__pyx_n_s_pairs;
+static PyObject *__pyx_n_s_plus;
+static PyObject *__pyx_n_s_portrait;
+static PyObject *__pyx_n_s_position;
+static PyObject *__pyx_n_s_potentials;
+static PyObject *__pyx_n_s_power;
+static PyObject *__pyx_n_s_precision;
+static PyObject *__pyx_n_s_prepare;
+static PyObject *__pyx_n_s_project_output;
+static PyObject *__pyx_n_s_properties;
+static PyObject *__pyx_n_s_props;
+static PyObject *__pyx_n_s_push_labels;
+static PyObject *__pyx_n_s_push_weights;
+static PyObject *__pyx_kp_b_pywrapfst;
+static PyObject *__pyx_n_s_pywrapfst_2;
+static PyObject *__pyx_n_s_pyx_vtable;
+static PyObject *__pyx_n_s_qt;
+static PyObject *__pyx_n_s_qualname;
+static PyObject *__pyx_n_s_ranksep;
+static PyObject *__pyx_n_s_read;
+static PyObject *__pyx_n_s_read_from_string;
+static PyObject *__pyx_n_s_read_fst;
+static PyObject *__pyx_n_s_read_text;
+static PyObject *__pyx_n_s_register;
+static PyObject *__pyx_n_s_remove_common_affix;
+static PyObject *__pyx_n_s_remove_total_weight;
+static PyObject *__pyx_n_b_repr_svg;
+static PyObject *__pyx_n_s_require_superinitial;
+static PyObject *__pyx_n_s_reset;
+static PyObject *__pyx_n_s_reset_fst_error_fatal;
+static PyObject *__pyx_n_s_result;
+static PyObject *__pyx_n_s_return_arc_labeling;
+static PyObject *__pyx_n_s_return_label;
+static PyObject *__pyx_n_s_returncode;
+static PyObject *__pyx_n_s_reverse;
+static PyObject *__pyx_n_s_rhs;
+static PyObject *__pyx_n_s_seed;
+static PyObject *__pyx_n_s_seek;
+static PyObject *__pyx_n_s_select;
+static PyObject *__pyx_n_s_set_flags;
+static PyObject *__pyx_n_s_set_input_symbols;
+static PyObject *__pyx_n_s_set_name;
+static PyObject *__pyx_n_s_set_output_symbols;
+static PyObject *__pyx_n_s_set_value;
+static PyObject *__pyx_n_s_shortestdistance;
+static PyObject *__pyx_n_s_show_weight_one;
+static PyObject *__pyx_n_s_ssymbols;
+static PyObject *__pyx_n_s_st;
+static PyObject *__pyx_n_b_standard;
+static PyObject *__pyx_n_s_start;
+static PyObject *__pyx_n_s_state;
+static PyObject *__pyx_n_s_states;
+static PyObject *__pyx_n_s_staticmethod;
+static PyObject *__pyx_n_s_stderr;
+static PyObject *__pyx_n_s_stdin;
+static PyObject *__pyx_n_s_stdout;
+static PyObject *__pyx_n_s_subprocess;
+static PyObject *__pyx_n_s_subsequential_label;
+static PyObject *__pyx_n_s_symbol;
+static PyObject *__pyx_n_s_syms;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_test_2;
+static PyObject *__pyx_n_s_text;
+static PyObject *__pyx_n_s_times;
+static PyObject *__pyx_n_s_title;
+static PyObject *__pyx_n_s_to_final;
+static PyObject *__pyx_n_s_to_string;
+static PyObject *__pyx_n_b_tropical;
+static PyObject *__pyx_n_s_type;
+static PyObject *__pyx_n_b_uniform;
+static PyObject *__pyx_n_s_unique;
+static PyObject *__pyx_kp_b_unspecified;
+static PyObject *__pyx_kp_s_usr_local_google_home_kbg_scrat;
+static PyObject *__pyx_n_s_utf8;
+static PyObject *__pyx_n_s_value;
+static PyObject *__pyx_n_b_vector;
+static PyObject *__pyx_n_s_verify;
+static PyObject *__pyx_n_s_vertical;
+static PyObject *__pyx_n_s_w;
+static PyObject *__pyx_n_s_warning;
+static PyObject *__pyx_n_s_weight;
+static PyObject *__pyx_n_s_weight_type;
+static PyObject *__pyx_n_s_weighted;
+static PyObject *__pyx_n_s_width;
+static PyObject *__pyx_n_s_write;
+static PyObject *__pyx_n_s_write_text;
+static PyObject *__pyx_pf_9pywrapfst_6Weight___repr__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_2__str__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_4__float__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_6Weight_6__init__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, PyObject *__pyx_v_weight_type, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_8copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_10Zero(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_12One(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_14NoWeight(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_16__richcmp__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_x, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_y, int __pyx_v_op); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_18to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6Weight_20type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_plus(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_2times(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4divide(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_6power(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w, size_t __pyx_v_n); /* proto */
+static int __pyx_pf_9pywrapfst_12_SymbolTable___init__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_2__iter__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_4available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_6checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_8copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_10find(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_12member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static int __pyx_pf_9pywrapfst_12_SymbolTable_14__contains__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_16get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_18labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_20name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_22num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_24write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_26write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable___repr__(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, __pyx_t_10basictypes_int64 __pyx_v_key); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_2add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_4set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable___repr__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_11SymbolTable_2__init__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self, PyObject *__pyx_v_name); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_4read(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_6read_text(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_allow_negative_labels); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_8read_fst(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_input_table); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_8compact_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_10merge_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator___repr__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_19SymbolTableIterator_2__init__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_4__iter__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_6__next__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_8done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_10next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_12reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_14symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_16value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper___repr__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_12EncodeMapper_2__init__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, PyObject *__pyx_v_arc_type, bool __pyx_v_encode_labels, bool __pyx_v_encode_weights); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_4arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_6__call__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_8flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_10input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_12output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_14properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_16set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_18set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_20weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst__repr_svg_(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_2__repr__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_4_Fst_4__init__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_6__str__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_8arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_10arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_12copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_14draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, PyObject *__pyx_v_title, double __pyx_v_width, double __pyx_v_height, bool __pyx_v_portrait, bool __pyx_v_vertical, double __pyx_v_ranksep, double __pyx_v_nodesep, __pyx_t_10basictypes_int32 __pyx_v_fontsize, __pyx_t_10basictypes_int32 __pyx_v_precision, bool __pyx_v_show_weight_one); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_16final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_18fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_20input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_22num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_24num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_26num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_28output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_30properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_32start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_34states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_36text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_show_weight_one, PyObject *__pyx_v_missing_sym); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_38verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_40weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_42write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_44WriteToString(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_2add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_4arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_st); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_6closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_closure_plus); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_8concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_10connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_12decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_14delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_16delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_states); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_18encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_20invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_22minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, CYTHON_UNUSED bool __pyx_v_allow_nondet); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_24mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_26mutable_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_28mutable_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_30num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_32project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_project_output); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_34prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_36push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_38relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_ipairs, PyObject *__pyx_v_opairs); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_40relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols, bool __pyx_v_attach_new_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols, bool __pyx_v_attach_new_osymbols); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_42reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_44reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_46reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, bool __pyx_v_to_final); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_48rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_connect, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_50set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_52set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_54set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_56set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_58set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_60topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_62union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Fst___new__(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_cls, PyObject *__pyx_v_arc_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Fst_2read(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_fst_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Fst_4read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_fst_string, PyObject *__pyx_v_fst_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Arc___repr__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_3Arc_2__init__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_ilabel, __pyx_t_10basictypes_int64 __pyx_v_olabel, PyObject *__pyx_v_weight, __pyx_t_10basictypes_int64 __pyx_v_nextstate); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Arc_4copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Arc_6ilabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_3Arc_6ilabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Arc_6olabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_3Arc_6olabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Arc_6weight___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_3Arc_6weight_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_3Arc_9nextstate___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_3Arc_9nextstate_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator___repr__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_11ArcIterator_2__init__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_4__iter__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_6__next__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_8done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_10flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_12next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_14position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_16reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_18seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_20set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_22value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator___repr__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_18MutableArcIterator_2__init__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_4__iter__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_6__next__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_8done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_10flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_12next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_14position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_16reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_18seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_20set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_22set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_24value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator___repr__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_13StateIterator_2__init__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_4__iter__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_6__next__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_8done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_10next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_12reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_14value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_12arcmap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_mt, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_14compose(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_cf, bool __pyx_v_connect); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_16convert(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_fst_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_18determinize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_dt, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight, bool __pyx_v_increment_subsequential_label); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_20difference(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_cf, bool __pyx_v_connect); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_22disambiguate(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_24epsnormalize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_eps_norm_output); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_26equal(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_28equivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_30intersect(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_cf, bool __pyx_v_connect); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_32isomorphic(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_34prune(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_36push(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, bool __pyx_v_push_weights, bool __pyx_v_push_labels, bool __pyx_v_remove_common_affix, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_38randequivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, __pyx_t_10basictypes_int32 __pyx_v_npath, float __pyx_v_delta, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_40randgen(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int32 __pyx_v_npath, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length, bool __pyx_v_weighted, bool __pyx_v_remove_total_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_42replace(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pairs, PyObject *__pyx_v_call_arc_labeling, PyObject *__pyx_v_return_arc_labeling, bool __pyx_v_epsilon_on_replace, __pyx_t_10basictypes_int64 __pyx_v_return_label); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_44reverse(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_require_superinitial); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_46rmepsilon(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_connect, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_qt, bool __pyx_v_reverse, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_48shortestdistance(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_qt, bool __pyx_v_reverse); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_50shortestpath(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int32 __pyx_v_nshortest, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_qt, bool __pyx_v_unique, PyObject *__pyx_v_weight); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_52statemap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_mt); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_54synchronize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */
+static int __pyx_pf_9pywrapfst_8Compiler___cinit__(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, std::string __pyx_v_fst_type, std::string __pyx_v_arc_type, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_keep_isymbols, bool __pyx_v_keep_osymbols, bool __pyx_v_keep_state_numbering, bool __pyx_v_allow_negative_labels); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_8Compiler_2compile(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_8Compiler_4write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression); /* proto */
+static int __pyx_pf_9pywrapfst_9FarReader___init__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_2__repr__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_4open(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filenames); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_6__iter__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_8__next__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_10arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_12done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_14error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_16far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_18find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_20get_fst(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_22get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_24next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_26reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_28__getitem__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key); /* proto */
+static int __pyx_pf_9pywrapfst_9FarWriter___init__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_2__repr__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_4create(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, PyObject *__pyx_v_arc_type, PyObject *__pyx_v_far_type); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_6add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_8arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_10error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_12far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self); /* proto */
+static int __pyx_pf_9pywrapfst_9FarWriter_14__setitem__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_fst); /* proto */
+static PyObject *__pyx_pf_9pywrapfst_56_reset_fst_error_fatal(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
+static PyObject *__pyx_tp_new_9pywrapfst_Weight(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst__SymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst__FstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst__MutableSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst__MutableFstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_SymbolTable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_SymbolTableIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_EncodeMapper(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst__Fst(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst__MutableFst(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_Arc(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_ArcIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_MutableArcIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_StateIterator(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_Compiler(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_FarReader(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_9pywrapfst_FarWriter(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_int_0;
+static PyObject *__pyx_int_neg_1;
+static float __pyx_k__11;
+static float __pyx_k__12;
+static float __pyx_k__13;
+static __pyx_t_10basictypes_int64 __pyx_k__14;
+static float __pyx_k__15;
+static __pyx_t_10basictypes_int64 __pyx_k__16;
+static float __pyx_k__17;
+static float __pyx_k__18;
+static float __pyx_k__22;
+static __pyx_t_10basictypes_int64 __pyx_k__23;
+static float __pyx_k__24;
+static __pyx_t_10basictypes_int64 __pyx_k__25;
+static float __pyx_k__34;
+static float __pyx_k__35;
+static float __pyx_k__36;
+static __pyx_t_10basictypes_int64 __pyx_k__37;
+static float __pyx_k__38;
+static __pyx_t_10basictypes_int64 __pyx_k__39;
+static float __pyx_k__40;
+static float __pyx_k__41;
+static float __pyx_k__43;
+static float __pyx_k__44;
+static __pyx_t_10basictypes_int64 __pyx_k__45;
+static float __pyx_k__46;
+static float __pyx_k__47;
+static __pyx_t_10basictypes_int32 __pyx_k__48;
+static __pyx_t_10basictypes_int32 __pyx_k__50;
+static float __pyx_k__51;
+static __pyx_t_10basictypes_int64 __pyx_k__52;
+static float __pyx_k__53;
+static __pyx_t_10basictypes_int64 __pyx_k__54;
+static float __pyx_k__55;
+static __pyx_t_10basictypes_int64 __pyx_k__56;
+static float __pyx_k__57;
+static __pyx_t_10basictypes_int64 __pyx_k__58;
+static std::string __pyx_k__59;
+static std::string __pyx_k__60;
+static PyObject *__pyx_tuple__2;
+static PyObject *__pyx_tuple__3;
+static PyObject *__pyx_tuple__4;
+static PyObject *__pyx_tuple__5;
+static PyObject *__pyx_tuple__6;
+static PyObject *__pyx_tuple__7;
+static PyObject *__pyx_tuple__8;
+static PyObject *__pyx_tuple__9;
+static PyObject *__pyx_tuple__10;
+static PyObject *__pyx_tuple__19;
+static PyObject *__pyx_tuple__20;
+static PyObject *__pyx_tuple__21;
+static PyObject *__pyx_tuple__26;
+static PyObject *__pyx_tuple__27;
+static PyObject *__pyx_tuple__28;
+static PyObject *__pyx_tuple__29;
+static PyObject *__pyx_tuple__30;
+static PyObject *__pyx_tuple__31;
+static PyObject *__pyx_tuple__32;
+static PyObject *__pyx_tuple__33;
+static PyObject *__pyx_tuple__42;
+static PyObject *__pyx_tuple__49;
+static PyObject *__pyx_tuple__61;
+static PyObject *__pyx_tuple__62;
+static PyObject *__pyx_tuple__63;
+static PyObject *__pyx_tuple__64;
+static PyObject *__pyx_tuple__66;
+static PyObject *__pyx_tuple__68;
+static PyObject *__pyx_tuple__70;
+static PyObject *__pyx_tuple__72;
+static PyObject *__pyx_tuple__74;
+static PyObject *__pyx_tuple__75;
+static PyObject *__pyx_tuple__77;
+static PyObject *__pyx_tuple__78;
+static PyObject *__pyx_tuple__80;
+static PyObject *__pyx_tuple__81;
+static PyObject *__pyx_codeobj__65;
+static PyObject *__pyx_codeobj__67;
+static PyObject *__pyx_codeobj__69;
+static PyObject *__pyx_codeobj__71;
+static PyObject *__pyx_codeobj__73;
+static PyObject *__pyx_codeobj__76;
+static PyObject *__pyx_codeobj__79;
+static PyObject *__pyx_codeobj__82;
+static PyObject *__pyx_codeobj__83;
+
+/* "pywrapfst.pyx":159
+ *
+ *
+ * cdef string tostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<<
+ * """Converts strings to bytestrings.
+ *
+ */
+
+static std::string __pyx_f_9pywrapfst_tostring(PyObject *__pyx_v_data, struct __pyx_opt_args_9pywrapfst_tostring *__pyx_optional_args) {
+ PyObject *__pyx_v_encoding = ((PyObject *)__pyx_n_s_utf8);
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ std::string __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ __Pyx_RefNannySetupContext("tostring", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_encoding = __pyx_optional_args->encoding;
+ }
+ }
+
+ /* "pywrapfst.pyx":180
+ * """
+ * # A Python bytestring can be implicitly cast to a C++ string.
+ * if isinstance(data, bytes): # <<<<<<<<<<<<<<
+ * return data
+ * elif isinstance(data, unicode):
+ */
+ __pyx_t_1 = PyBytes_Check(__pyx_v_data);
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":181
+ * # A Python bytestring can be implicitly cast to a C++ string.
+ * if isinstance(data, bytes):
+ * return data # <<<<<<<<<<<<<<
+ * elif isinstance(data, unicode):
+ * return data.encode(encoding)
+ */
+ __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 181, __pyx_L1_error)
+ __pyx_r = __pyx_t_3;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":180
+ * """
+ * # A Python bytestring can be implicitly cast to a C++ string.
+ * if isinstance(data, bytes): # <<<<<<<<<<<<<<
+ * return data
+ * elif isinstance(data, unicode):
+ */
+ }
+
+ /* "pywrapfst.pyx":182
+ * if isinstance(data, bytes):
+ * return data
+ * elif isinstance(data, unicode): # <<<<<<<<<<<<<<
+ * return data.encode(encoding)
+ * raise FstArgError("Cannot encode as string: {!r}".format(data))
+ */
+ __pyx_t_2 = PyUnicode_Check(__pyx_v_data);
+ __pyx_t_1 = (__pyx_t_2 != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":183
+ * return data
+ * elif isinstance(data, unicode):
+ * return data.encode(encoding) # <<<<<<<<<<<<<<
+ * raise FstArgError("Cannot encode as string: {!r}".format(data))
+ *
+ */
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_INCREF(__pyx_v_encoding);
+ __Pyx_GIVEREF(__pyx_v_encoding);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_encoding);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_r = __pyx_t_3;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":182
+ * if isinstance(data, bytes):
+ * return data
+ * elif isinstance(data, unicode): # <<<<<<<<<<<<<<
+ * return data.encode(encoding)
+ * raise FstArgError("Cannot encode as string: {!r}".format(data))
+ */
+ }
+
+ /* "pywrapfst.pyx":184
+ * elif isinstance(data, unicode):
+ * return data.encode(encoding)
+ * raise FstArgError("Cannot encode as string: {!r}".format(data)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_encode_as_string_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_8 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_8)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_8) {
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_data); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data};
+ __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_7);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data};
+ __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_7);
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+ __Pyx_INCREF(__pyx_v_data);
+ __Pyx_GIVEREF(__pyx_v_data);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_data);
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_7};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_7};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_7);
+ __pyx_t_7 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 184, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":159
+ *
+ *
+ * cdef string tostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<<
+ * """Converts strings to bytestrings.
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_AddTraceback("pywrapfst.tostring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":187
+ *
+ *
+ * cdef string weighttostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<<
+ * """Converts strings or numerics to bytestrings.
+ *
+ */
+
+static std::string __pyx_f_9pywrapfst_weighttostring(PyObject *__pyx_v_data, struct __pyx_opt_args_9pywrapfst_weighttostring *__pyx_optional_args) {
+ PyObject *__pyx_v_encoding = ((PyObject *)__pyx_n_s_utf8);
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ std::string __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ __Pyx_RefNannySetupContext("weighttostring", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_encoding = __pyx_optional_args->encoding;
+ }
+ }
+
+ /* "pywrapfst.pyx":211
+ * """
+ * # A Python bytestring can be implicitly cast to a C++ string.
+ * if isinstance(data, bytes): # <<<<<<<<<<<<<<
+ * return data
+ * elif isinstance(data, unicode):
+ */
+ __pyx_t_1 = PyBytes_Check(__pyx_v_data);
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":212
+ * # A Python bytestring can be implicitly cast to a C++ string.
+ * if isinstance(data, bytes):
+ * return data # <<<<<<<<<<<<<<
+ * elif isinstance(data, unicode):
+ * return data.encode(encoding)
+ */
+ __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_v_data); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 212, __pyx_L1_error)
+ __pyx_r = __pyx_t_3;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":211
+ * """
+ * # A Python bytestring can be implicitly cast to a C++ string.
+ * if isinstance(data, bytes): # <<<<<<<<<<<<<<
+ * return data
+ * elif isinstance(data, unicode):
+ */
+ }
+
+ /* "pywrapfst.pyx":213
+ * if isinstance(data, bytes):
+ * return data
+ * elif isinstance(data, unicode): # <<<<<<<<<<<<<<
+ * return data.encode(encoding)
+ * elif isinstance(data, numbers.Number):
+ */
+ __pyx_t_2 = PyUnicode_Check(__pyx_v_data);
+ __pyx_t_1 = (__pyx_t_2 != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":214
+ * return data
+ * elif isinstance(data, unicode):
+ * return data.encode(encoding) # <<<<<<<<<<<<<<
+ * elif isinstance(data, numbers.Number):
+ * return str(data).encode(encoding)
+ */
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 214, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_encoding};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 214, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_INCREF(__pyx_v_encoding);
+ __Pyx_GIVEREF(__pyx_v_encoding);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_encoding);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 214, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_4); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 214, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_r = __pyx_t_3;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":213
+ * if isinstance(data, bytes):
+ * return data
+ * elif isinstance(data, unicode): # <<<<<<<<<<<<<<
+ * return data.encode(encoding)
+ * elif isinstance(data, numbers.Number):
+ */
+ }
+
+ /* "pywrapfst.pyx":215
+ * elif isinstance(data, unicode):
+ * return data.encode(encoding)
+ * elif isinstance(data, numbers.Number): # <<<<<<<<<<<<<<
+ * return str(data).encode(encoding)
+ * raise FstArgError("Cannot encode as string: {!r}".format(data))
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 215, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Number); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_1 = PyObject_IsInstance(__pyx_v_data, __pyx_t_5); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 215, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":216
+ * return data.encode(encoding)
+ * elif isinstance(data, numbers.Number):
+ * return str(data).encode(encoding) # <<<<<<<<<<<<<<
+ * raise FstArgError("Cannot encode as string: {!r}".format(data))
+ *
+ */
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(__pyx_v_data);
+ __Pyx_GIVEREF(__pyx_v_data);
+ PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_data);
+ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_encoding};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_encoding};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_encoding);
+ __Pyx_GIVEREF(__pyx_v_encoding);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_encoding);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_3 = __pyx_convert_string_from_py_std__in_string(__pyx_t_5); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_r = __pyx_t_3;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":215
+ * elif isinstance(data, unicode):
+ * return data.encode(encoding)
+ * elif isinstance(data, numbers.Number): # <<<<<<<<<<<<<<
+ * return str(data).encode(encoding)
+ * raise FstArgError("Cannot encode as string: {!r}".format(data))
+ */
+ }
+
+ /* "pywrapfst.pyx":217
+ * elif isinstance(data, numbers.Number):
+ * return str(data).encode(encoding)
+ * raise FstArgError("Cannot encode as string: {!r}".format(data)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_encode_as_string_r, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+ if (likely(__pyx_t_8)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
+ }
+ }
+ if (!__pyx_t_8) {
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data};
+ __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_data};
+ __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+ __Pyx_INCREF(__pyx_v_data);
+ __Pyx_GIVEREF(__pyx_v_data);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_data);
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 217, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __PYX_ERR(0, 217, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":187
+ *
+ *
+ * cdef string weighttostring(data, encoding="utf8") except *: # <<<<<<<<<<<<<<
+ * """Converts strings or numerics to bytestrings.
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_AddTraceback("pywrapfst.weighttostring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":220
+ *
+ *
+ * cdef fst.ComposeFilter _get_compose_filter(const string &cf) except *: # <<<<<<<<<<<<<<
+ * """Matches string with the appropriate ComposeFilter enum value.
+ *
+ */
+
+static enum fst::ComposeFilter __pyx_f_9pywrapfst__get_compose_filter(std::string const &__pyx_v_cf) {
+ 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;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_get_compose_filter", 0);
+
+ /* "pywrapfst.pyx":240
+ * """
+ * cdef fst.ComposeFilter compose_filter
+ * if not fst.GetComposeFilter(cf, addr(compose_filter)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown compose filter type: {!r}".format(cf))
+ * return compose_filter
+ */
+ __pyx_t_1 = ((!(fst::script::GetComposeFilter(__pyx_v_cf, (&__pyx_v_compose_filter)) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":241
+ * cdef fst.ComposeFilter compose_filter
+ * if not fst.GetComposeFilter(cf, addr(compose_filter)):
+ * raise FstArgError("Unknown compose filter type: {!r}".format(cf)) # <<<<<<<<<<<<<<
+ * return compose_filter
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_compose_filter_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_cf); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 241, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":240
+ * """
+ * cdef fst.ComposeFilter compose_filter
+ * if not fst.GetComposeFilter(cf, addr(compose_filter)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown compose filter type: {!r}".format(cf))
+ * return compose_filter
+ */
+ }
+
+ /* "pywrapfst.pyx":242
+ * if not fst.GetComposeFilter(cf, addr(compose_filter)):
+ * raise FstArgError("Unknown compose filter type: {!r}".format(cf))
+ * return compose_filter # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_compose_filter;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":220
+ *
+ *
+ * cdef fst.ComposeFilter _get_compose_filter(const string &cf) except *: # <<<<<<<<<<<<<<
+ * """Matches string with the appropriate ComposeFilter enum value.
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._get_compose_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = (enum fst::ComposeFilter) 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":245
+ *
+ *
+ * cdef fst.DeterminizeType _get_determinize_type(const string &dt) except *: # <<<<<<<<<<<<<<
+ * """Matches string with the appropriate DeterminizeType enum value.
+ *
+ */
+
+static enum fst::DeterminizeType __pyx_f_9pywrapfst__get_determinize_type(std::string const &__pyx_v_dt) {
+ enum fst::DeterminizeType __pyx_v_determinize_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;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_get_determinize_type", 0);
+
+ /* "pywrapfst.pyx":261
+ * """
+ * cdef fst.DeterminizeType determinize_type
+ * if not fst.GetDeterminizeType(dt, addr(determinize_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ * return determinize_type
+ */
+ __pyx_t_1 = ((!(fst::script::GetDeterminizeType(__pyx_v_dt, (&__pyx_v_determinize_type)) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":262
+ * cdef fst.DeterminizeType determinize_type
+ * if not fst.GetDeterminizeType(dt, addr(determinize_type)):
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt)) # <<<<<<<<<<<<<<
+ * return determinize_type
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_determinization_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_dt); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 262, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 262, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":261
+ * """
+ * cdef fst.DeterminizeType determinize_type
+ * if not fst.GetDeterminizeType(dt, addr(determinize_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ * return determinize_type
+ */
+ }
+
+ /* "pywrapfst.pyx":263
+ * if not fst.GetDeterminizeType(dt, addr(determinize_type)):
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ * return determinize_type # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_determinize_type;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":245
+ *
+ *
+ * cdef fst.DeterminizeType _get_determinize_type(const string &dt) except *: # <<<<<<<<<<<<<<
+ * """Matches string with the appropriate DeterminizeType enum value.
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._get_determinize_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = (enum fst::DeterminizeType) 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":266
+ *
+ *
+ * cdef fst.QueueType _get_queue_type(const string &qt) except *: # <<<<<<<<<<<<<<
+ * """Matches string with the appropriate QueueType enum value.
+ *
+ */
+
+static enum fst::QueueType __pyx_f_9pywrapfst__get_queue_type(std::string const &__pyx_v_qt) {
+ 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;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_get_queue_type", 0);
+
+ /* "pywrapfst.pyx":285
+ * """
+ * cdef fst.QueueType queue_type
+ * if not fst.GetQueueType(qt, addr(queue_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown queue type: {!r}".format(qt))
+ * return queue_type
+ */
+ __pyx_t_1 = ((!(fst::script::GetQueueType(__pyx_v_qt, (&__pyx_v_queue_type)) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":286
+ * cdef fst.QueueType queue_type
+ * if not fst.GetQueueType(qt, addr(queue_type)):
+ * raise FstArgError("Unknown queue type: {!r}".format(qt)) # <<<<<<<<<<<<<<
+ * return queue_type
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_queue_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_qt); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 286, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 286, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":285
+ * """
+ * cdef fst.QueueType queue_type
+ * if not fst.GetQueueType(qt, addr(queue_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown queue type: {!r}".format(qt))
+ * return queue_type
+ */
+ }
+
+ /* "pywrapfst.pyx":287
+ * if not fst.GetQueueType(qt, addr(queue_type)):
+ * raise FstArgError("Unknown queue type: {!r}".format(qt))
+ * return queue_type # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_queue_type;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":266
+ *
+ *
+ * cdef fst.QueueType _get_queue_type(const string &qt) except *: # <<<<<<<<<<<<<<
+ * """Matches string with the appropriate QueueType enum value.
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._get_queue_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = (enum fst::QueueType) 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":290
+ *
+ *
+ * cdef fst.RandArcSelection _get_rand_arc_selection(const string &ras) 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_ras) {
+ enum fst::script::RandArcSelection __pyx_v_rand_arc_selection;
+ enum fst::script::RandArcSelection __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_get_rand_arc_selection", 0);
+
+ /* "pywrapfst.pyx":309
+ * """
+ * cdef fst.RandArcSelection rand_arc_selection
+ * if not fst.GetRandArcSelection(ras, addr(rand_arc_selection)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown random arc selection type: {!r}".format(ras))
+ * return rand_arc_selection
+ */
+ __pyx_t_1 = ((!(fst::script::GetRandArcSelection(__pyx_v_ras, (&__pyx_v_rand_arc_selection)) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":310
+ * cdef fst.RandArcSelection rand_arc_selection
+ * if not fst.GetRandArcSelection(ras, addr(rand_arc_selection)):
+ * raise FstArgError("Unknown random arc selection type: {!r}".format(ras)) # <<<<<<<<<<<<<<
+ * return rand_arc_selection
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_random_arc_selection_typ, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_ras); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 310, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":309
+ * """
+ * cdef fst.RandArcSelection rand_arc_selection
+ * if not fst.GetRandArcSelection(ras, addr(rand_arc_selection)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown random arc selection type: {!r}".format(ras))
+ * return rand_arc_selection
+ */
+ }
+
+ /* "pywrapfst.pyx":311
+ * if not fst.GetRandArcSelection(ras, addr(rand_arc_selection)):
+ * raise FstArgError("Unknown random arc selection type: {!r}".format(ras))
+ * return rand_arc_selection # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_rand_arc_selection;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":290
+ *
+ *
+ * cdef fst.RandArcSelection _get_rand_arc_selection(const string &ras) except *: # <<<<<<<<<<<<<<
+ * """Matches string with the appropriate RandArcSelection enum value.
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._get_rand_arc_selection", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = (enum fst::script::RandArcSelection) 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":314
+ *
+ *
+ * cdef fst.ReplaceLabelType _get_replace_label_type(const string &rlt, # <<<<<<<<<<<<<<
+ * 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_rlt, 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;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_get_replace_label_type", 0);
+
+ /* "pywrapfst.pyx":335
+ * """
+ * cdef fst.ReplaceLabelType replace_label_type
+ * if not fst.GetReplaceLabelType(rlt, epsilon_on_replace, # <<<<<<<<<<<<<<
+ * addr(replace_label_type)):
+ * raise FstArgError("Unknown replace label type: {!r}".format(rlt))
+ */
+ __pyx_t_1 = ((!(fst::script::GetReplaceLabelType(__pyx_v_rlt, __pyx_v_epsilon_on_replace, (&__pyx_v_replace_label_type)) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":337
+ * if not fst.GetReplaceLabelType(rlt, epsilon_on_replace,
+ * addr(replace_label_type)):
+ * raise FstArgError("Unknown replace label type: {!r}".format(rlt)) # <<<<<<<<<<<<<<
+ * return replace_label_type
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_replace_label_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_rlt); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 337, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 337, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":335
+ * """
+ * cdef fst.ReplaceLabelType replace_label_type
+ * if not fst.GetReplaceLabelType(rlt, epsilon_on_replace, # <<<<<<<<<<<<<<
+ * addr(replace_label_type)):
+ * raise FstArgError("Unknown replace label type: {!r}".format(rlt))
+ */
+ }
+
+ /* "pywrapfst.pyx":338
+ * addr(replace_label_type)):
+ * raise FstArgError("Unknown replace label type: {!r}".format(rlt))
+ * return replace_label_type # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_replace_label_type;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":314
+ *
+ *
+ * cdef fst.ReplaceLabelType _get_replace_label_type(const string &rlt, # <<<<<<<<<<<<<<
+ * bool epsilon_on_replace) except *:
+ * """Matches string with the appropriate ReplaceLabelType enum value.
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._get_replace_label_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = (enum fst::ReplaceLabelType) 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":364
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(),
+ * id(self))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_6Weight_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight___repr__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight___repr__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":365
+ *
+ * def __repr__(self):
+ * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(), # <<<<<<<<<<<<<<
+ * id(self))
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Weight_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 365, __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 '%s'", "type");
+ __PYX_ERR(0, 365, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 365, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "to_string");
+ __PYX_ERR(0, 365, __pyx_L1_error)
+ }
+ __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 365, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+
+ /* "pywrapfst.pyx":366
+ * def __repr__(self):
+ * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(),
+ * id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __str__(self):
+ */
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 366, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 366, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ __pyx_t_7 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_7 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_4, __pyx_t_6};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_t_3, __pyx_t_4, __pyx_t_6};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 365, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ if (__pyx_t_5) {
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_6);
+ __pyx_t_3 = 0;
+ __pyx_t_4 = 0;
+ __pyx_t_6 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 365, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":364
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(),
+ * id(self))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst.Weight.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":368
+ * id(self))
+ *
+ * def __str__(self): # <<<<<<<<<<<<<<
+ * return self.to_string()
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_3__str__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_6Weight_3__str__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_2__str__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_2__str__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__str__", 0);
+
+ /* "pywrapfst.pyx":369
+ *
+ * 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 '%s'", "to_string");
+ __PYX_ERR(0, 369, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 369, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":368
+ * id(self))
+ *
+ * def __str__(self): # <<<<<<<<<<<<<<
+ * return self.to_string()
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.Weight.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":374
+ * # ValueError when that is not appropriate.
+ *
+ * def __float__(self): # <<<<<<<<<<<<<<
+ * return float(self.to_string())
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_5__float__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_6Weight_5__float__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__float__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_4__float__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_4__float__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("__float__", 0);
+
+ /* "pywrapfst.pyx":375
+ *
+ * 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 '%s'", "to_string");
+ __PYX_ERR(0, 375, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 375, __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, 375, __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":374
+ * # 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":377
+ * return float(self.to_string())
+ *
+ * def __init__(self, weight_type, weight): # <<<<<<<<<<<<<<
+ * self._weight.reset(new fst.WeightClass(tostring(weight_type),
+ * weighttostring(weight)))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_6Weight_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_6Weight_7__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_weight_type = 0;
+ PyObject *__pyx_v_weight = 0;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_weight_type,&__pyx_n_s_weight,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight_type)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 377, __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, 377, __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, 377, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Weight.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_6__init__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self), __pyx_v_weight_type, __pyx_v_weight);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_6Weight_6__init__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, PyObject *__pyx_v_weight_type, PyObject *__pyx_v_weight) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ std::string __pyx_t_2;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":378
+ *
+ * def __init__(self, weight_type, weight):
+ * self._weight.reset(new fst.WeightClass(tostring(weight_type), # <<<<<<<<<<<<<<
+ * weighttostring(weight)))
+ * self._check_weight()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 378, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 378, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":379
+ * def __init__(self, weight_type, weight):
+ * self._weight.reset(new fst.WeightClass(tostring(weight_type),
+ * weighttostring(weight))) # <<<<<<<<<<<<<<
+ * self._check_weight()
+ *
+ */
+ __pyx_t_2 = __pyx_f_9pywrapfst_weighttostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 379, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":378
+ *
+ * def __init__(self, weight_type, weight):
+ * self._weight.reset(new fst.WeightClass(tostring(weight_type), # <<<<<<<<<<<<<<
+ * weighttostring(weight)))
+ * self._check_weight()
+ */
+ __pyx_v_self->_weight.reset(new fst::script::WeightClass(__pyx_t_1, __pyx_t_2));
+
+ /* "pywrapfst.pyx":380
+ * self._weight.reset(new fst.WeightClass(tostring(weight_type),
+ * weighttostring(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 '%s'", "_check_weight");
+ __PYX_ERR(0, 380, __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, 380, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":377
+ * return float(self.to_string())
+ *
+ * def __init__(self, weight_type, weight): # <<<<<<<<<<<<<<
+ * self._weight.reset(new fst.WeightClass(tostring(weight_type),
+ * weighttostring(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":382
+ * self._check_weight()
+ *
+ * cdef void _check_weight(self) except *: # <<<<<<<<<<<<<<
+ * if self.type() == b"none":
+ * raise FstUnknownWeightTypeError(self.type())
+ */
+
+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;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("_check_weight", 0);
+
+ /* "pywrapfst.pyx":383
+ *
+ * cdef void _check_weight(self) except *:
+ * if self.type() == b"none": # <<<<<<<<<<<<<<
+ * raise FstUnknownWeightTypeError(self.type())
+ * if self.to_string() == b"BadNumber":
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "type");
+ __PYX_ERR(0, 383, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->type(__pyx_v_self, 0) == ((char *)"none")) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":384
+ * cdef void _check_weight(self) except *:
+ * if self.type() == b"none":
+ * raise FstUnknownWeightTypeError(self.type()) # <<<<<<<<<<<<<<
+ * if self.to_string() == b"BadNumber":
+ * raise FstBadWeightError(self.to_string())
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstUnknownWeightTypeError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 384, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "type");
+ __PYX_ERR(0, 384, __pyx_L1_error)
+ }
+ __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 384, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __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_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 384, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":383
+ *
+ * cdef void _check_weight(self) except *:
+ * if self.type() == b"none": # <<<<<<<<<<<<<<
+ * raise FstUnknownWeightTypeError(self.type())
+ * if self.to_string() == b"BadNumber":
+ */
+ }
+
+ /* "pywrapfst.pyx":385
+ * if self.type() == b"none":
+ * raise FstUnknownWeightTypeError(self.type())
+ * if self.to_string() == b"BadNumber": # <<<<<<<<<<<<<<
+ * raise FstBadWeightError(self.to_string())
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "to_string");
+ __PYX_ERR(0, 385, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0) == ((char *)"BadNumber")) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":386
+ * raise FstUnknownWeightTypeError(self.type())
+ * if self.to_string() == b"BadNumber":
+ * raise FstBadWeightError(self.to_string()) # <<<<<<<<<<<<<<
+ *
+ * cpdef Weight copy(self):
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "to_string");
+ __PYX_ERR(0, 386, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_self->__pyx_vtab)->to_string(__pyx_v_self, 0)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 386, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":385
+ * if self.type() == b"none":
+ * raise FstUnknownWeightTypeError(self.type())
+ * if self.to_string() == b"BadNumber": # <<<<<<<<<<<<<<
+ * raise FstBadWeightError(self.to_string())
+ *
+ */
+ }
+
+ /* "pywrapfst.pyx":382
+ * self._check_weight()
+ *
+ * cdef void _check_weight(self) except *: # <<<<<<<<<<<<<<
+ * if self.type() == b"none":
+ * raise FstUnknownWeightTypeError(self.type())
+ */
+
+ /* 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_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst.Weight._check_weight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":388
+ * raise FstBadWeightError(self.to_string())
+ *
+ * cpdef Weight copy(self): # <<<<<<<<<<<<<<
+ * """
+ * copy(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_6Weight_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_6Weight_copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_6Weight_9copy)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 388, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 388, __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, 388, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":394
+ * Returns a copy of the Weight.
+ * """
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new
+ * fst.WeightClass(<fst.WeightClass> deref(self._weight)))
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 394, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 394, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":395
+ * """
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new # <<<<<<<<<<<<<<
+ * fst.WeightClass(<fst.WeightClass> deref(self._weight)))
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 395, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":396
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new
+ * fst.WeightClass(<fst.WeightClass> deref(self._weight))) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 396, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":395
+ * """
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new # <<<<<<<<<<<<<<
+ * fst.WeightClass(<fst.WeightClass> deref(self._weight)))
+ * return result
+ */
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(((fst::script::WeightClass)(*__pyx_v_self->_weight))));
+
+ /* "pywrapfst.pyx":397
+ * result._weight.reset(new
+ * fst.WeightClass(<fst.WeightClass> deref(self._weight)))
+ * return result # <<<<<<<<<<<<<<
+ *
+ * # To get around the inability to declare cdef class methods, we define
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":388
+ * raise FstBadWeightError(self.to_string())
+ *
+ * cpdef Weight copy(self): # <<<<<<<<<<<<<<
+ * """
+ * copy(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst.Weight.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_6Weight_8copy[] = "\n copy(self)\n\n Returns a copy of the Weight.\n ";
+static PyObject *__pyx_pw_9pywrapfst_6Weight_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("copy (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_8copy(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_8copy(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_6Weight_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 388, __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":403
+ *
+ * @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 ";
+static PyObject *__pyx_pw_9pywrapfst_6Weight_11Zero(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("Zero (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_10Zero(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_weight_type));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_10Zero(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("Zero", 0);
+
+ /* "pywrapfst.pyx":407
+ * Weight.Zero(weight_type)
+ * """
+ * return _Weight_Zero(weight_type) # <<<<<<<<<<<<<<
+ *
+ * @classmethod
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__Weight_Zero(__pyx_v_weight_type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 407, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":403
+ *
+ * @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":410
+ *
+ * @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 ";
+static PyObject *__pyx_pw_9pywrapfst_6Weight_13One(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("One (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_12One(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_weight_type));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_12One(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("One", 0);
+
+ /* "pywrapfst.pyx":414
+ * Weight.One(weight_type)
+ * """
+ * return _Weight_One(weight_type) # <<<<<<<<<<<<<<
+ *
+ * @classmethod
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__Weight_One(__pyx_v_weight_type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 414, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":410
+ *
+ * @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":417
+ *
+ * @classmethod
+ * def NoWeight(cls, weight_type): # <<<<<<<<<<<<<<
+ * """
+ * Weight.NoWeight(weight_type)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_15NoWeight(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type); /*proto*/
+static char __pyx_doc_9pywrapfst_6Weight_14NoWeight[] = "\n Weight.NoWeight(weight_type)\n ";
+static PyObject *__pyx_pw_9pywrapfst_6Weight_15NoWeight(PyObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("NoWeight (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_14NoWeight(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_weight_type));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_14NoWeight(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_weight_type) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("NoWeight", 0);
+
+ /* "pywrapfst.pyx":421
+ * Weight.NoWeight(weight_type)
+ * """
+ * return _Weight_NoWeight(weight_type) # <<<<<<<<<<<<<<
+ *
+ * def __richcmp__(Weight x, Weight y, int op):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__Weight_NoWeight(__pyx_v_weight_type)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 421, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":417
+ *
+ * @classmethod
+ * def NoWeight(cls, weight_type): # <<<<<<<<<<<<<<
+ * """
+ * Weight.NoWeight(weight_type)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.Weight.NoWeight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":423
+ * return _Weight_NoWeight(weight_type)
+ *
+ * def __richcmp__(Weight x, Weight y, int op): # <<<<<<<<<<<<<<
+ * # This is useful for unit tests.
+ * if op == 2: # `==`
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_17__richcmp__(PyObject *__pyx_v_x, PyObject *__pyx_v_y, int __pyx_v_op); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_6Weight_17__richcmp__(PyObject *__pyx_v_x, PyObject *__pyx_v_y, int __pyx_v_op) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__richcmp__ (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_x), __pyx_ptype_9pywrapfst_Weight, 1, "x", 0))) __PYX_ERR(0, 423, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_9pywrapfst_Weight, 1, "y", 0))) __PYX_ERR(0, 423, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_6Weight_16__richcmp__(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_x), ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_y), ((int)__pyx_v_op));
+
+ /* 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__richcmp__(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_x, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_y, int __pyx_v_op) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("__richcmp__", 0);
+
+ /* "pywrapfst.pyx":425
+ * def __richcmp__(Weight x, Weight y, int op):
+ * # This is useful for unit tests.
+ * if op == 2: # `==` # <<<<<<<<<<<<<<
+ * return (x.type() == y.type() and x.to_string() == y.to_string())
+ * elif op == 3: # `!=`
+ */
+ switch (__pyx_v_op) {
+ case 2:
+
+ /* "pywrapfst.pyx":426
+ * # This is useful for unit tests.
+ * if op == 2: # `==`
+ * return (x.type() == y.type() and x.to_string() == y.to_string()) # <<<<<<<<<<<<<<
+ * elif op == 3: # `!=`
+ * return not (x == y)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ if (unlikely(((PyObject *)__pyx_v_x) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "type");
+ __PYX_ERR(0, 426, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_y) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "type");
+ __PYX_ERR(0, 426, __pyx_L1_error)
+ }
+ __pyx_t_2 = (((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_x->__pyx_vtab)->type(__pyx_v_x, 0) == ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_y->__pyx_vtab)->type(__pyx_v_y, 0));
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_1 = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L3_bool_binop_done;
+ }
+ if (unlikely(((PyObject *)__pyx_v_x) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "to_string");
+ __PYX_ERR(0, 426, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_y) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "to_string");
+ __PYX_ERR(0, 426, __pyx_L1_error)
+ }
+ __pyx_t_2 = (((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_x->__pyx_vtab)->to_string(__pyx_v_x, 0) == ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_y->__pyx_vtab)->to_string(__pyx_v_y, 0));
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_1 = __pyx_t_3;
+ __pyx_t_3 = 0;
+ __pyx_L3_bool_binop_done:;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":425
+ * def __richcmp__(Weight x, Weight y, int op):
+ * # This is useful for unit tests.
+ * if op == 2: # `==` # <<<<<<<<<<<<<<
+ * return (x.type() == y.type() and x.to_string() == y.to_string())
+ * elif op == 3: # `!=`
+ */
+ break;
+
+ /* "pywrapfst.pyx":427
+ * if op == 2: # `==`
+ * return (x.type() == y.type() and x.to_string() == y.to_string())
+ * elif op == 3: # `!=` # <<<<<<<<<<<<<<
+ * return not (x == y)
+ * else:
+ */
+ case 3:
+
+ /* "pywrapfst.pyx":428
+ * return (x.type() == y.type() and x.to_string() == y.to_string())
+ * elif op == 3: # `!=`
+ * return not (x == y) # <<<<<<<<<<<<<<
+ * else:
+ * raise NotImplementedError("Invalid operator {!r}".format(op))
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyObject_RichCompare(((PyObject *)__pyx_v_x), ((PyObject *)__pyx_v_y), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 428, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 428, __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, 428, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":427
+ * if op == 2: # `==`
+ * return (x.type() == y.type() and x.to_string() == y.to_string())
+ * elif op == 3: # `!=` # <<<<<<<<<<<<<<
+ * return not (x == y)
+ * else:
+ */
+ break;
+ default:
+
+ /* "pywrapfst.pyx":430
+ * return not (x == y)
+ * else:
+ * raise NotImplementedError("Invalid operator {!r}".format(op)) # <<<<<<<<<<<<<<
+ *
+ * cpdef string to_string(self):
+ */
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Invalid_operator_r, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_op); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+ __pyx_t_1 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 430, __pyx_L1_error)
+ break;
+ }
+
+ /* "pywrapfst.pyx":423
+ * return _Weight_NoWeight(weight_type)
+ *
+ * def __richcmp__(Weight x, Weight y, int op): # <<<<<<<<<<<<<<
+ * # This is useful for unit tests.
+ * if op == 2: # `==`
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst.Weight.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":432
+ * raise NotImplementedError("Invalid operator {!r}".format(op))
+ *
+ * cpdef string to_string(self): # <<<<<<<<<<<<<<
+ * return self._weight.get().ToString()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_6Weight_19to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_6Weight_to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("to_string", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 432, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_6Weight_19to_string)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 432, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 432, __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, 432, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":433
+ *
+ * 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 '%s'", "_weight");
+ __PYX_ERR(0, 433, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_weight.get()->ToString();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":432
+ * raise NotImplementedError("Invalid operator {!r}".format(op))
+ *
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_19to_string(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_6Weight_19to_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_18to_string(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_18to_string(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("to_string", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_6Weight_to_string(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 432, __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":435
+ * return self._weight.get().ToString()
+ *
+ * cpdef string type(self): # <<<<<<<<<<<<<<
+ * return self._weight.get().Type()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_6Weight_21type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_6Weight_type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 435, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_6Weight_21type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 435, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 435, __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, 435, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":436
+ *
+ * cpdef string type(self):
+ * return self._weight.get().Type() # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 436, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_weight.get()->Type();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":435
+ * return self._weight.get().ToString()
+ *
+ * cpdef string type(self): # <<<<<<<<<<<<<<
+ * return self._weight.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.Weight.type", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_6Weight_21type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_6Weight_21type(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_20type(((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6Weight_20type(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_6Weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 435, __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":439
+ *
+ *
+ * cdef Weight _plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight),
+ */
+
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__plus(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_plus", 0);
+
+ /* "pywrapfst.pyx":440
+ *
+ * cdef Weight _plus(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight),
+ * deref(rhs._weight))))
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 440, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 440, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":441
+ * cdef Weight _plus(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), # <<<<<<<<<<<<<<
+ * deref(rhs._weight))))
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 441, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 441, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":442
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight),
+ * deref(rhs._weight)))) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 442, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":441
+ * cdef Weight _plus(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight), # <<<<<<<<<<<<<<
+ * deref(rhs._weight))))
+ * return result
+ */
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Plus((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight))));
+
+ /* "pywrapfst.pyx":443
+ * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight),
+ * deref(rhs._weight))))
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":439
+ *
+ *
+ * cdef Weight _plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight),
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._plus", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":446
+ *
+ *
+ * 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 FstBadWeightError: invalid weight.\n FstUnknownWeightTypeError: weights are null or not in the same semiring.\n ";
+static PyMethodDef __pyx_mdef_9pywrapfst_1plus = {"plus", (PyCFunction)__pyx_pw_9pywrapfst_1plus, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_plus};
+static PyObject *__pyx_pw_9pywrapfst_1plus(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("plus (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("plus", 1, 2, 2, 1); __PYX_ERR(0, 446, __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, 446, __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, 446, __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, 446, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 446, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_plus(__pyx_self, __pyx_v_lhs, __pyx_v_rhs);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_plus(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("plus", 0);
+
+ /* "pywrapfst.pyx":466
+ * FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ * """
+ * cdef Weight result = _plus(lhs, rhs) # <<<<<<<<<<<<<<
+ * result._check_weight()
+ * return result
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__plus(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 466, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":467
+ * """
+ * cdef Weight result = _plus(lhs, rhs)
+ * result._check_weight() # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_weight");
+ __PYX_ERR(0, 467, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 467, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":468
+ * cdef Weight result = _plus(lhs, rhs)
+ * result._check_weight()
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":446
+ *
+ *
+ * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * """
+ * plus(lhs, rhs)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.plus", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":471
+ *
+ *
+ * cdef Weight _times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight),
+ */
+
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__times(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_times", 0);
+
+ /* "pywrapfst.pyx":472
+ *
+ * cdef Weight _times(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight),
+ * deref(rhs._weight))))
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 472, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 472, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":473
+ * cdef Weight _times(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), # <<<<<<<<<<<<<<
+ * deref(rhs._weight))))
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 473, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 473, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":474
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight),
+ * deref(rhs._weight)))) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 474, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":473
+ * cdef Weight _times(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight), # <<<<<<<<<<<<<<
+ * deref(rhs._weight))))
+ * return result
+ */
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Times((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight))));
+
+ /* "pywrapfst.pyx":475
+ * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight),
+ * deref(rhs._weight))))
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":471
+ *
+ *
+ * cdef Weight _times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight),
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._times", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":478
+ *
+ *
+ * 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 FstBadWeightError: invalid weight.\n FstUnknownWeightTypeError: weights are null or not in the same semiring.\n ";
+static PyMethodDef __pyx_mdef_9pywrapfst_3times = {"times", (PyCFunction)__pyx_pw_9pywrapfst_3times, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_2times};
+static PyObject *__pyx_pw_9pywrapfst_3times(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("times (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("times", 1, 2, 2, 1); __PYX_ERR(0, 478, __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, 478, __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, 478, __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, 478, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 478, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_2times(__pyx_self, __pyx_v_lhs, __pyx_v_rhs);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_2times(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("times", 0);
+
+ /* "pywrapfst.pyx":498
+ * FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ * """
+ * cdef Weight result = _times(lhs, rhs) # <<<<<<<<<<<<<<
+ * result._check_weight()
+ * return result
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__times(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 498, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":499
+ * """
+ * cdef Weight result = _times(lhs, rhs)
+ * result._check_weight() # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_weight");
+ __PYX_ERR(0, 499, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":500
+ * cdef Weight result = _times(lhs, rhs)
+ * result._check_weight()
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":478
+ *
+ *
+ * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * """
+ * times(lhs, rhs)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.times", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":503
+ *
+ *
+ * cdef Weight _divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight),
+ */
+
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__divide(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_divide", 0);
+
+ /* "pywrapfst.pyx":504
+ *
+ * cdef Weight _divide(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight),
+ * deref(rhs._weight))))
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 504, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 504, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":505
+ * cdef Weight _divide(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), # <<<<<<<<<<<<<<
+ * deref(rhs._weight))))
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 505, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 505, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":506
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight),
+ * deref(rhs._weight)))) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 506, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":505
+ * cdef Weight _divide(Weight lhs, Weight rhs):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight), # <<<<<<<<<<<<<<
+ * deref(rhs._weight))))
+ * return result
+ */
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Divide((*__pyx_v_lhs->_weight), (*__pyx_v_rhs->_weight))));
+
+ /* "pywrapfst.pyx":507
+ * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight),
+ * deref(rhs._weight))))
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":503
+ *
+ *
+ * cdef Weight _divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight),
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._divide", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":510
+ *
+ *
+ * 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 FstBadWeightError: invalid weight.\n FstUnknownWeightTypeError: weights are null or not in the same semiring.\n ";
+static PyMethodDef __pyx_mdef_9pywrapfst_5divide = {"divide", (PyCFunction)__pyx_pw_9pywrapfst_5divide, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4divide};
+static PyObject *__pyx_pw_9pywrapfst_5divide(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("divide (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("divide", 1, 2, 2, 1); __PYX_ERR(0, 510, __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, 510, __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, 510, __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, 510, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst_Weight, 1, "rhs", 0))) __PYX_ERR(0, 510, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_4divide(__pyx_self, __pyx_v_lhs, __pyx_v_rhs);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4divide(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_lhs, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_rhs) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("divide", 0);
+
+ /* "pywrapfst.pyx":532
+ * FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ * """
+ * cdef Weight result = _divide(lhs, rhs) # <<<<<<<<<<<<<<
+ * result._check_weight()
+ * return result
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__divide(__pyx_v_lhs, __pyx_v_rhs)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 532, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":533
+ * """
+ * cdef Weight result = _divide(lhs, rhs)
+ * result._check_weight() # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_weight");
+ __PYX_ERR(0, 533, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 533, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":534
+ * cdef Weight result = _divide(lhs, rhs)
+ * result._check_weight()
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":510
+ *
+ *
+ * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * """
+ * divide(lhs, rhs)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.divide", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":537
+ *
+ *
+ * cdef Weight _power(Weight w, size_t n): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n)))
+ */
+
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__power(struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w, size_t __pyx_v_n) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_power", 0);
+
+ /* "pywrapfst.pyx":538
+ *
+ * cdef Weight _power(Weight w, size_t n):
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n)))
+ * return result
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 538, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 538, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":539
+ * cdef Weight _power(Weight w, size_t n):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n))) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 539, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_w) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 539, __pyx_L1_error)
+ }
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::Power((*__pyx_v_w->_weight), __pyx_v_n)));
+
+ /* "pywrapfst.pyx":540
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n)))
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":537
+ *
+ *
+ * cdef Weight _power(Weight w, size_t n): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n)))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._power", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":543
+ *
+ *
+ * def power(Weight w, size_t n): # <<<<<<<<<<<<<<
+ * """
+ * times(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 times(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 FstBadWeightError: invalid weight.\n FstUnknownWeightTypeError: weights are null or not in the same semiring.\n ";
+static PyMethodDef __pyx_mdef_9pywrapfst_7power = {"power", (PyCFunction)__pyx_pw_9pywrapfst_7power, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_6power};
+static PyObject *__pyx_pw_9pywrapfst_7power(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w = 0;
+ size_t __pyx_v_n;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("power (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_w,&__pyx_n_s_n,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_w)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("power", 1, 2, 2, 1); __PYX_ERR(0, 543, __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, 543, __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, 543, __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, 543, __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, 543, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_6power(__pyx_self, __pyx_v_w, __pyx_v_n);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_6power(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst_Weight *__pyx_v_w, size_t __pyx_v_n) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("power", 0);
+
+ /* "pywrapfst.pyx":560
+ * FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ * """
+ * cdef Weight result = _power(w, n) # <<<<<<<<<<<<<<
+ * result._check_weight()
+ * return result
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__power(__pyx_v_w, __pyx_v_n)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 560, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":561
+ * """
+ * cdef Weight result = _power(w, n)
+ * result._check_weight() # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_weight");
+ __PYX_ERR(0, 561, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_Weight *)__pyx_v_result->__pyx_vtab)->_check_weight(__pyx_v_result); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 561, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":562
+ * cdef Weight result = _power(w, n)
+ * result._check_weight()
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":543
+ *
+ *
+ * def power(Weight w, size_t n): # <<<<<<<<<<<<<<
+ * """
+ * times(lhs, rhs)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.power", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":565
+ *
+ *
+ * cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type, # <<<<<<<<<<<<<<
+ * weight) except *:
+ * """Converts weight string to a WeightClass.
+ */
+
+static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_Zero(std::string const &__pyx_v_weight_type, PyObject *__pyx_v_weight) {
+ fst::script::WeightClass __pyx_v_result;
+ fst::script::WeightClass __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ std::string __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_get_WeightClass_or_Zero", 0);
+
+ /* "pywrapfst.pyx":583
+ * """
+ * cdef fst.WeightClass result
+ * if weight is None: # <<<<<<<<<<<<<<
+ * result = fst.WeightClass.Zero(weight_type)
+ * elif isinstance(weight, Weight):
+ */
+ __pyx_t_1 = (__pyx_v_weight == Py_None);
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":584
+ * cdef fst.WeightClass result
+ * if weight is None:
+ * result = fst.WeightClass.Zero(weight_type) # <<<<<<<<<<<<<<
+ * elif isinstance(weight, Weight):
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ */
+ __pyx_v_result = fst::script::WeightClass::Zero(__pyx_v_weight_type);
+
+ /* "pywrapfst.pyx":583
+ * """
+ * cdef fst.WeightClass result
+ * if weight is None: # <<<<<<<<<<<<<<
+ * result = fst.WeightClass.Zero(weight_type)
+ * elif isinstance(weight, Weight):
+ */
+ goto __pyx_L3;
+ }
+
+ /* "pywrapfst.pyx":585
+ * if weight is None:
+ * result = fst.WeightClass.Zero(weight_type)
+ * elif isinstance(weight, Weight): # <<<<<<<<<<<<<<
+ * result = deref(<fst.WeightClass *> (<Weight> 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":586
+ * result = fst.WeightClass.Zero(weight_type)
+ * elif isinstance(weight, Weight):
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get()) # <<<<<<<<<<<<<<
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ */
+ if (unlikely(__pyx_v_weight == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 586, __pyx_L1_error)
+ }
+ __pyx_v_result = (*((fst::script::WeightClass *)((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_weight)->_weight.get()));
+
+ /* "pywrapfst.pyx":585
+ * if weight is None:
+ * result = fst.WeightClass.Zero(weight_type)
+ * elif isinstance(weight, Weight): # <<<<<<<<<<<<<<
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ * else:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "pywrapfst.pyx":588
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight)) # <<<<<<<<<<<<<<
+ * if result.ToString() == b"BadNumber":
+ * raise FstBadWeightError(weighttostring(weight))
+ */
+ /*else*/ {
+ __pyx_t_3 = __pyx_f_9pywrapfst_weighttostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 588, __pyx_L1_error)
+ __pyx_v_result = fst::script::WeightClass(__pyx_v_weight_type, __pyx_t_3);
+
+ /* "pywrapfst.pyx":589
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<<
+ * raise FstBadWeightError(weighttostring(weight))
+ * return result
+ */
+ __pyx_t_1 = ((__pyx_v_result.ToString() == ((char *)"BadNumber")) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":590
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ * if result.ToString() == b"BadNumber":
+ * raise FstBadWeightError(weighttostring(weight)) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 590, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_3 = __pyx_f_9pywrapfst_weighttostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 590, __pyx_L1_error)
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 590, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 590, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 590, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 590, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 590, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 590, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 590, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":589
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<<
+ * raise FstBadWeightError(weighttostring(weight))
+ * return result
+ */
+ }
+ }
+ __pyx_L3:;
+
+ /* "pywrapfst.pyx":591
+ * if result.ToString() == b"BadNumber":
+ * raise FstBadWeightError(weighttostring(weight))
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":565
+ *
+ *
+ * cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type, # <<<<<<<<<<<<<<
+ * weight) except *:
+ * """Converts weight string to a WeightClass.
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._get_WeightClass_or_Zero", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":594
+ *
+ *
+ * cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type, # <<<<<<<<<<<<<<
+ * weight) except *:
+ * """Converts weight string to a WeightClass.
+ */
+
+static fst::script::WeightClass __pyx_f_9pywrapfst__get_WeightClass_or_One(std::string const &__pyx_v_weight_type, PyObject *__pyx_v_weight) {
+ fst::script::WeightClass __pyx_v_result;
+ fst::script::WeightClass __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ std::string __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_get_WeightClass_or_One", 0);
+
+ /* "pywrapfst.pyx":612
+ * """
+ * cdef fst.WeightClass result
+ * if weight is None: # <<<<<<<<<<<<<<
+ * result = fst.WeightClass.One(weight_type)
+ * elif isinstance(weight, Weight):
+ */
+ __pyx_t_1 = (__pyx_v_weight == Py_None);
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":613
+ * cdef fst.WeightClass result
+ * if weight is None:
+ * result = fst.WeightClass.One(weight_type) # <<<<<<<<<<<<<<
+ * elif isinstance(weight, Weight):
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ */
+ __pyx_v_result = fst::script::WeightClass::One(__pyx_v_weight_type);
+
+ /* "pywrapfst.pyx":612
+ * """
+ * cdef fst.WeightClass result
+ * if weight is None: # <<<<<<<<<<<<<<
+ * result = fst.WeightClass.One(weight_type)
+ * elif isinstance(weight, Weight):
+ */
+ goto __pyx_L3;
+ }
+
+ /* "pywrapfst.pyx":614
+ * if weight is None:
+ * result = fst.WeightClass.One(weight_type)
+ * elif isinstance(weight, Weight): # <<<<<<<<<<<<<<
+ * result = deref(<fst.WeightClass *> (<Weight> 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":615
+ * result = fst.WeightClass.One(weight_type)
+ * elif isinstance(weight, Weight):
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get()) # <<<<<<<<<<<<<<
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ */
+ if (unlikely(__pyx_v_weight == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 615, __pyx_L1_error)
+ }
+ __pyx_v_result = (*((fst::script::WeightClass *)((struct __pyx_obj_9pywrapfst_Weight *)__pyx_v_weight)->_weight.get()));
+
+ /* "pywrapfst.pyx":614
+ * if weight is None:
+ * result = fst.WeightClass.One(weight_type)
+ * elif isinstance(weight, Weight): # <<<<<<<<<<<<<<
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ * else:
+ */
+ goto __pyx_L3;
+ }
+
+ /* "pywrapfst.pyx":617
+ * result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight)) # <<<<<<<<<<<<<<
+ * if result.ToString() == b"BadNumber":
+ * raise FstBadWeightError(weighttostring(weight))
+ */
+ /*else*/ {
+ __pyx_t_3 = __pyx_f_9pywrapfst_weighttostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 617, __pyx_L1_error)
+ __pyx_v_result = fst::script::WeightClass(__pyx_v_weight_type, __pyx_t_3);
+
+ /* "pywrapfst.pyx":618
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<<
+ * raise FstBadWeightError(weighttostring(weight))
+ * return result
+ */
+ __pyx_t_1 = ((__pyx_v_result.ToString() == ((char *)"BadNumber")) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":619
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ * if result.ToString() == b"BadNumber":
+ * raise FstBadWeightError(weighttostring(weight)) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstBadWeightError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 619, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_3 = __pyx_f_9pywrapfst_weighttostring(__pyx_v_weight, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 619, __pyx_L1_error)
+ __pyx_t_6 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 619, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 619, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 619, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 619, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 619, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 619, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":618
+ * else:
+ * result = fst.WeightClass(weight_type, weighttostring(weight))
+ * if result.ToString() == b"BadNumber": # <<<<<<<<<<<<<<
+ * raise FstBadWeightError(weighttostring(weight))
+ * return result
+ */
+ }
+ }
+ __pyx_L3:;
+
+ /* "pywrapfst.pyx":620
+ * if result.ToString() == b"BadNumber":
+ * raise FstBadWeightError(weighttostring(weight))
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":594
+ *
+ *
+ * cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type, # <<<<<<<<<<<<<<
+ * weight) except *:
+ * """Converts weight string to a WeightClass.
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._get_WeightClass_or_One", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":623
+ *
+ *
+ * cdef Weight _Weight_Zero(weight_type): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero(
+ */
+
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Weight_Zero(PyObject *__pyx_v_weight_type) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ std::string __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("_Weight_Zero", 0);
+
+ /* "pywrapfst.pyx":624
+ *
+ * cdef Weight _Weight_Zero(weight_type):
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero(
+ * tostring(weight_type))))
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 624, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 624, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":625
+ * cdef Weight _Weight_Zero(weight_type):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( # <<<<<<<<<<<<<<
+ * tostring(weight_type))))
+ * if result._weight.get().Type() == b"none":
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 625, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":626
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero(
+ * tostring(weight_type)))) # <<<<<<<<<<<<<<
+ * if result._weight.get().Type() == b"none":
+ * raise FstUnknownWeightTypeError(weight_type)
+ */
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":625
+ * cdef Weight _Weight_Zero(weight_type):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero( # <<<<<<<<<<<<<<
+ * tostring(weight_type))))
+ * if result._weight.get().Type() == b"none":
+ */
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::Zero(__pyx_t_2)));
+
+ /* "pywrapfst.pyx":627
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero(
+ * tostring(weight_type))))
+ * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<<
+ * raise FstUnknownWeightTypeError(weight_type)
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 627, __pyx_L1_error)
+ }
+ __pyx_t_3 = ((__pyx_v_result->_weight.get()->Type() == ((char *)"none")) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":628
+ * tostring(weight_type))))
+ * if result._weight.get().Type() == b"none":
+ * raise FstUnknownWeightTypeError(weight_type) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstUnknownWeightTypeError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 628, __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);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 628, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_weight_type};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 628, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_weight_type};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 628, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 628, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_INCREF(__pyx_v_weight_type);
+ __Pyx_GIVEREF(__pyx_v_weight_type);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_weight_type);
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 628, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __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, 628, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":627
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero(
+ * tostring(weight_type))))
+ * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<<
+ * raise FstUnknownWeightTypeError(weight_type)
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":629
+ * if result._weight.get().Type() == b"none":
+ * raise FstUnknownWeightTypeError(weight_type)
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":623
+ *
+ *
+ * cdef Weight _Weight_Zero(weight_type): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero(
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._Weight_Zero", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":632
+ *
+ *
+ * cdef Weight _Weight_One(weight_type): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(
+ */
+
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Weight_One(PyObject *__pyx_v_weight_type) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ std::string __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("_Weight_One", 0);
+
+ /* "pywrapfst.pyx":633
+ *
+ * cdef Weight _Weight_One(weight_type):
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new fst.WeightClass(
+ * fst.WeightClass.One(tostring(weight_type))))
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 633, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 633, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":634
+ * cdef Weight _Weight_One(weight_type):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<<
+ * fst.WeightClass.One(tostring(weight_type))))
+ * if result._weight.get().Type() == b"none":
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 634, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":635
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(
+ * fst.WeightClass.One(tostring(weight_type)))) # <<<<<<<<<<<<<<
+ * if result._weight.get().Type() == b"none":
+ * raise FstUnknownWeightTypeError(weight_type)
+ */
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 635, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":634
+ * cdef Weight _Weight_One(weight_type):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<<
+ * fst.WeightClass.One(tostring(weight_type))))
+ * if result._weight.get().Type() == b"none":
+ */
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::One(__pyx_t_2)));
+
+ /* "pywrapfst.pyx":636
+ * result._weight.reset(new fst.WeightClass(
+ * fst.WeightClass.One(tostring(weight_type))))
+ * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<<
+ * raise FstUnknownWeightTypeError(weight_type)
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 636, __pyx_L1_error)
+ }
+ __pyx_t_3 = ((__pyx_v_result->_weight.get()->Type() == ((char *)"none")) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":637
+ * fst.WeightClass.One(tostring(weight_type))))
+ * if result._weight.get().Type() == b"none":
+ * raise FstUnknownWeightTypeError(weight_type) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstUnknownWeightTypeError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 637, __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);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 637, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_weight_type};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 637, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_weight_type};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 637, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 637, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_INCREF(__pyx_v_weight_type);
+ __Pyx_GIVEREF(__pyx_v_weight_type);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_weight_type);
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 637, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __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, 637, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":636
+ * result._weight.reset(new fst.WeightClass(
+ * fst.WeightClass.One(tostring(weight_type))))
+ * if result._weight.get().Type() == b"none": # <<<<<<<<<<<<<<
+ * raise FstUnknownWeightTypeError(weight_type)
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":638
+ * if result._weight.get().Type() == b"none":
+ * raise FstUnknownWeightTypeError(weight_type)
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":632
+ *
+ *
+ * cdef Weight _Weight_One(weight_type): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._Weight_One", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":641
+ *
+ *
+ * cdef Weight _Weight_NoWeight(weight_type): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(
+ */
+
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst__Weight_NoWeight(PyObject *__pyx_v_weight_type) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ std::string __pyx_t_2;
+ __Pyx_RefNannySetupContext("_Weight_NoWeight", 0);
+
+ /* "pywrapfst.pyx":642
+ *
+ * cdef Weight _Weight_NoWeight(weight_type):
+ * cdef Weight result = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * result._weight.reset(new fst.WeightClass(
+ * fst.WeightClass.NoWeight(tostring(weight_type))))
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 642, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 642, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":643
+ * cdef Weight _Weight_NoWeight(weight_type):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<<
+ * fst.WeightClass.NoWeight(tostring(weight_type))))
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 643, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":644
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(
+ * fst.WeightClass.NoWeight(tostring(weight_type)))) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_weight_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 644, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":643
+ * cdef Weight _Weight_NoWeight(weight_type):
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass( # <<<<<<<<<<<<<<
+ * fst.WeightClass.NoWeight(tostring(weight_type))))
+ * return result
+ */
+ __pyx_v_result->_weight.reset(new fst::script::WeightClass(fst::script::WeightClass::NoWeight(__pyx_t_2)));
+
+ /* "pywrapfst.pyx":645
+ * result._weight.reset(new fst.WeightClass(
+ * fst.WeightClass.NoWeight(tostring(weight_type))))
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":641
+ *
+ *
+ * cdef Weight _Weight_NoWeight(weight_type): # <<<<<<<<<<<<<<
+ * cdef Weight result = Weight.__new__(Weight)
+ * result._weight.reset(new fst.WeightClass(
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._Weight_NoWeight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":679
+ * # Doing so will allow undefined behavior.
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_12_SymbolTable_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_12_SymbolTable_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+ if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1;
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable___init__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_12_SymbolTable___init__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":680
+ *
+ * def __init__(self):
+ * raise FstDeletedConstructorError( # <<<<<<<<<<<<<<
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":681
+ * def __init__(self):
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<<
+ *
+ * def __iter__(self):
+ */
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 681, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 680, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 680, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 680, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 680, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 680, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 680, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":679
+ * # Doing so will allow undefined behavior.
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":683
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ * def __iter__(self): # <<<<<<<<<<<<<<
+ * return SymbolTableIterator(self)
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_3__iter__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_3__iter__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_2__iter__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_2__iter__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("__iter__", 0);
+
+ /* "pywrapfst.pyx":684
+ *
+ * def __iter__(self):
+ * return SymbolTableIterator(self) # <<<<<<<<<<<<<<
+ *
+ * cpdef int64 available_key(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 684, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_SymbolTableIterator), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 684, __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":683
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ * def __iter__(self): # <<<<<<<<<<<<<<
+ * return SymbolTableIterator(self)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":686
+ * return SymbolTableIterator(self)
+ *
+ * cpdef int64 available_key(self): # <<<<<<<<<<<<<<
+ * return self._table.AvailableKey()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_5available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_5;
+ __Pyx_RefNannySetupContext("available_key", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_available_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 686, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_5available_key)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 686, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 686, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 686, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":687
+ *
+ * cpdef int64 available_key(self):
+ * return self._table.AvailableKey() # <<<<<<<<<<<<<<
+ *
+ * cpdef string checksum(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 687, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_table->AvailableKey();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":686
+ * return SymbolTableIterator(self)
+ *
+ * cpdef int64 available_key(self): # <<<<<<<<<<<<<<
+ * return self._table.AvailableKey()
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst._SymbolTable.available_key", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_5available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_5available_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("available_key (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_4available_key(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_4available_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("available_key", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_12_SymbolTable_available_key(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 686, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.available_key", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":689
+ * return self._table.AvailableKey()
+ *
+ * cpdef string checksum(self): # <<<<<<<<<<<<<<
+ * return self._table.CheckSum()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_7checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_12_SymbolTable_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("checksum", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 689, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_7checksum)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 689, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 689, __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, 689, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":690
+ *
+ * cpdef string checksum(self):
+ * return self._table.CheckSum() # <<<<<<<<<<<<<<
+ *
+ * cpdef SymbolTable copy(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 690, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_table->CheckSum();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":689
+ * return self._table.AvailableKey()
+ *
+ * cpdef string checksum(self): # <<<<<<<<<<<<<<
+ * return self._table.CheckSum()
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst._SymbolTable.checksum", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_7checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_7checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("checksum (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_6checksum(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_6checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("checksum", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12_SymbolTable_checksum(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 689, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.checksum", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":692
+ * return self._table.CheckSum()
+ *
+ * cpdef SymbolTable copy(self): # <<<<<<<<<<<<<<
+ * """
+ * copy(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_12_SymbolTable_copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 692, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_9copy)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 692, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 692, __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, 692, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":698
+ * Returns a mutable copy of the SymbolTable.
+ * """
+ * return _init_SymbolTable(self._table.Copy()) # <<<<<<<<<<<<<<
+ *
+ * def find(self, key):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 698, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_self->_table->Copy())); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 698, __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":692
+ * return self._table.CheckSum()
+ *
+ * cpdef SymbolTable copy(self): # <<<<<<<<<<<<<<
+ * """
+ * copy(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_12_SymbolTable_8copy[] = "\n copy(self)\n\n Returns a mutable copy of the SymbolTable.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_9copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("copy (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_8copy(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_8copy(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_12_SymbolTable_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 692, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":700
+ * return _init_SymbolTable(self._table.Copy())
+ *
+ * def find(self, key): # <<<<<<<<<<<<<<
+ * """
+ * find(self, key)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_11find(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static char __pyx_doc_9pywrapfst_12_SymbolTable_10find[] = "\n find(self, key)\n\n Given a symbol or index, finds the other one.\n\n This method returns the index associated with a symbol key, or the symbol\n associated with a index key.\n\n Args:\n key: Either a string or an index.\n\n Returns:\n If key is a string, the associated index; if key is an integer, the\n associated symbol.\n\n Raises:\n KeyError: Key not found.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_11find(PyObject *__pyx_v_self, PyObject *__pyx_v_key) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("find (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_10find(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_key));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_10find(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key) {
+ PyObject *__pyx_v_result = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ std::string __pyx_t_4;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ int __pyx_t_8;
+ PyObject *__pyx_t_9 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_10;
+ PyObject *__pyx_t_11 = NULL;
+ PyObject *__pyx_t_12 = NULL;
+ __Pyx_RefNannySetupContext("find", 0);
+
+ /* "pywrapfst.pyx":719
+ * KeyError: Key not found.
+ * """
+ * try: # <<<<<<<<<<<<<<
+ * result = self._table.FindIndex(tostring(key))
+ * if result == -1:
+ */
+ {
+ __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":720
+ * """
+ * try:
+ * result = self._table.FindIndex(tostring(key)) # <<<<<<<<<<<<<<
+ * if result == -1:
+ * raise KeyError(key)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 720, __pyx_L3_error)
+ }
+ __pyx_t_4 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 720, __pyx_L3_error)
+ __pyx_t_5 = __Pyx_PyInt_From_int64_t(__pyx_v_self->_table->Find(__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 720, __pyx_L3_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_v_result = __pyx_t_5;
+ __pyx_t_5 = 0;
+
+ /* "pywrapfst.pyx":721
+ * try:
+ * result = self._table.FindIndex(tostring(key))
+ * if result == -1: # <<<<<<<<<<<<<<
+ * raise KeyError(key)
+ * except FstArgError:
+ */
+ __pyx_t_5 = __Pyx_PyInt_EqObjC(__pyx_v_result, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 721, __pyx_L3_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 721, __pyx_L3_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (__pyx_t_6) {
+
+ /* "pywrapfst.pyx":722
+ * result = self._table.FindIndex(tostring(key))
+ * if result == -1:
+ * raise KeyError(key) # <<<<<<<<<<<<<<
+ * except FstArgError:
+ * result = self._table.FindSymbol(key)
+ */
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 722, __pyx_L3_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_key);
+ __Pyx_GIVEREF(__pyx_v_key);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_key);
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 722, __pyx_L3_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __PYX_ERR(0, 722, __pyx_L3_error)
+
+ /* "pywrapfst.pyx":721
+ * try:
+ * result = self._table.FindIndex(tostring(key))
+ * if result == -1: # <<<<<<<<<<<<<<
+ * raise KeyError(key)
+ * except FstArgError:
+ */
+ }
+
+ /* "pywrapfst.pyx":719
+ * KeyError: Key not found.
+ * """
+ * try: # <<<<<<<<<<<<<<
+ * result = self._table.FindIndex(tostring(key))
+ * if result == -1:
+ */
+ }
+ __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;
+ goto __pyx_L10_try_end;
+ __pyx_L3_error:;
+ __Pyx_PyThreadState_assign
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+
+ /* "pywrapfst.pyx":723
+ * if result == -1:
+ * raise KeyError(key)
+ * except FstArgError: # <<<<<<<<<<<<<<
+ * result = self._table.FindSymbol(key)
+ * if result == b"":
+ */
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 723, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (__pyx_t_8) {
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.find", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(0, 723, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GOTREF(__pyx_t_9);
+
+ /* "pywrapfst.pyx":724
+ * raise KeyError(key)
+ * except FstArgError:
+ * result = self._table.FindSymbol(key) # <<<<<<<<<<<<<<
+ * if result == b"":
+ * raise KeyError(key)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 724, __pyx_L5_except_error)
+ }
+ __pyx_t_10 = __Pyx_PyInt_As_int64_t(__pyx_v_key); if (unlikely((__pyx_t_10 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 724, __pyx_L5_except_error)
+ __pyx_t_11 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->_table->Find(__pyx_t_10)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 724, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __Pyx_XDECREF_SET(__pyx_v_result, __pyx_t_11);
+ __pyx_t_11 = 0;
+
+ /* "pywrapfst.pyx":725
+ * except FstArgError:
+ * result = self._table.FindSymbol(key)
+ * if result == b"": # <<<<<<<<<<<<<<
+ * raise KeyError(key)
+ * return result
+ */
+ __pyx_t_6 = (__Pyx_PyBytes_Equals(__pyx_v_result, __pyx_kp_b_, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 725, __pyx_L5_except_error)
+ if (__pyx_t_6) {
+
+ /* "pywrapfst.pyx":726
+ * result = self._table.FindSymbol(key)
+ * if result == b"":
+ * raise KeyError(key) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 726, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __Pyx_INCREF(__pyx_v_key);
+ __Pyx_GIVEREF(__pyx_v_key);
+ PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_v_key);
+ __pyx_t_12 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_11, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 726, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_12);
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __Pyx_Raise(__pyx_t_12, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+ __PYX_ERR(0, 726, __pyx_L5_except_error)
+
+ /* "pywrapfst.pyx":725
+ * except FstArgError:
+ * result = self._table.FindSymbol(key)
+ * if result == b"": # <<<<<<<<<<<<<<
+ * raise KeyError(key)
+ * return result
+ */
+ }
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ goto __pyx_L4_exception_handled;
+ }
+ goto __pyx_L5_except_error;
+ __pyx_L5_except_error:;
+
+ /* "pywrapfst.pyx":719
+ * KeyError: Key not found.
+ * """
+ * try: # <<<<<<<<<<<<<<
+ * result = self._table.FindIndex(tostring(key))
+ * if result == -1:
+ */
+ __Pyx_PyThreadState_assign
+ __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_L4_exception_handled:;
+ __Pyx_PyThreadState_assign
+ __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);
+ __pyx_L10_try_end:;
+ }
+
+ /* "pywrapfst.pyx":727
+ * if result == b"":
+ * raise KeyError(key)
+ * return result # <<<<<<<<<<<<<<
+ *
+ * cpdef bool member(self, key):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_result);
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":700
+ * return _init_SymbolTable(self._table.Copy())
+ *
+ * def find(self, key): # <<<<<<<<<<<<<<
+ * """
+ * find(self, key)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_XDECREF(__pyx_t_11);
+ __Pyx_XDECREF(__pyx_t_12);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.find", __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":729
+ * return result
+ *
+ * cpdef bool member(self, key): # <<<<<<<<<<<<<<
+ * """
+ * member(self, key)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_13member(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static bool __pyx_f_9pywrapfst_12_SymbolTable_member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ bool __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ std::string __pyx_t_10;
+ int __pyx_t_11;
+ __pyx_t_10basictypes_int64 __pyx_t_12;
+ __Pyx_RefNannySetupContext("member", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_member); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_13member)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_key);
+ __Pyx_GIVEREF(__pyx_v_key);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_key);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_6;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":745
+ * Whether or not the key is present (as a string or a index) in the table.
+ * """
+ * try: # <<<<<<<<<<<<<<
+ * return self._table.MemberSymbol(tostring(key))
+ * except FstArgError:
+ */
+ {
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
+ __Pyx_XGOTREF(__pyx_t_7);
+ __Pyx_XGOTREF(__pyx_t_8);
+ __Pyx_XGOTREF(__pyx_t_9);
+ /*try:*/ {
+
+ /* "pywrapfst.pyx":746
+ * """
+ * try:
+ * return self._table.MemberSymbol(tostring(key)) # <<<<<<<<<<<<<<
+ * except FstArgError:
+ * return self._table.MemberIndex(key)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 746, __pyx_L3_error)
+ }
+ __pyx_t_10 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 746, __pyx_L3_error)
+ __pyx_r = __pyx_v_self->_table->Member(__pyx_t_10);
+ goto __pyx_L7_try_return;
+
+ /* "pywrapfst.pyx":745
+ * Whether or not the key is present (as a string or a index) in the table.
+ * """
+ * try: # <<<<<<<<<<<<<<
+ * return self._table.MemberSymbol(tostring(key))
+ * except FstArgError:
+ */
+ }
+ __pyx_L3_error:;
+ __Pyx_PyThreadState_assign
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":747
+ * try:
+ * return self._table.MemberSymbol(tostring(key))
+ * except FstArgError: # <<<<<<<<<<<<<<
+ * return self._table.MemberIndex(key)
+ *
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 747, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (__pyx_t_11) {
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.member", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 747, __pyx_L5_except_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_GOTREF(__pyx_t_3);
+
+ /* "pywrapfst.pyx":748
+ * return self._table.MemberSymbol(tostring(key))
+ * except FstArgError:
+ * return self._table.MemberIndex(key) # <<<<<<<<<<<<<<
+ *
+ * def __contains__(self, key):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 748, __pyx_L5_except_error)
+ }
+ __pyx_t_12 = __Pyx_PyInt_As_int64_t(__pyx_v_key); if (unlikely((__pyx_t_12 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 748, __pyx_L5_except_error)
+ __pyx_r = __pyx_v_self->_table->Member(__pyx_t_12);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ goto __pyx_L6_except_return;
+ }
+ goto __pyx_L5_except_error;
+ __pyx_L5_except_error:;
+
+ /* "pywrapfst.pyx":745
+ * Whether or not the key is present (as a string or a index) in the table.
+ * """
+ * try: # <<<<<<<<<<<<<<
+ * return self._table.MemberSymbol(tostring(key))
+ * except FstArgError:
+ */
+ __Pyx_PyThreadState_assign
+ __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_PyThreadState_assign
+ __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_PyThreadState_assign
+ __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":729
+ * return result
+ *
+ * cpdef bool member(self, key): # <<<<<<<<<<<<<<
+ * """
+ * member(self, key)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_WriteUnraisable("pywrapfst._SymbolTable.member", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_13member(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static char __pyx_doc_9pywrapfst_12_SymbolTable_12member[] = "\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 much better to simply call the find method, catching the KeyError.\n\n Args:\n key: Either a string or an index.\n\n Returns:\n Whether or not the key is present (as a string or a index) in the table.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_13member(PyObject *__pyx_v_self, PyObject *__pyx_v_key) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("member (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_12member(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_key));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_12member(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("member", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_12_SymbolTable_member(__pyx_v_self, __pyx_v_key, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 729, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.member", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":750
+ * return self._table.MemberIndex(key)
+ *
+ * def __contains__(self, key): # <<<<<<<<<<<<<<
+ * return self.member(key)
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_12_SymbolTable_15__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static int __pyx_pw_9pywrapfst_12_SymbolTable_15__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__contains__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_14__contains__(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_key));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_12_SymbolTable_14__contains__(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_key) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__contains__", 0);
+
+ /* "pywrapfst.pyx":751
+ *
+ * def __contains__(self, key):
+ * return self.member(key) # <<<<<<<<<<<<<<
+ *
+ * cpdef int64 get_nth_key(self, ssize_t pos) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "member");
+ __PYX_ERR(0, 751, __pyx_L1_error)
+ }
+ __pyx_r = ((struct __pyx_vtabstruct_9pywrapfst__SymbolTable *)__pyx_v_self->__pyx_vtab)->member(__pyx_v_self, __pyx_v_key, 0);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":750
+ * return self._table.MemberIndex(key)
+ *
+ * def __contains__(self, key): # <<<<<<<<<<<<<<
+ * return self.member(key)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.__contains__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":753
+ * return self.member(key)
+ *
+ * cpdef int64 get_nth_key(self, ssize_t pos) except *: # <<<<<<<<<<<<<<
+ * """
+ * get_nth_key(self, pos)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_17get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_12_SymbolTable_get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_int64 __pyx_v_result;
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_7;
+ int __pyx_t_8;
+ __Pyx_RefNannySetupContext("get_nth_key", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_nth_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_17get_nth_key)) {
+ __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_pos); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_7 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_7 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_7;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":768
+ * KeyError: index not found.
+ * """
+ * cdef int64 result = self._table.GetNthKey(pos) # <<<<<<<<<<<<<<
+ * if result == -1:
+ * raise KeyError(pos)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 768, __pyx_L1_error)
+ }
+ __pyx_v_result = __pyx_v_self->_table->GetNthKey(__pyx_v_pos);
+
+ /* "pywrapfst.pyx":769
+ * """
+ * cdef int64 result = self._table.GetNthKey(pos)
+ * if result == -1: # <<<<<<<<<<<<<<
+ * raise KeyError(pos)
+ * return result
+ */
+ __pyx_t_8 = ((__pyx_v_result == -1L) != 0);
+ if (__pyx_t_8) {
+
+ /* "pywrapfst.pyx":770
+ * cdef int64 result = self._table.GetNthKey(pos)
+ * if result == -1:
+ * raise KeyError(pos) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_pos); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 770, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 770, __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_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 770, __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, 770, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":769
+ * """
+ * cdef int64 result = self._table.GetNthKey(pos)
+ * if result == -1: # <<<<<<<<<<<<<<
+ * raise KeyError(pos)
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":771
+ * if result == -1:
+ * raise KeyError(pos)
+ * return result # <<<<<<<<<<<<<<
+ *
+ * cpdef string labeled_checksum(self):
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":753
+ * return self.member(key)
+ *
+ * cpdef int64 get_nth_key(self, ssize_t pos) except *: # <<<<<<<<<<<<<<
+ * """
+ * get_nth_key(self, pos)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.get_nth_key", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_17get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos); /*proto*/
+static char __pyx_doc_9pywrapfst_12_SymbolTable_16get_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.\n\n Raises:\n KeyError: index not found.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_17get_nth_key(PyObject *__pyx_v_self, PyObject *__pyx_arg_pos) {
+ Py_ssize_t __pyx_v_pos;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("get_nth_key (wrapper)", 0);
+ assert(__pyx_arg_pos); {
+ __pyx_v_pos = PyInt_AsSsize_t(__pyx_arg_pos); if (unlikely((__pyx_v_pos == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 753, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.get_nth_key", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_16get_nth_key(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((Py_ssize_t)__pyx_v_pos));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_16get_nth_key(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, Py_ssize_t __pyx_v_pos) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __pyx_t_10basictypes_int64 __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("get_nth_key", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_f_9pywrapfst_12_SymbolTable_get_nth_key(__pyx_v_self, __pyx_v_pos, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 753, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 753, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.get_nth_key", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":773
+ * return result
+ *
+ * cpdef string labeled_checksum(self): # <<<<<<<<<<<<<<
+ * return self._table.LabeledCheckSum()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_19labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("labeled_checksum", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_labeled_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 773, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_19labeled_checksum)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 773, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 773, __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, 773, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":774
+ *
+ * cpdef string labeled_checksum(self):
+ * return self._table.LabeledCheckSum() # <<<<<<<<<<<<<<
+ *
+ * cpdef string name(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 774, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_table->LabeledCheckSum();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":773
+ * return result
+ *
+ * cpdef string labeled_checksum(self): # <<<<<<<<<<<<<<
+ * return self._table.LabeledCheckSum()
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst._SymbolTable.labeled_checksum", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_19labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_19labeled_checksum(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("labeled_checksum (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_18labeled_checksum(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_18labeled_checksum(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("labeled_checksum", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 773, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.labeled_checksum", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":776
+ * return self._table.LabeledCheckSum()
+ *
+ * cpdef string name(self): # <<<<<<<<<<<<<<
+ * return self._table.Name()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_12_SymbolTable_name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("name", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_21name)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 776, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 776, __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, 776, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":777
+ *
+ * cpdef string name(self):
+ * return self._table.Name() # <<<<<<<<<<<<<<
+ *
+ * cpdef size_t num_symbols(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 777, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_table->Name();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":776
+ * return self._table.LabeledCheckSum()
+ *
+ * cpdef string name(self): # <<<<<<<<<<<<<<
+ * return self._table.Name()
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst._SymbolTable.name", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_21name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("name (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_20name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_20name(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("name", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12_SymbolTable_name(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.name", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":779
+ * return self._table.Name()
+ *
+ * cpdef size_t num_symbols(self): # <<<<<<<<<<<<<<
+ * return self._table.NumSymbols()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static size_t __pyx_f_9pywrapfst_12_SymbolTable_num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, int __pyx_skip_dispatch) {
+ size_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ size_t __pyx_t_5;
+ __Pyx_RefNannySetupContext("num_symbols", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 779, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 779, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 779, __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, 779, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":780
+ *
+ * cpdef size_t num_symbols(self):
+ * return self._table.NumSymbols() # <<<<<<<<<<<<<<
+ *
+ * cpdef void write(self, filename) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 780, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_table->NumSymbols();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":779
+ * return self._table.Name()
+ *
+ * cpdef size_t num_symbols(self): # <<<<<<<<<<<<<<
+ * return self._table.NumSymbols()
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst._SymbolTable.num_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("num_symbols (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_22num_symbols(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_22num_symbols(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("num_symbols", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_9pywrapfst_12_SymbolTable_num_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 779, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.num_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":782
+ * return self._table.NumSymbols()
+ *
+ * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<<
+ * """
+ * write(self, filename)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/
+static void __pyx_f_9pywrapfst_12_SymbolTable_write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ std::string __pyx_t_6;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("write", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 782, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_25write)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_filename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 782, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 782, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 782, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 782, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_filename);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 782, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":796
+ * FstIOError: Write failed.
+ * """
+ * if not self._table.Write(tostring(filename)): # <<<<<<<<<<<<<<
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 796, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 796, __pyx_L1_error)
+ __pyx_t_7 = ((!(__pyx_v_self->_table->Write(__pyx_t_6) != 0)) != 0);
+ if (__pyx_t_7) {
+
+ /* "pywrapfst.pyx":797
+ * """
+ * if not self._table.Write(tostring(filename)):
+ * raise FstIOError("Write failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ *
+ * cpdef void write_text(self, filename) except *:
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Write_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 797, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 797, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":796
+ * FstIOError: Write failed.
+ * """
+ * if not self._table.Write(tostring(filename)): # <<<<<<<<<<<<<<
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ */
+ }
+
+ /* "pywrapfst.pyx":782
+ * return self._table.NumSymbols()
+ *
+ * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<<
+ * """
+ * write(self, filename)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/
+static char __pyx_doc_9pywrapfst_12_SymbolTable_24write[] = "\n write(self, filename)\n\n Serializes symbol table to a file.\n\n This methods writes the SymbolTable to a file in binary format.\n\n Args:\n filename: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_25write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("write (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_24write(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_filename));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_24write(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("write", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_f_9pywrapfst_12_SymbolTable_write(__pyx_v_self, __pyx_v_filename, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 782, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 782, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":799
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ * cpdef void write_text(self, filename) except *: # <<<<<<<<<<<<<<
+ * """
+ * write_text(self, filename)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/
+static void __pyx_f_9pywrapfst_12_SymbolTable_write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ std::string __pyx_t_6;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("write_text", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write_text); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 799, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_27write_text)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_filename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 799, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 799, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 799, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 799, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_filename);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 799, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":813
+ * FstIOError: Write failed.
+ * """
+ * if not self._table.WriteText(tostring(filename)): # <<<<<<<<<<<<<<
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 813, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 813, __pyx_L1_error)
+ __pyx_t_7 = ((!(__pyx_v_self->_table->WriteText(__pyx_t_6) != 0)) != 0);
+ if (__pyx_t_7) {
+
+ /* "pywrapfst.pyx":814
+ * """
+ * if not self._table.WriteText(tostring(filename)):
+ * raise FstIOError("Write failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Write_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 814, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":813
+ * FstIOError: Write failed.
+ * """
+ * if not self._table.WriteText(tostring(filename)): # <<<<<<<<<<<<<<
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ */
+ }
+
+ /* "pywrapfst.pyx":799
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ * cpdef void write_text(self, filename) except *: # <<<<<<<<<<<<<<
+ * """
+ * write_text(self, filename)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.write_text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/
+static char __pyx_doc_9pywrapfst_12_SymbolTable_26write_text[] = "\n write_text(self, filename)\n\n Writes symbol table to text file.\n\n This method writes the SymbolTable to a file in human-readable format.\n\n Args:\n filename: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12_SymbolTable_27write_text(PyObject *__pyx_v_self, PyObject *__pyx_v_filename) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("write_text (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12_SymbolTable_26write_text(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_filename));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12_SymbolTable_26write_text(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_self, PyObject *__pyx_v_filename) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("write_text", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_f_9pywrapfst_12_SymbolTable_write_text(__pyx_v_self, __pyx_v_filename, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 799, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 799, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._SymbolTable.write_text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":832
+ * # Doing so will allow undefined behavior.
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<const EncodeMapper SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ * id(self))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable___repr__(((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_24_EncodeMapperSymbolTable___repr__(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":833
+ *
+ * def __repr__(self):
+ * return "<const EncodeMapper SymbolTable {!r} at 0x{:x}>".format(self.name(), # <<<<<<<<<<<<<<
+ * id(self))
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_const_EncodeMapper_SymbolTable, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 833, __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 '%s'", "name");
+ __PYX_ERR(0, 833, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 833, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+
+ /* "pywrapfst.pyx":834
+ * def __repr__(self):
+ * return "<const EncodeMapper SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ * id(self)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 834, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 834, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 833, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 833, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 833, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_4) {
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 833, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":832
+ * # Doing so will allow undefined behavior.
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<const EncodeMapper SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ * id(self))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst._EncodeMapperSymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":851
+ * # Doing so will allow undefined behavior.
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<const Fst SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ * id(self))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_15_FstSymbolTable_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_15_FstSymbolTable___repr__(((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_15_FstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":852
+ *
+ * def __repr__(self):
+ * return "<const Fst SymbolTable {!r} at 0x{:x}>".format(self.name(), # <<<<<<<<<<<<<<
+ * id(self))
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_const_Fst_SymbolTable_r_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 852, __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 '%s'", "name");
+ __PYX_ERR(0, 852, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 852, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+
+ /* "pywrapfst.pyx":853
+ * def __repr__(self):
+ * return "<const Fst SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ * id(self)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 853, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 853, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 852, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_4) {
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 852, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":851
+ * # Doing so will allow undefined behavior.
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<const Fst SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ * id(self))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst._FstSymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":867
+ * """
+ *
+ * cpdef int64 add_symbol(self, symbol, int64 key=-1): # <<<<<<<<<<<<<<
+ * """
+ * add_symbol(self, symbol, key=-1)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args) {
+ __pyx_t_10basictypes_int64 __pyx_v_key = ((__pyx_t_10basictypes_int64)-1L);
+ PyObject *__pyx_v_symbol_string = 0;
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_8;
+ std::string __pyx_t_9;
+ int __pyx_t_10;
+ __Pyx_RefNannySetupContext("add_symbol", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_key = __pyx_optional_args->key;
+ }
+ }
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 867, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol)) {
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 867, __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, 867, __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, 867, __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, 867, __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, 867, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_8 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_8 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 867, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_8;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":883
+ * The integer key of the new symbol.
+ * """
+ * cdef symbol_string = tostring(symbol) # <<<<<<<<<<<<<<
+ * if key != -1:
+ * return self._table.AddSymbol(symbol_string, key)
+ */
+ __pyx_t_9 = __pyx_f_9pywrapfst_tostring(__pyx_v_symbol, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 883, __pyx_L1_error)
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 883, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_symbol_string = __pyx_t_1;
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":884
+ * """
+ * cdef symbol_string = tostring(symbol)
+ * if key != -1: # <<<<<<<<<<<<<<
+ * return self._table.AddSymbol(symbol_string, key)
+ * else:
+ */
+ __pyx_t_10 = ((__pyx_v_key != -1L) != 0);
+ if (__pyx_t_10) {
+
+ /* "pywrapfst.pyx":885
+ * cdef symbol_string = tostring(symbol)
+ * if key != -1:
+ * return self._table.AddSymbol(symbol_string, key) # <<<<<<<<<<<<<<
+ * else:
+ * return self._table.AddSymbol(symbol_string)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 885, __pyx_L1_error)
+ }
+ __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_v_symbol_string); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 885, __pyx_L1_error)
+ __pyx_r = __pyx_v_self->__pyx_base._table->AddSymbol(__pyx_t_9, __pyx_v_key);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":884
+ * """
+ * cdef symbol_string = tostring(symbol)
+ * if key != -1: # <<<<<<<<<<<<<<
+ * return self._table.AddSymbol(symbol_string, key)
+ * else:
+ */
+ }
+
+ /* "pywrapfst.pyx":887
+ * return self._table.AddSymbol(symbol_string, key)
+ * else:
+ * return self._table.AddSymbol(symbol_string) # <<<<<<<<<<<<<<
+ *
+ * cpdef void add_table(self, _SymbolTable syms):
+ */
+ /*else*/ {
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 887, __pyx_L1_error)
+ }
+ __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_v_symbol_string); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 887, __pyx_L1_error)
+ __pyx_r = __pyx_v_self->__pyx_base._table->AddSymbol(__pyx_t_9);
+ goto __pyx_L0;
+ }
+
+ /* "pywrapfst.pyx":867
+ * """
+ *
+ * cpdef int64 add_symbol(self, symbol, int64 key=-1): # <<<<<<<<<<<<<<
+ * """
+ * add_symbol(self, symbol, key=-1)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_WriteUnraisable("pywrapfst._MutableSymbolTable.add_symbol", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_symbol_string);
+ __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=-1)\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 (-1 is reserved for \"no symbol requested\").\n\n Returns:\n The integer key of the new symbol.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_symbol = 0;
+ __pyx_t_10basictypes_int64 __pyx_v_key;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("add_symbol (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_symbol,&__pyx_n_s_key,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_symbol)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_key);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add_symbol") < 0)) __PYX_ERR(0, 867, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_symbol = values[0];
+ if (values[1]) {
+ __pyx_v_key = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_key == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 867, __pyx_L3_error)
+ } else {
+ __pyx_v_key = ((__pyx_t_10basictypes_int64)-1L);
+ }
+ }
+ 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, 867, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.add_symbol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_add_symbol(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), __pyx_v_symbol, __pyx_v_key);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_add_symbol(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_symbol, __pyx_t_10basictypes_int64 __pyx_v_key) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __pyx_t_10basictypes_int64 __pyx_t_1;
+ struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("add_symbol", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.key = __pyx_v_key;
+ __pyx_t_1 = __pyx_vtabptr_9pywrapfst__MutableSymbolTable->add_symbol(__pyx_v_self, __pyx_v_symbol, 1, &__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 867, __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":889
+ * return self._table.AddSymbol(symbol_string)
+ *
+ * cpdef void add_table(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * add_table(self, syms)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static void __pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("add_table", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_table); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 889, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_syms)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 889, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(((PyObject *)__pyx_v_syms));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_syms));
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_syms));
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 889, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":901
+ * syms: A SymbolTable to be merged with the current table.
+ * """
+ * self._table.AddTable(deref(syms._table)) # <<<<<<<<<<<<<<
+ *
+ * cpdef void set_name(self, new_name) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 901, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 901, __pyx_L1_error)
+ }
+ __pyx_v_self->__pyx_base._table->AddTable((*__pyx_v_syms->_table));
+
+ /* "pywrapfst.pyx":889
+ * return self._table.AddSymbol(symbol_string)
+ *
+ * cpdef void add_table(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * add_table(self, syms)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_WriteUnraisable("pywrapfst._MutableSymbolTable.add_table", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static char __pyx_doc_9pywrapfst_19_MutableSymbolTable_2add_table[] = "\n add_table(self, syms)\n\n Adds another SymbolTable to this table.\n\n This method merges another symbol table into the current table. All key\n values will be offset by the current available key.\n\n Args:\n syms: A SymbolTable to be merged with the current table.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("add_table (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 889, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_2add_table(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_2add_table(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("add_table", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_19_MutableSymbolTable_add_table(__pyx_v_self, __pyx_v_syms, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 889, __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":903
+ * self._table.AddTable(deref(syms._table))
+ *
+ * cpdef void set_name(self, new_name) except *: # <<<<<<<<<<<<<<
+ * self._table.SetName(tostring(new_name))
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name(PyObject *__pyx_v_self, PyObject *__pyx_v_new_name); /*proto*/
+static void __pyx_f_9pywrapfst_19_MutableSymbolTable_set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ std::string __pyx_t_6;
+ __Pyx_RefNannySetupContext("set_name", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 903, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_new_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 903, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_new_name};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 903, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_new_name};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 903, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 903, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_new_name);
+ __Pyx_GIVEREF(__pyx_v_new_name);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_new_name);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 903, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":904
+ *
+ * cpdef void set_name(self, new_name) except *:
+ * self._table.SetName(tostring(new_name)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 904, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_new_name, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 904, __pyx_L1_error)
+ __pyx_v_self->__pyx_base._table->SetName(__pyx_t_6);
+
+ /* "pywrapfst.pyx":903
+ * self._table.AddTable(deref(syms._table))
+ *
+ * cpdef void set_name(self, new_name) except *: # <<<<<<<<<<<<<<
+ * self._table.SetName(tostring(new_name))
+ *
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst._MutableSymbolTable.set_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name(PyObject *__pyx_v_self, PyObject *__pyx_v_new_name); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name(PyObject *__pyx_v_self, PyObject *__pyx_v_new_name) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_name (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19_MutableSymbolTable_4set_name(((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)__pyx_v_self), ((PyObject *)__pyx_v_new_name));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19_MutableSymbolTable_4set_name(struct __pyx_obj_9pywrapfst__MutableSymbolTable *__pyx_v_self, PyObject *__pyx_v_new_name) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("set_name", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_f_9pywrapfst_19_MutableSymbolTable_set_name(__pyx_v_self, __pyx_v_new_name, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 903, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 903, __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":923
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<Fst SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_22_MutableFstSymbolTable_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_22_MutableFstSymbolTable___repr__(((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_22_MutableFstSymbolTable___repr__(struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":924
+ *
+ * def __repr__(self):
+ * return "<Fst SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Fst_SymbolTable_r_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 924, __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 '%s'", "name");
+ __PYX_ERR(0, 924, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 924, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 924, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 924, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 924, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 924, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 924, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_4) {
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 924, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":923
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<Fst SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst._MutableFstSymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":952
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable___repr__(((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable___repr__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":953
+ *
+ * def __repr__(self):
+ * return "<SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self, name=b"<unspecified>"):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_SymbolTable_r_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 953, __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 '%s'", "name");
+ __PYX_ERR(0, 953, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_SymbolTable *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.name(((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_self), 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 953, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 953, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 953, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 953, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 953, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 953, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_4) {
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 953, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":952
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":955
+ * return "<SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+ *
+ * def __init__(self, name=b"<unspecified>"): # <<<<<<<<<<<<<<
+ * self._table = new fst.SymbolTable(tostring(name))
+ * self._smart_table.reset(self._table)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_11SymbolTable_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_11SymbolTable_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_name = 0;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name_2,0};
+ PyObject* values[1] = {0};
+ values[0] = ((PyObject *)__pyx_kp_b_unspecified);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name_2);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 955, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 955, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_2__init__(((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_v_self), __pyx_v_name);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_11SymbolTable_2__init__(struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_self, PyObject *__pyx_v_name) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":956
+ *
+ * def __init__(self, name=b"<unspecified>"):
+ * self._table = new fst.SymbolTable(tostring(name)) # <<<<<<<<<<<<<<
+ * self._smart_table.reset(self._table)
+ *
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_name, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 956, __pyx_L1_error)
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 956, __pyx_L1_error)
+ }
+ __pyx_v_self->__pyx_base.__pyx_base._table = new fst::SymbolTable(__pyx_t_1);
+
+ /* "pywrapfst.pyx":957
+ * def __init__(self, name=b"<unspecified>"):
+ * self._table = new fst.SymbolTable(tostring(name))
+ * self._smart_table.reset(self._table) # <<<<<<<<<<<<<<
+ *
+ * @classmethod
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_smart_table");
+ __PYX_ERR(0, 957, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 957, __pyx_L1_error)
+ }
+ __pyx_v_self->_smart_table.reset(__pyx_v_self->__pyx_base.__pyx_base._table);
+
+ /* "pywrapfst.pyx":955
+ * return "<SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+ *
+ * def __init__(self, name=b"<unspecified>"): # <<<<<<<<<<<<<<
+ * self._table = new fst.SymbolTable(tostring(name))
+ * self._smart_table.reset(self._table)
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":960
+ *
+ * @classmethod
+ * def read(cls, filename): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read(filename)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_5read(PyObject *__pyx_v_cls, PyObject *__pyx_v_filename); /*proto*/
+static char __pyx_doc_9pywrapfst_11SymbolTable_4read[] = "\n SymbolTable.read(filename)\n\n Reads symbol table from binary file.\n\n This class method creates a new SymbolTable from a symbol table binary file.\n\n Args:\n filename: The string location of the input binary file.\n\n Returns:\n A new SymbolTable instance.\n\n See also: `SymbolTable.read_fst`, `SymbolTable.read_text`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_5read(PyObject *__pyx_v_cls, PyObject *__pyx_v_filename) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("read (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_4read(((PyTypeObject*)__pyx_v_cls), ((PyObject *)__pyx_v_filename));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_4read(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename) {
+ fst::SymbolTable *__pyx_v_tsyms;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("read", 0);
+
+ /* "pywrapfst.pyx":976
+ * See also: `SymbolTable.read_fst`, `SymbolTable.read_text`.
+ * """
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename)) # <<<<<<<<<<<<<<
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 976, __pyx_L1_error)
+ __pyx_v_tsyms = fst::SymbolTable::Read(__pyx_t_1);
+
+ /* "pywrapfst.pyx":977
+ * """
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename))
+ * if tsyms == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms)
+ */
+ __pyx_t_2 = ((__pyx_v_tsyms == NULL) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":978
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename))
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ * return _init_SymbolTable(tsyms)
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 978, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 978, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":977
+ * """
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename))
+ * if tsyms == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms)
+ */
+ }
+
+ /* "pywrapfst.pyx":979
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms) # <<<<<<<<<<<<<<
+ *
+ * @classmethod
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_tsyms)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 979, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":960
+ *
+ * @classmethod
+ * def read(cls, filename): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read(filename)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.read", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":982
+ *
+ * @classmethod
+ * def read_text(cls, filename, bool allow_negative_labels=False): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read_text(filename)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_7read_text(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11SymbolTable_6read_text[] = "\n SymbolTable.read_text(filename)\n\n Reads symbol table from text file.\n\n This class method creates a new SymbolTable from a symbol table text file.\n\n Args:\n filename: The string location of the input text file.\n allow_negative_labels: Should negative labels be allowed? (Not\n recommended; may cause conflicts).\n\n Returns:\n A new SymbolTable instance.\n\n See also: `SymbolTable.read`, `SymbolTable.read_fst`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_7read_text(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_filename = 0;
+ bool __pyx_v_allow_negative_labels;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("read_text (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_allow_negative_labels,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_negative_labels);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_text") < 0)) __PYX_ERR(0, 982, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_filename = values[0];
+ if (values[1]) {
+ __pyx_v_allow_negative_labels = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_allow_negative_labels == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 982, __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, 982, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.read_text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_6read_text(((PyTypeObject*)__pyx_v_cls), __pyx_v_filename, __pyx_v_allow_negative_labels);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_6read_text(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_allow_negative_labels) {
+ std::unique_ptr<fst::SymbolTableTextOptions> __pyx_v_opts;
+ fst::SymbolTable *__pyx_v_tsyms;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("read_text", 0);
+
+ /* "pywrapfst.pyx":1001
+ * """
+ * cdef unique_ptr[fst.SymbolTableTextOptions] opts
+ * opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels)) # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename),
+ * deref(opts))
+ */
+ __pyx_v_opts.reset(new fst::SymbolTableTextOptions(__pyx_v_allow_negative_labels));
+
+ /* "pywrapfst.pyx":1002
+ * cdef unique_ptr[fst.SymbolTableTextOptions] opts
+ * opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels))
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename), # <<<<<<<<<<<<<<
+ * deref(opts))
+ * if tsyms == NULL:
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1002, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1003
+ * opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels))
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename),
+ * deref(opts)) # <<<<<<<<<<<<<<
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ */
+ __pyx_v_tsyms = fst::SymbolTable::ReadText(__pyx_t_1, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":1004
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename),
+ * deref(opts))
+ * if tsyms == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms)
+ */
+ __pyx_t_2 = ((__pyx_v_tsyms == NULL) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":1005
+ * deref(opts))
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ * return _init_SymbolTable(tsyms)
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 1005, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1004
+ * cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename),
+ * deref(opts))
+ * if tsyms == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms)
+ */
+ }
+
+ /* "pywrapfst.pyx":1006
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms) # <<<<<<<<<<<<<<
+ *
+ * @classmethod
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_tsyms)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1006, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":982
+ *
+ * @classmethod
+ * def read_text(cls, filename, bool allow_negative_labels=False): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read_text(filename)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.read_text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1009
+ *
+ * @classmethod
+ * def read_fst(cls, filename, bool input_table): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read_fst(filename, input_table)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_9read_fst(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11SymbolTable_8read_fst[] = "\n SymbolTable.read_fst(filename, input_table)\n\n Reads symbol table from an FST file without loading the corresponding FST.\n\n This class method creates a new SymbolTable by reading either the input or\n output symbol table from an FST file, without loading the corresponding FST.\n\n Args:\n filename: The string location of the input FST file.\n input_table: Should the input table be read (True) or the output table\n (False)?\n\n Returns:\n A new SymbolTable instance, or None if none can be read.\n\n Raises:\n FstIOError: Read failed.\n\n See also: `SymbolTable.read`, `SymbolTable.read_text`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11SymbolTable_9read_fst(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_filename = 0;
+ bool __pyx_v_input_table;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("read_fst (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_input_table,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_input_table)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("read_fst", 1, 2, 2, 1); __PYX_ERR(0, 1009, __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, 1009, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_filename = values[0];
+ __pyx_v_input_table = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_input_table == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1009, __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, 1009, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.read_fst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11SymbolTable_8read_fst(((PyTypeObject*)__pyx_v_cls), __pyx_v_filename, __pyx_v_input_table);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11SymbolTable_8read_fst(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, bool __pyx_v_input_table) {
+ fst::SymbolTable *__pyx_v_tsyms;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("read_fst", 0);
+
+ /* "pywrapfst.pyx":1031
+ * See also: `SymbolTable.read`, `SymbolTable.read_text`.
+ * """
+ * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table) # <<<<<<<<<<<<<<
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ */
+ __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_filename); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1031, __pyx_L1_error)
+ __pyx_v_tsyms = fst::FstReadSymbols(__pyx_t_1, __pyx_v_input_table);
+
+ /* "pywrapfst.pyx":1032
+ * """
+ * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table)
+ * if tsyms == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms)
+ */
+ __pyx_t_2 = ((__pyx_v_tsyms == NULL) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":1033
+ * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table)
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ * return _init_SymbolTable(tsyms)
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1033, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 1033, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1032
+ * """
+ * cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table)
+ * if tsyms == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms)
+ */
+ }
+
+ /* "pywrapfst.pyx":1034
+ * if tsyms == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * return _init_SymbolTable(tsyms) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(__pyx_v_tsyms)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1034, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1009
+ *
+ * @classmethod
+ * def read_fst(cls, filename, bool input_table): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read_fst(filename, input_table)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst.SymbolTable.read_fst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1037
+ *
+ *
+ * cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable( # <<<<<<<<<<<<<<
+ * fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder):
+ * cdef _EncodeMapperSymbolTable result = (
+ */
+
+static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(fst::SymbolTable *__pyx_v_table, std::shared_ptr<fst::script::EncodeMapperClass> __pyx_v_encoder) {
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_init_EncodeMapperSymbolTable", 0);
+
+ /* "pywrapfst.pyx":1040
+ * fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder):
+ * cdef _EncodeMapperSymbolTable result = (
+ * _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable)) # <<<<<<<<<<<<<<
+ * result._table = table
+ * result._encoder = encoder
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst__EncodeMapperSymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1040, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable)))) __PYX_ERR(0, 1040, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":1041
+ * cdef _EncodeMapperSymbolTable result = (
+ * _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable))
+ * result._table = table # <<<<<<<<<<<<<<
+ * result._encoder = encoder
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1041, __pyx_L1_error)
+ }
+ __pyx_v_result->__pyx_base._table = __pyx_v_table;
+
+ /* "pywrapfst.pyx":1042
+ * _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable))
+ * result._table = table
+ * result._encoder = encoder # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1042, __pyx_L1_error)
+ }
+ __pyx_v_result->_encoder = __pyx_v_encoder;
+
+ /* "pywrapfst.pyx":1043
+ * result._table = table
+ * result._encoder = encoder
+ * return result # <<<<<<<<<<<<<<
+ *
+ * cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table,
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1037
+ *
+ *
+ * cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable( # <<<<<<<<<<<<<<
+ * fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder):
+ * cdef _EncodeMapperSymbolTable result = (
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._init_EncodeMapperSymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1045
+ * return result
+ *
+ * cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<<
+ * shared_ptr[fst.FstClass] ifst):
+ * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable)
+ */
+
+static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst__init_FstSymbolTable(fst::SymbolTable *__pyx_v_table, std::shared_ptr<fst::script::FstClass> __pyx_v_ifst) {
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_init_FstSymbolTable", 0);
+
+ /* "pywrapfst.pyx":1047
+ * cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table,
+ * shared_ptr[fst.FstClass] ifst):
+ * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable) # <<<<<<<<<<<<<<
+ * result._table = table
+ * result._fst = ifst
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst__FstSymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst__FstSymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1047, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst__FstSymbolTable)))) __PYX_ERR(0, 1047, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":1048
+ * shared_ptr[fst.FstClass] ifst):
+ * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable)
+ * result._table = table # <<<<<<<<<<<<<<
+ * result._fst = ifst
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1048, __pyx_L1_error)
+ }
+ __pyx_v_result->__pyx_base._table = __pyx_v_table;
+
+ /* "pywrapfst.pyx":1049
+ * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable)
+ * result._table = table
+ * result._fst = ifst # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1049, __pyx_L1_error)
+ }
+ __pyx_v_result->_fst = __pyx_v_ifst;
+
+ /* "pywrapfst.pyx":1050
+ * result._table = table
+ * result._fst = ifst
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1045
+ * return result
+ *
+ * cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<<
+ * shared_ptr[fst.FstClass] ifst):
+ * cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._init_FstSymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1053
+ *
+ *
+ * cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<<
+ * shared_ptr[fst.MutableFstClass] ifst):
+ * cdef _MutableFstSymbolTable result = (
+ */
+
+static struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_f_9pywrapfst__init_MutableFstSymbolTable(fst::SymbolTable *__pyx_v_table, std::shared_ptr<fst::script::MutableFstClass> __pyx_v_ifst) {
+ struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_init_MutableFstSymbolTable", 0);
+
+ /* "pywrapfst.pyx":1056
+ * shared_ptr[fst.MutableFstClass] ifst):
+ * cdef _MutableFstSymbolTable result = (
+ * _MutableFstSymbolTable.__new__(_MutableFstSymbolTable)) # <<<<<<<<<<<<<<
+ * result._table = table
+ * result._mfst = ifst
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst__MutableFstSymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst__MutableFstSymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1056, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst__MutableFstSymbolTable)))) __PYX_ERR(0, 1056, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":1057
+ * cdef _MutableFstSymbolTable result = (
+ * _MutableFstSymbolTable.__new__(_MutableFstSymbolTable))
+ * result._table = table # <<<<<<<<<<<<<<
+ * result._mfst = ifst
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1057, __pyx_L1_error)
+ }
+ __pyx_v_result->__pyx_base.__pyx_base._table = __pyx_v_table;
+
+ /* "pywrapfst.pyx":1058
+ * _MutableFstSymbolTable.__new__(_MutableFstSymbolTable))
+ * result._table = table
+ * result._mfst = ifst # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1058, __pyx_L1_error)
+ }
+ __pyx_v_result->_mfst = __pyx_v_ifst;
+
+ /* "pywrapfst.pyx":1059
+ * result._table = table
+ * result._mfst = ifst
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1053
+ *
+ *
+ * cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table, # <<<<<<<<<<<<<<
+ * shared_ptr[fst.MutableFstClass] ifst):
+ * cdef _MutableFstSymbolTable result = (
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._init_MutableFstSymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1062
+ *
+ *
+ * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table): # <<<<<<<<<<<<<<
+ * cdef SymbolTable result = SymbolTable.__new__(SymbolTable)
+ * result._table = table
+ */
+
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst__init_SymbolTable(fst::SymbolTable *__pyx_v_table) {
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_result = 0;
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("_init_SymbolTable", 0);
+
+ /* "pywrapfst.pyx":1063
+ *
+ * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table):
+ * cdef SymbolTable result = SymbolTable.__new__(SymbolTable) # <<<<<<<<<<<<<<
+ * result._table = table
+ * return result
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_SymbolTable(((PyTypeObject *)__pyx_ptype_9pywrapfst_SymbolTable), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1063, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_SymbolTable)))) __PYX_ERR(0, 1063, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_SymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":1064
+ * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table):
+ * cdef SymbolTable result = SymbolTable.__new__(SymbolTable)
+ * result._table = table # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1064, __pyx_L1_error)
+ }
+ __pyx_v_result->__pyx_base.__pyx_base._table = __pyx_v_table;
+
+ /* "pywrapfst.pyx":1065
+ * cdef SymbolTable result = SymbolTable.__new__(SymbolTable)
+ * result._table = table
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1062
+ *
+ *
+ * cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table): # <<<<<<<<<<<<<<
+ * cdef SymbolTable result = SymbolTable.__new__(SymbolTable)
+ * result._table = table
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._init_SymbolTable", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1071
+ *
+ *
+ * cpdef SymbolTable compact_symbol_table(_SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * compact_symbol_table(syms)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_syms); /*proto*/
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_compact_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, CYTHON_UNUSED int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("compact_symbol_table", 0);
+
+ /* "pywrapfst.pyx":1083
+ * A new compacted SymbolTable.
+ * """
+ * return _init_SymbolTable(fst.CompactSymbolTable(deref(syms._table))) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1083, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::CompactSymbolTable((*__pyx_v_syms->_table)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1083, __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":1071
+ *
+ *
+ * cpdef SymbolTable compact_symbol_table(_SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * compact_symbol_table(syms)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.compact_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_syms); /*proto*/
+static char __pyx_doc_9pywrapfst_8compact_symbol_table[] = "\n compact_symbol_table(syms)\n\n Constructively relabels a SymbolTable to make it a contiguous mapping.\n\n Args:\n syms: Input SymbolTable.\n\n Returns:\n A new compacted SymbolTable.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9compact_symbol_table(PyObject *__pyx_self, PyObject *__pyx_v_syms) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("compact_symbol_table (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1071, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_8compact_symbol_table(__pyx_self, ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_8compact_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("compact_symbol_table", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_compact_symbol_table(__pyx_v_syms, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1071, __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":1086
+ *
+ *
+ * cpdef SymbolTable merge_symbol_table(_SymbolTable lhs, _SymbolTable rhs): # <<<<<<<<<<<<<<
+ * """
+ * merge_symbol_table(lhs, rhs)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_f_9pywrapfst_merge_symbol_table(struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs, CYTHON_UNUSED int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("merge_symbol_table", 0);
+
+ /* "pywrapfst.pyx":1110
+ * See also: `relabel_symbols`.
+ * """
+ * return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table), # <<<<<<<<<<<<<<
+ * deref(rhs._table), NULL))
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ if (unlikely(((PyObject *)__pyx_v_lhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1110, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1111
+ * """
+ * return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table),
+ * deref(rhs._table), NULL)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_rhs) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1111, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1110
+ * See also: `relabel_symbols`.
+ * """
+ * return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table), # <<<<<<<<<<<<<<
+ * deref(rhs._table), NULL))
+ *
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_SymbolTable(fst::MergeSymbolTable((*__pyx_v_lhs->_table), (*__pyx_v_rhs->_table), NULL))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1110, __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":1086
+ *
+ *
+ * cpdef SymbolTable merge_symbol_table(_SymbolTable lhs, _SymbolTable rhs): # <<<<<<<<<<<<<<
+ * """
+ * merge_symbol_table(lhs, rhs)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.merge_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_10merge_symbol_table[] = "\n merge_symbol_table(lhs, rhs)\n\n Merges all symbols from the left table into the right.\n\n This function creates a new SymbolTable which is the merger of the two input\n symbol Tables. Symbols in the right-hand table that conflict with those in the\n left-hand table will be assigned values from the left-hand table. Thus the\n returned table will never modify symbol assignments from the left-hand side,\n but may do so on the right.\n\n If the left-hand table is associated with an FST, it may be necessary to\n relabel it using the output table.\n\n Args:\n lhs: Left-hand side SymbolTable.\n rhs: Left-hand side SymbolTable.\n\n Returns:\n A new merged SymbolTable.\n\n See also: `relabel_symbols`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11merge_symbol_table(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs = 0;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("merge_symbol_table (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lhs,&__pyx_n_s_rhs,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lhs)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("merge_symbol_table", 1, 2, 2, 1); __PYX_ERR(0, 1086, __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, 1086, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_lhs = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]);
+ __pyx_v_rhs = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]);
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("merge_symbol_table", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1086, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.merge_symbol_table", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lhs), __pyx_ptype_9pywrapfst__SymbolTable, 1, "lhs", 0))) __PYX_ERR(0, 1086, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_rhs), __pyx_ptype_9pywrapfst__SymbolTable, 1, "rhs", 0))) __PYX_ERR(0, 1086, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_10merge_symbol_table(__pyx_self, __pyx_v_lhs, __pyx_v_rhs);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_10merge_symbol_table(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_lhs, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_rhs) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("merge_symbol_table", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_merge_symbol_table(__pyx_v_lhs, __pyx_v_rhs, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1086, __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":1128
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<SymbolTableIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator___repr__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator___repr__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":1129
+ *
+ * def __repr__(self):
+ * return "<SymbolTableIterator at 0x{:x}>".format(id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self, _SymbolTable syms):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_SymbolTableIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_3)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_3) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1129, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1128
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<SymbolTableIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1131
+ * return "<SymbolTableIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * self._siter.reset(new fst.SymbolTableIterator(deref(syms._table)))
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_19SymbolTableIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_19SymbolTableIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms = 0;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_syms,0};
+ PyObject* values[1] = {0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_syms)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1131, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ }
+ __pyx_v_syms = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]);
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1131, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1131, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_2__init__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self), __pyx_v_syms);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_19SymbolTableIterator_2__init__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":1132
+ *
+ * def __init__(self, _SymbolTable syms):
+ * self._siter.reset(new fst.SymbolTableIterator(deref(syms._table))) # <<<<<<<<<<<<<<
+ *
+ * # This just registers this class as a possible iterator.
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_siter");
+ __PYX_ERR(0, 1132, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1132, __pyx_L1_error)
+ }
+ __pyx_v_self->_siter.reset(new fst::SymbolTableIterator((*__pyx_v_syms->_table)));
+
+ /* "pywrapfst.pyx":1131
+ * return "<SymbolTableIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * self._siter.reset(new fst.SymbolTableIterator(deref(syms._table)))
+ *
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1135
+ *
+ * # This just registers this class as a possible iterator.
+ * def __iter__(self): # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_5__iter__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_5__iter__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_4__iter__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_4__iter__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__iter__", 0);
+
+ /* "pywrapfst.pyx":1136
+ * # 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":1135
+ *
+ * # 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":1139
+ *
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self): # <<<<<<<<<<<<<<
+ * if self.done():
+ * raise StopIteration
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_6__next__(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_6__next__(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ __pyx_t_10basictypes_int64 __pyx_v_value;
+ std::string __pyx_v_symbol;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("__next__", 0);
+
+ /* "pywrapfst.pyx":1140
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self):
+ * if self.done(): # <<<<<<<<<<<<<<
+ * raise StopIteration
+ * cdef int64 value = self.value()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "done");
+ __PYX_ERR(0, 1140, __pyx_L1_error)
+ }
+ __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":1141
+ * def __next__(self):
+ * if self.done():
+ * raise StopIteration # <<<<<<<<<<<<<<
+ * cdef int64 value = self.value()
+ * cdef string symbol = self.symbol()
+ */
+ __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0);
+ __PYX_ERR(0, 1141, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1140
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self):
+ * if self.done(): # <<<<<<<<<<<<<<
+ * raise StopIteration
+ * cdef int64 value = self.value()
+ */
+ }
+
+ /* "pywrapfst.pyx":1142
+ * if self.done():
+ * raise StopIteration
+ * cdef int64 value = self.value() # <<<<<<<<<<<<<<
+ * cdef string symbol = self.symbol()
+ * self.next()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "value");
+ __PYX_ERR(0, 1142, __pyx_L1_error)
+ }
+ __pyx_v_value = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->value(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":1143
+ * raise StopIteration
+ * cdef int64 value = self.value()
+ * cdef string symbol = self.symbol() # <<<<<<<<<<<<<<
+ * self.next()
+ * return (value, symbol)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "symbol");
+ __PYX_ERR(0, 1143, __pyx_L1_error)
+ }
+ __pyx_v_symbol = ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->symbol(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":1144
+ * cdef int64 value = self.value()
+ * cdef string symbol = self.symbol()
+ * self.next() # <<<<<<<<<<<<<<
+ * return (value, symbol)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "next");
+ __PYX_ERR(0, 1144, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":1145
+ * cdef string symbol = self.symbol()
+ * self.next()
+ * return (value, symbol) # <<<<<<<<<<<<<<
+ *
+ * cpdef bool done(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1145, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_symbol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1145, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1145, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3);
+ __pyx_t_2 = 0;
+ __pyx_t_3 = 0;
+ __pyx_r = __pyx_t_4;
+ __pyx_t_4 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1139
+ *
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self): # <<<<<<<<<<<<<<
+ * if self.done():
+ * raise StopIteration
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1147
+ * return (value, symbol)
+ *
+ * cpdef bool done(self): # <<<<<<<<<<<<<<
+ * """
+ * done(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_19SymbolTableIterator_done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("done", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_9done)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1147, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1147, __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, 1147, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1159
+ * 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 '%s'", "_siter");
+ __PYX_ERR(0, 1159, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_siter.get()->Done();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1147
+ * return (value, symbol)
+ *
+ * cpdef bool done(self): # <<<<<<<<<<<<<<
+ * """
+ * done(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_19SymbolTableIterator_8done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("done (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_8done(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_8done(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("done", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_19SymbolTableIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1161
+ * return self._siter.get().Done()
+ *
+ * cpdef void next(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_19SymbolTableIterator_next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1161, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_11next)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1161, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1161, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1170
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_siter");
+ __PYX_ERR(0, 1170, __pyx_L1_error)
+ }
+ __pyx_v_self->_siter.get()->Next();
+
+ /* "pywrapfst.pyx":1161
+ * return self._siter.get().Done()
+ *
+ * cpdef void next(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_19SymbolTableIterator_10next[] = "\n next(self)\n\n Advances the iterator.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("next (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_10next(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_10next(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_19SymbolTableIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1161, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.next", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1172
+ * self._siter.get().Next()
+ *
+ * cpdef void reset(self): # <<<<<<<<<<<<<<
+ * """
+ * reset(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_19SymbolTableIterator_reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1172, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1172, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1172, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1181
+ * should use the Pythonic API.
+ * """
+ * self._siter.get().Reset() # <<<<<<<<<<<<<<
+ *
+ * cpdef string symbol(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_siter");
+ __PYX_ERR(0, 1181, __pyx_L1_error)
+ }
+ __pyx_v_self->_siter.get()->Reset();
+
+ /* "pywrapfst.pyx":1172
+ * self._siter.get().Next()
+ *
+ * cpdef void reset(self): # <<<<<<<<<<<<<<
+ * """
+ * reset(self)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_19SymbolTableIterator_12reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reset (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_12reset(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_12reset(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_19SymbolTableIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1172, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.reset", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1183
+ * self._siter.get().Reset()
+ *
+ * cpdef string symbol(self): # <<<<<<<<<<<<<<
+ * """
+ * symbol(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_19SymbolTableIterator_symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("symbol", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_symbol); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1183, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1183, __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, 1183, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1197
+ * A symbol string.
+ * """
+ * return self._siter.get().Symbol() # <<<<<<<<<<<<<<
+ *
+ * cpdef int64 value(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_siter");
+ __PYX_ERR(0, 1197, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_siter.get()->Symbol();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1183
+ * self._siter.get().Reset()
+ *
+ * cpdef string symbol(self): # <<<<<<<<<<<<<<
+ * """
+ * symbol(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.symbol", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_19SymbolTableIterator_14symbol[] = "\n symbol(self)\n\n Returns the current symbol string.\n\n This method returns the current symbol string at this point in the table.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n A symbol string.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("symbol (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_14symbol(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_14symbol(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("symbol", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_19SymbolTableIterator_symbol(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.symbol", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1199
+ * return self._siter.get().Symbol()
+ *
+ * cpdef int64 value(self): # <<<<<<<<<<<<<<
+ * """
+ * value(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_17value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_19SymbolTableIterator_value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_5;
+ __Pyx_RefNannySetupContext("value", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1199, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_17value)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1199, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1199, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1199, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1211
+ * An integer index.
+ * """
+ * return self._siter.get().Value() # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_siter");
+ __PYX_ERR(0, 1211, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_siter.get()->Value();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1199
+ * return self._siter.get().Symbol()
+ *
+ * cpdef int64 value(self): # <<<<<<<<<<<<<<
+ * """
+ * value(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst.SymbolTableIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_17value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_19SymbolTableIterator_16value[] = "\n value(self)\n\n Returns the current integer index of the symbol.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n An integer index.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19SymbolTableIterator_17value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("value (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_19SymbolTableIterator_16value(((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_19SymbolTableIterator_16value(struct __pyx_obj_9pywrapfst_SymbolTableIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("value", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_19SymbolTableIterator_value(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1199, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.SymbolTableIterator.value", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1240
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<EncodeMapper at 0x{:x}>".format(id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper___repr__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper___repr__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":1241
+ *
+ * def __repr__(self):
+ * return "<EncodeMapper at 0x{:x}>".format(id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self,
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_EncodeMapper_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_3)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_3) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1241, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1240
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<EncodeMapper at 0x{:x}>".format(id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1243
+ * return "<EncodeMapper at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, # <<<<<<<<<<<<<<
+ * arc_type=b"standard",
+ * bool encode_labels=False,
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_12EncodeMapper_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_12EncodeMapper_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_arc_type = 0;
+ bool __pyx_v_encode_labels;
+ bool __pyx_v_encode_weights;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arc_type,&__pyx_n_s_encode_labels,&__pyx_n_s_encode_weights,0};
+ PyObject* values[3] = {0,0,0};
+ values[0] = ((PyObject *)__pyx_n_b_standard);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encode_labels);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_encode_weights);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1243, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 1245, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":1245
+ * def __init__(self,
+ * arc_type=b"standard",
+ * bool encode_labels=False, # <<<<<<<<<<<<<<
+ * bool encode_weights=False):
+ * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights)
+ */
+ __pyx_v_encode_labels = ((bool)0);
+ }
+ if (values[2]) {
+ __pyx_v_encode_weights = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_encode_weights == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1246, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":1246
+ * arc_type=b"standard",
+ * bool encode_labels=False,
+ * bool encode_weights=False): # <<<<<<<<<<<<<<
+ * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights)
+ * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags,
+ */
+ __pyx_v_encode_weights = ((bool)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1243, __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":1243
+ * return "<EncodeMapper at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, # <<<<<<<<<<<<<<
+ * arc_type=b"standard",
+ * bool encode_labels=False,
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_12EncodeMapper_2__init__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, PyObject *__pyx_v_arc_type, bool __pyx_v_encode_labels, bool __pyx_v_encode_weights) {
+ __pyx_t_10basictypes_uint32 __pyx_v_flags;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":1247
+ * bool encode_labels=False,
+ * bool encode_weights=False):
+ * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights) # <<<<<<<<<<<<<<
+ * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags,
+ * fst.ENCODE))
+ */
+ __pyx_v_flags = fst::script::GetEncodeFlags(__pyx_v_encode_labels, __pyx_v_encode_weights);
+
+ /* "pywrapfst.pyx":1248
+ * bool encode_weights=False):
+ * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights)
+ * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags, # <<<<<<<<<<<<<<
+ * fst.ENCODE))
+ * if not self._encoder:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1248, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1248, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1249
+ * cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights)
+ * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags,
+ * fst.ENCODE)) # <<<<<<<<<<<<<<
+ * if not self._encoder:
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ */
+ __pyx_v_self->_encoder.reset(new fst::script::EncodeMapperClass(__pyx_t_1, __pyx_v_flags, fst::ENCODE));
+
+ /* "pywrapfst.pyx":1250
+ * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags,
+ * fst.ENCODE))
+ * if not self._encoder: # <<<<<<<<<<<<<<
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1250, __pyx_L1_error)
+ }
+ __pyx_t_2 = ((!__pyx_v_self->_encoder) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":1251
+ * fst.ENCODE))
+ * if not self._encoder:
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) # <<<<<<<<<<<<<<
+ *
+ * cpdef string arc_type(self):
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_arc_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_arc_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_arc_type);
+ __Pyx_GIVEREF(__pyx_v_arc_type);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_arc_type);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1251, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 1251, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1250
+ * self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags,
+ * fst.ENCODE))
+ * if not self._encoder: # <<<<<<<<<<<<<<
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ *
+ */
+ }
+
+ /* "pywrapfst.pyx":1243
+ * return "<EncodeMapper at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, # <<<<<<<<<<<<<<
+ * arc_type=b"standard",
+ * bool encode_labels=False,
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1253
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._encoder.get().ArcType()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_12EncodeMapper_arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1253, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1253, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1253, __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, 1253, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1254
+ *
+ * cpdef string arc_type(self):
+ * return self._encoder.get().ArcType() # <<<<<<<<<<<<<<
+ *
+ * # Python's equivalent to operator().
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1254, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_encoder.get()->ArcType();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1253
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._encoder.get().ArcType()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("arc_type (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_4arc_type(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_4arc_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12EncodeMapper_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1253, __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":1258
+ * # Python's equivalent to operator().
+ *
+ * def __call__(self, Arc arc): # <<<<<<<<<<<<<<
+ * """
+ * self(state, ilabel, olabel, weight, nextstate)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_7__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_12EncodeMapper_6__call__[] = "\n self(state, ilabel, olabel, weight, nextstate)\n\n Uses the encoder to encode an arc.\n\n Args:\n ilabel: The integer index of the input label.\n olabel: The integer index of the output label.\n weight: A Weight or weight string indicating the desired final weight; if\n null, it is set to semiring One.\n nextstate: The integer index of the destination state.\n\n Raises:\n FstOpError: Incompatible or invalid weight.\n ";
+#if CYTHON_COMPILING_IN_CPYTHON
+struct wrapperbase __pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__;
+#endif
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_7__call__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__call__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arc,0};
+ PyObject* values[1] = {0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) __PYX_ERR(0, 1258, __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, 1258, __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, 1258, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_6__call__(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), __pyx_v_arc);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_6__call__(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__call__", 0);
+
+ /* "pywrapfst.pyx":1274
+ * FstOpError: Incompatible or invalid weight.
+ * """
+ * return _init_Arc(self._encoder.get().__call__(deref(arc._arc))) # <<<<<<<<<<<<<<
+ *
+ * cpdef uint32 flags(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1274, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_arc) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc");
+ __PYX_ERR(0, 1274, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_Arc(__pyx_v_self->_encoder.get()->operator()((*__pyx_v_arc->_arc)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1274, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1258
+ * # 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":1276
+ * return _init_Arc(self._encoder.get().__call__(deref(arc._arc)))
+ *
+ * cpdef uint32 flags(self): # <<<<<<<<<<<<<<
+ * return self._encoder.get().Flags()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_9flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_12EncodeMapper_flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_uint32 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_uint32 __pyx_t_5;
+ __Pyx_RefNannySetupContext("flags", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1276, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_9flags)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1276, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1276, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1276, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1277
+ *
+ * cpdef uint32 flags(self):
+ * return self._encoder.get().Flags() # <<<<<<<<<<<<<<
+ *
+ * cpdef _EncodeMapperSymbolTable input_symbols(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1277, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_encoder.get()->Flags();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1276
+ * return _init_Arc(self._encoder.get().__call__(deref(arc._arc)))
+ *
+ * cpdef uint32 flags(self): # <<<<<<<<<<<<<<
+ * return self._encoder.get().Flags()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_9flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_9flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("flags (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_8flags(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_8flags(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("flags", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_f_9pywrapfst_12EncodeMapper_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1276, __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":1279
+ * return self._encoder.get().Flags()
+ *
+ * cpdef _EncodeMapperSymbolTable input_symbols(self): # <<<<<<<<<<<<<<
+ * if self._encoder.get().InputSymbols() == NULL:
+ * return
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_t_5;
+ __Pyx_RefNannySetupContext("input_symbols", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1279, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1279, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1279, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable))))) __PYX_ERR(0, 1279, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1280
+ *
+ * cpdef _EncodeMapperSymbolTable input_symbols(self):
+ * if self._encoder.get().InputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1280, __pyx_L1_error)
+ }
+ __pyx_t_5 = ((__pyx_v_self->_encoder.get()->InputSymbols() == NULL) != 0);
+ if (__pyx_t_5) {
+
+ /* "pywrapfst.pyx":1281
+ * cpdef _EncodeMapperSymbolTable input_symbols(self):
+ * if self._encoder.get().InputSymbols() == NULL:
+ * return # <<<<<<<<<<<<<<
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ * self._encoder.get().InputSymbols()), self._encoder)
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)Py_None); __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1280
+ *
+ * cpdef _EncodeMapperSymbolTable input_symbols(self):
+ * if self._encoder.get().InputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ }
+
+ /* "pywrapfst.pyx":1282
+ * if self._encoder.get().InputSymbols() == NULL:
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._encoder.get().InputSymbols()), self._encoder)
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+
+ /* "pywrapfst.pyx":1283
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ * self._encoder.get().InputSymbols()), self._encoder) # <<<<<<<<<<<<<<
+ *
+ * cpdef _EncodeMapperSymbolTable output_symbols(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1283, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1282
+ * if self._encoder.get().InputSymbols() == NULL:
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._encoder.get().InputSymbols()), self._encoder)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1283, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1283
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ * self._encoder.get().InputSymbols()), self._encoder) # <<<<<<<<<<<<<<
+ *
+ * cpdef _EncodeMapperSymbolTable output_symbols(self):
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_encoder.get()->InputSymbols()), __pyx_v_self->_encoder)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1282, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1279
+ * return self._encoder.get().Flags()
+ *
+ * cpdef _EncodeMapperSymbolTable input_symbols(self): # <<<<<<<<<<<<<<
+ * if self._encoder.get().InputSymbols() == NULL:
+ * return
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("input_symbols (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_10input_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_10input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("input_symbols", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_12EncodeMapper_input_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1279, __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":1285
+ * self._encoder.get().InputSymbols()), self._encoder)
+ *
+ * cpdef _EncodeMapperSymbolTable output_symbols(self): # <<<<<<<<<<<<<<
+ * if self._encoder.get().OutputSymbols() == NULL:
+ * return
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_t_5;
+ __Pyx_RefNannySetupContext("output_symbols", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1285, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1285, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1285, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable))))) __PYX_ERR(0, 1285, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1286
+ *
+ * cpdef _EncodeMapperSymbolTable output_symbols(self):
+ * if self._encoder.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1286, __pyx_L1_error)
+ }
+ __pyx_t_5 = ((__pyx_v_self->_encoder.get()->OutputSymbols() == NULL) != 0);
+ if (__pyx_t_5) {
+
+ /* "pywrapfst.pyx":1287
+ * cpdef _EncodeMapperSymbolTable output_symbols(self):
+ * if self._encoder.get().OutputSymbols() == NULL:
+ * return # <<<<<<<<<<<<<<
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ * self._encoder.get().OutputSymbols()), self._encoder)
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)Py_None); __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1286
+ *
+ * cpdef _EncodeMapperSymbolTable output_symbols(self):
+ * if self._encoder.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ }
+
+ /* "pywrapfst.pyx":1288
+ * if self._encoder.get().OutputSymbols() == NULL:
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._encoder.get().OutputSymbols()), self._encoder)
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+
+ /* "pywrapfst.pyx":1289
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ * self._encoder.get().OutputSymbols()), self._encoder) # <<<<<<<<<<<<<<
+ *
+ * cpdef uint64 properties(self, uint64 mask):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1289, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1288
+ * if self._encoder.get().OutputSymbols() == NULL:
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._encoder.get().OutputSymbols()), self._encoder)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1289, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1289
+ * return
+ * return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ * self._encoder.get().OutputSymbols()), self._encoder) # <<<<<<<<<<<<<<
+ *
+ * cpdef uint64 properties(self, uint64 mask):
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable(const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_encoder.get()->OutputSymbols()), __pyx_v_self->_encoder)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1288, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1285
+ * self._encoder.get().InputSymbols()), self._encoder)
+ *
+ * cpdef _EncodeMapperSymbolTable output_symbols(self): # <<<<<<<<<<<<<<
+ * if self._encoder.get().OutputSymbols() == NULL:
+ * return
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("output_symbols (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_12output_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_12output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("output_symbols", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_12EncodeMapper_output_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1285, __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":1291
+ * self._encoder.get().OutputSymbols()), self._encoder)
+ *
+ * cpdef uint64 properties(self, uint64 mask): # <<<<<<<<<<<<<<
+ * """
+ * properties(self, mask)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_15properties(PyObject *__pyx_v_self, PyObject *__pyx_arg_mask); /*proto*/
+static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_12EncodeMapper_properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_uint64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __pyx_t_10basictypes_uint64 __pyx_t_7;
+ __Pyx_RefNannySetupContext("properties", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_15properties)) {
+ __pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_7 = __Pyx_PyInt_As_uint64_t(__pyx_t_2); if (unlikely((__pyx_t_7 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_7;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1307
+ * A 64-bit bitmask representing the requested properties.
+ * """
+ * return self._encoder.get().Properties(mask) # <<<<<<<<<<<<<<
+ *
+ * cpdef void set_input_symbols(self, _SymbolTable syms) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1307, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_encoder.get()->Properties(__pyx_v_mask);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1291
+ * self._encoder.get().OutputSymbols()), self._encoder)
+ *
+ * cpdef uint64 properties(self, uint64 mask): # <<<<<<<<<<<<<<
+ * """
+ * properties(self, mask)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_WriteUnraisable("pywrapfst.EncodeMapper.properties", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_15properties(PyObject *__pyx_v_self, PyObject *__pyx_arg_mask); /*proto*/
+static char __pyx_doc_9pywrapfst_12EncodeMapper_14properties[] = "\n properties(self, mask)\n\n Provides property bits.\n\n This method provides user access to the properties attributes for the\n encoder. The resulting value is a long integer, but when it is cast to a\n boolean, it represents whether or not the FST has the `mask` property.\n\n Args:\n mask: The property mask to be compared to the encoder's properties.\n\n Returns:\n A 64-bit bitmask representing the requested properties.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_15properties(PyObject *__pyx_v_self, PyObject *__pyx_arg_mask) {
+ __pyx_t_10basictypes_uint64 __pyx_v_mask;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("properties (wrapper)", 0);
+ assert(__pyx_arg_mask); {
+ __pyx_v_mask = __Pyx_PyInt_As_uint64_t(__pyx_arg_mask); if (unlikely((__pyx_v_mask == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1291, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.properties", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_14properties(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((__pyx_t_10basictypes_uint64)__pyx_v_mask));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_14properties(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("properties", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_f_9pywrapfst_12EncodeMapper_properties(__pyx_v_self, __pyx_v_mask, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1291, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.properties", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1309
+ * return self._encoder.get().Properties(mask)
+ *
+ * cpdef void set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * """
+ * set_input_symbols(self, syms)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static void __pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("set_input_symbols", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_syms)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(((PyObject *)__pyx_v_syms));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_syms));
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_syms));
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1320
+ * See also: `set_output_symbols`.
+ * """
+ * self._encoder.get().SetInputSymbols(syms._table) # <<<<<<<<<<<<<<
+ *
+ * cpdef void set_output_symbols(self, _SymbolTable syms) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1320, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1320, __pyx_L1_error)
+ }
+ __pyx_v_self->_encoder.get()->SetInputSymbols(__pyx_v_syms->_table);
+
+ /* "pywrapfst.pyx":1309
+ * return self._encoder.get().Properties(mask)
+ *
+ * cpdef void set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * """
+ * set_input_symbols(self, syms)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static char __pyx_doc_9pywrapfst_12EncodeMapper_16set_input_symbols[] = "\n set_input_symbols(self, syms)\n\n Sets the input symbol table.\n\n Args:\n syms: A SymbolTable.\n\n See also: `set_output_symbols`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_input_symbols (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_16set_input_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_16set_input_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("set_input_symbols", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols(__pyx_v_self, __pyx_v_syms, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1309, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1322
+ * self._encoder.get().SetInputSymbols(syms._table)
+ *
+ * cpdef void set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * """
+ * set_output_symbols(self, syms)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static void __pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("set_output_symbols", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_syms)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_syms)};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(((PyObject *)__pyx_v_syms));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_syms));
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_syms));
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1333
+ * See also: `set_input_symbols`.
+ * """
+ * self._encoder.get().SetOutputSymbols(syms._table) # <<<<<<<<<<<<<<
+ *
+ * cpdef string weight_type(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1333, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1333, __pyx_L1_error)
+ }
+ __pyx_v_self->_encoder.get()->SetOutputSymbols(__pyx_v_syms->_table);
+
+ /* "pywrapfst.pyx":1322
+ * self._encoder.get().SetInputSymbols(syms._table)
+ *
+ * cpdef void set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * """
+ * set_output_symbols(self, syms)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static char __pyx_doc_9pywrapfst_12EncodeMapper_18set_output_symbols[] = "\n set_output_symbols(self, syms)\n\n Sets the output symbol table.\n\n Args:\n syms: A SymbolTable.\n\n See also: `set_input_symbols`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_output_symbols (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_18set_output_symbols(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_18set_output_symbols(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("set_output_symbols", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols(__pyx_v_self, __pyx_v_syms, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1322, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.EncodeMapper.set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1335
+ * self._encoder.get().SetOutputSymbols(syms._table)
+ *
+ * cpdef string weight_type(self): # <<<<<<<<<<<<<<
+ * return self._encoder.get().WeightType()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_12EncodeMapper_weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("weight_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1335, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1335, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1335, __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, 1335, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1336
+ *
+ * cpdef string weight_type(self):
+ * return self._encoder.get().WeightType() # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1336, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_encoder.get()->WeightType();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1335
+ * self._encoder.get().SetOutputSymbols(syms._table)
+ *
+ * cpdef string weight_type(self): # <<<<<<<<<<<<<<
+ * return self._encoder.get().WeightType()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("weight_type (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_12EncodeMapper_20weight_type(((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12EncodeMapper_20weight_type(struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("weight_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_12EncodeMapper_weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1335, __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":1360
+ *
+ * # IPython notebook magic to produce an SVG of the FST.
+ * def _repr_svg_(self): # <<<<<<<<<<<<<<
+ * """IPython notebook magic to produce an SVG of the FST using GraphViz.
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_1_repr_svg_(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst__repr_svg_[] = "IPython notebook magic to produce an SVG of the FST using GraphViz.\n\n This method produces an SVG of the internal graph. Users wishing to create\n publication-quality graphs should instead use the method `draw`, which\n exposes additional parameters.\n\n Raises:\n OSError: Cannot locate the `dot` executable.\n subprocess.CalledProcessError: `dot` returned non-zero exit code.\n\n See also: `draw`, `text`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_1_repr_svg_(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_repr_svg_ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst__repr_svg_(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst__repr_svg_(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_v_proc = NULL;
+ std::stringstream __pyx_v_sstrm;
+ PyObject *__pyx_v_sout = NULL;
+ CYTHON_UNUSED PyObject *__pyx_v_serr = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ std::string __pyx_t_6;
+ std::string __pyx_t_7;
+ PyObject *(*__pyx_t_8)(PyObject *);
+ int __pyx_t_9;
+ int __pyx_t_10;
+ PyObject *__pyx_t_11 = NULL;
+ __Pyx_RefNannySetupContext("_repr_svg_", 0);
+
+ /* "pywrapfst.pyx":1374
+ * """
+ * # Throws OSError if the dot executable is not found.
+ * proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE, # <<<<<<<<<<<<<<
+ * stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ * cdef stringstream sstrm
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1374, __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, 1374, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(__pyx_n_s_dot);
+ __Pyx_GIVEREF(__pyx_n_s_dot);
+ PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_dot);
+ __Pyx_INCREF(__pyx_kp_s_Tsvg);
+ __Pyx_GIVEREF(__pyx_kp_s_Tsvg);
+ PyList_SET_ITEM(__pyx_t_1, 1, __pyx_kp_s_Tsvg);
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+ __pyx_t_1 = 0;
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stdin, __pyx_t_5) < 0) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+ /* "pywrapfst.pyx":1375
+ * # Throws OSError if the dot executable is not found.
+ * proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE,
+ * stdout=subprocess.PIPE, stderr=subprocess.PIPE) # <<<<<<<<<<<<<<
+ * cdef stringstream sstrm
+ * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(),
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1375, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1375, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stdout, __pyx_t_4) < 0) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1375, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_PIPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1375, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_stderr, __pyx_t_5) < 0) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+ /* "pywrapfst.pyx":1374
+ * """
+ * # Throws OSError if the dot executable is not found.
+ * proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE, # <<<<<<<<<<<<<<
+ * stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ * cdef stringstream sstrm
+ */
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1374, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_v_proc = __pyx_t_5;
+ __pyx_t_5 = 0;
+
+ /* "pywrapfst.pyx":1377
+ * stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ * cdef stringstream sstrm
+ * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), # <<<<<<<<<<<<<<
+ * self._fst.get().OutputSymbols(), NULL,
+ * self._fst.get().Properties(fst.kAcceptor, True) ==
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1377, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1377, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1378
+ * cdef stringstream sstrm
+ * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(),
+ * self._fst.get().OutputSymbols(), NULL, # <<<<<<<<<<<<<<
+ * self._fst.get().Properties(fst.kAcceptor, True) ==
+ * fst.kAcceptor,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1378, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1379
+ * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(),
+ * self._fst.get().OutputSymbols(), NULL,
+ * self._fst.get().Properties(fst.kAcceptor, True) == # <<<<<<<<<<<<<<
+ * fst.kAcceptor,
+ * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, False,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1379, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1381
+ * self._fst.get().Properties(fst.kAcceptor, True) ==
+ * fst.kAcceptor,
+ * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, False, # <<<<<<<<<<<<<<
+ * addr(sstrm), b"_repr_svg")
+ * (sout, serr) = proc.communicate(sstrm.str())
+ */
+ __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b_); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1381, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1382
+ * fst.kAcceptor,
+ * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, False,
+ * addr(sstrm), b"_repr_svg") # <<<<<<<<<<<<<<
+ * (sout, serr) = proc.communicate(sstrm.str())
+ * if proc.returncode != 0: # Just to be explicit.
+ */
+ __pyx_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_repr_svg); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1382, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1377
+ * stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ * cdef stringstream sstrm
+ * fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(), # <<<<<<<<<<<<<<
+ * self._fst.get().OutputSymbols(), NULL,
+ * self._fst.get().Properties(fst.kAcceptor, True) ==
+ */
+ fst::script::DrawFst((*__pyx_v_self->_fst), __pyx_v_self->_fst.get()->InputSymbols(), __pyx_v_self->_fst.get()->OutputSymbols(), NULL, (__pyx_v_self->_fst.get()->Properties(fst::kAcceptor, 1) == fst::kAcceptor), __pyx_t_6, 8.5, 11.0, 1, 0, 0.4, 0.25, 14, 5, 0, (&__pyx_v_sstrm), __pyx_t_7);
+
+ /* "pywrapfst.pyx":1383
+ * b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, False,
+ * addr(sstrm), b"_repr_svg")
+ * (sout, serr) = proc.communicate(sstrm.str()) # <<<<<<<<<<<<<<
+ * if proc.returncode != 0: # Just to be explicit.
+ * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG)
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_proc, __pyx_n_s_communicate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_sstrm.str()); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_2 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
+ __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+ if (likely(__pyx_t_2)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ __Pyx_INCREF(__pyx_t_2);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_1, function);
+ }
+ }
+ if (!__pyx_t_2) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_1)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) {
+ PyObject* sequence = __pyx_t_5;
+ #if !CYTHON_COMPILING_IN_PYPY
+ Py_ssize_t size = Py_SIZE(sequence);
+ #else
+ Py_ssize_t size = PySequence_Size(sequence);
+ #endif
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(0, 1383, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ if (likely(PyTuple_CheckExact(sequence))) {
+ __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
+ } else {
+ __pyx_t_1 = PyList_GET_ITEM(sequence, 0);
+ __pyx_t_4 = PyList_GET_ITEM(sequence, 1);
+ }
+ __Pyx_INCREF(__pyx_t_1);
+ __Pyx_INCREF(__pyx_t_4);
+ #else
+ __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ #endif
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else {
+ Py_ssize_t index = -1;
+ __pyx_t_3 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext;
+ index = 0; __pyx_t_1 = __pyx_t_8(__pyx_t_3); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_1);
+ index = 1; __pyx_t_4 = __pyx_t_8(__pyx_t_3); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_4);
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_3), 2) < 0) __PYX_ERR(0, 1383, __pyx_L1_error)
+ __pyx_t_8 = NULL;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ goto __pyx_L4_unpacking_done;
+ __pyx_L3_unpacking_failed:;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_8 = NULL;
+ if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+ __PYX_ERR(0, 1383, __pyx_L1_error)
+ __pyx_L4_unpacking_done:;
+ }
+ __pyx_v_sout = __pyx_t_1;
+ __pyx_t_1 = 0;
+ __pyx_v_serr = __pyx_t_4;
+ __pyx_t_4 = 0;
+
+ /* "pywrapfst.pyx":1384
+ * addr(sstrm), b"_repr_svg")
+ * (sout, serr) = proc.communicate(sstrm.str())
+ * if proc.returncode != 0: # Just to be explicit. # <<<<<<<<<<<<<<
+ * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG)
+ * return sout.decode("utf8")
+ */
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_proc, __pyx_n_s_returncode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1384, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1384, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1384, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_9) {
+
+ /* "pywrapfst.pyx":1385
+ * (sout, serr) = proc.communicate(sstrm.str())
+ * if proc.returncode != 0: # Just to be explicit.
+ * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG) # <<<<<<<<<<<<<<
+ * return sout.decode("utf8")
+ *
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_subprocess); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_CalledProcessError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_proc, __pyx_n_s_returncode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_DOT_TSVG); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_2 = NULL;
+ __pyx_t_10 = 0;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
+ __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+ if (likely(__pyx_t_2)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ __Pyx_INCREF(__pyx_t_2);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_1, function);
+ __pyx_t_10 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_1)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_5, __pyx_t_3};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_t_5, __pyx_t_3};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (__pyx_t_2) {
+ __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_3);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 1385, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1384
+ * addr(sstrm), b"_repr_svg")
+ * (sout, serr) = proc.communicate(sstrm.str())
+ * if proc.returncode != 0: # Just to be explicit. # <<<<<<<<<<<<<<
+ * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG)
+ * return sout.decode("utf8")
+ */
+ }
+
+ /* "pywrapfst.pyx":1386
+ * if proc.returncode != 0: # Just to be explicit.
+ * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG)
+ * return sout.decode("utf8") # <<<<<<<<<<<<<<
+ *
+ * def __repr__(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sout, __pyx_n_s_decode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1360
+ *
+ * # IPython notebook magic to produce an SVG of the FST.
+ * def _repr_svg_(self): # <<<<<<<<<<<<<<
+ * """IPython notebook magic to produce an SVG of the FST using GraphViz.
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_11);
+ __Pyx_AddTraceback("pywrapfst._Fst._repr_svg_", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_proc);
+ __Pyx_XDECREF(__pyx_v_sout);
+ __Pyx_XDECREF(__pyx_v_serr);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1388
+ * return sout.decode("utf8")
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_3__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_2__repr__(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_2__repr__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":1389
+ *
+ * def __repr__(self):
+ * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Fst_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1389, __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 '%s'", "fst_type");
+ __PYX_ERR(0, 1389, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_self->__pyx_vtab)->fst_type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1389, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1389, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1389, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1389, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1389, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1389, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_4) {
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1389, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1388
+ * return sout.decode("utf8")
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst._Fst.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1391
+ * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self))
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_4_Fst_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_4_Fst_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+ if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1;
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_4__init__(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_4_Fst_4__init__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":1392
+ *
+ * def __init__(self):
+ * raise FstDeletedConstructorError( # <<<<<<<<<<<<<<
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1392, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":1393
+ * def __init__(self):
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<<
+ *
+ * # Other magic methods.
+ */
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1393, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1392, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1392, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1392, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1392, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1392, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 1392, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1391
+ * return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self))
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst._Fst.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1397
+ * # Other magic methods.
+ *
+ * def __str__(self): # <<<<<<<<<<<<<<
+ * return self.text(acceptor=self._fst.get().Properties(fst.kAcceptor, True) ==
+ * fst.kAcceptor,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_7__str__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_7__str__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__str__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_6__str__(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_6__str__(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("__str__", 0);
+
+ /* "pywrapfst.pyx":1398
+ *
+ * def __str__(self):
+ * return self.text(acceptor=self._fst.get().Properties(fst.kAcceptor, True) == # <<<<<<<<<<<<<<
+ * fst.kAcceptor,
+ * show_weight_one=self._fst.get().Properties(fst.kWeighted, True) ==
+ */
+ __Pyx_XDECREF(__pyx_r);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "text");
+ __PYX_ERR(0, 1398, __pyx_L1_error)
+ }
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_text); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1398, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1398, __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 '%s'", "_fst");
+ __PYX_ERR(0, 1398, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1399
+ * def __str__(self):
+ * return self.text(acceptor=self._fst.get().Properties(fst.kAcceptor, True) ==
+ * fst.kAcceptor, # <<<<<<<<<<<<<<
+ * show_weight_one=self._fst.get().Properties(fst.kWeighted, True) ==
+ * fst.kWeighted)
+ */
+ __pyx_t_3 = __Pyx_PyBool_FromLong((__pyx_v_self->_fst.get()->Properties(fst::kAcceptor, 1) == fst::kAcceptor)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1398, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_acceptor, __pyx_t_3) < 0) __PYX_ERR(0, 1398, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":1400
+ * return self.text(acceptor=self._fst.get().Properties(fst.kAcceptor, True) ==
+ * fst.kAcceptor,
+ * show_weight_one=self._fst.get().Properties(fst.kWeighted, True) == # <<<<<<<<<<<<<<
+ * fst.kWeighted)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1400, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1401
+ * fst.kAcceptor,
+ * show_weight_one=self._fst.get().Properties(fst.kWeighted, True) ==
+ * fst.kWeighted) # <<<<<<<<<<<<<<
+ *
+ * cpdef string arc_type(self):
+ */
+ __pyx_t_3 = __Pyx_PyBool_FromLong((__pyx_v_self->_fst.get()->Properties(fst::kWeighted, 1) == fst::kWeighted)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1400, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_show_weight_one, __pyx_t_3) < 0) __PYX_ERR(0, 1398, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":1398
+ *
+ * def __str__(self):
+ * return self.text(acceptor=self._fst.get().Properties(fst.kAcceptor, True) == # <<<<<<<<<<<<<<
+ * fst.kAcceptor,
+ * show_weight_one=self._fst.get().Properties(fst.kWeighted, True) ==
+ */
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1398, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1397
+ * # Other magic methods.
+ *
+ * def __str__(self): # <<<<<<<<<<<<<<
+ * return self.text(acceptor=self._fst.get().Properties(fst.kAcceptor, True) ==
+ * fst.kAcceptor,
+ */
+
+ /* 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.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1403
+ * fst.kWeighted)
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().ArcType()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1403, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_9arc_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1403, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1403, __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, 1403, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1404
+ *
+ * cpdef string arc_type(self):
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 1404, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_fst.get()->ArcType();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1403
+ * fst.kWeighted)
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().ArcType()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_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_4_Fst_8arc_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_8arc_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1403, __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":1406
+ * return self._fst.get().ArcType()
+ *
+ * cpdef ArcIterator arcs(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * arcs(self, state)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_11arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_f_9pywrapfst_4_Fst_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("arcs", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_11arcs)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_ArcIterator))))) __PYX_ERR(0, 1406, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1420
+ * See also: `mutable_arcs`, `states`.
+ * """
+ * return ArcIterator(self, state) # <<<<<<<<<<<<<<
+ *
+ * cpdef _Fst copy(self):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1420, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1420, __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, 1420, __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":1406
+ * return self._fst.get().ArcType()
+ *
+ * cpdef ArcIterator arcs(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * arcs(self, state)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._Fst.arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_11arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_10arcs[] = "\n arcs(self, state)\n\n Returns an iterator over arcs leaving some state=.\n\n Args:\n s: The source state ID.\n\n Returns:\n An ArcIterator over arcs leaving state `state`.\n\n See also: `mutable_arcs`, `states`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_11arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("arcs (wrapper)", 0);
+ assert(__pyx_arg_state); {
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1406, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_10arcs(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_10arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("arcs", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_arcs(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1406, __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":1422
+ * return ArcIterator(self, state)
+ *
+ * cpdef _Fst copy(self): # <<<<<<<<<<<<<<
+ * """
+ * copy(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_13copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst_4_Fst_copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1422, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_13copy)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1422, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1422, __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, 1422, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1428
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 1428, __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, 1428, __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":1422
+ * return ArcIterator(self, state)
+ *
+ * cpdef _Fst copy(self): # <<<<<<<<<<<<<<
+ * """
+ * copy(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._Fst.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_13copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_12copy[] = "\n copy(self)\n\n Makes a copy of the FST.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_13copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("copy (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_12copy(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_12copy(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1422, __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":1430
+ * return _init_XFst(new fst.FstClass(deref(self._fst)))
+ *
+ * cpdef void draw(self, # <<<<<<<<<<<<<<
+ * filename,
+ * _SymbolTable isymbols=None,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_15draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static void __pyx_f_9pywrapfst_4_Fst_draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args) {
+
+ /* "pywrapfst.pyx":1432
+ * cpdef void draw(self,
+ * filename,
+ * _SymbolTable isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable osymbols=None,
+ * SymbolTable ssymbols=None,
+ */
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1433
+ * filename,
+ * _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None, # <<<<<<<<<<<<<<
+ * SymbolTable ssymbols=None,
+ * bool acceptor=False,
+ */
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1434
+ * _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None,
+ * SymbolTable ssymbols=None, # <<<<<<<<<<<<<<
+ * bool acceptor=False,
+ * title=b"",
+ */
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1435
+ * _SymbolTable osymbols=None,
+ * SymbolTable ssymbols=None,
+ * bool acceptor=False, # <<<<<<<<<<<<<<
+ * title=b"",
+ * double width=8.5,
+ */
+ bool __pyx_v_acceptor = ((bool)0);
+ PyObject *__pyx_v_title = ((PyObject *)__pyx_kp_b_);
+ double __pyx_v_width = ((double)8.5);
+ double __pyx_v_height = ((double)11.0);
+
+ /* "pywrapfst.pyx":1439
+ * 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":1440
+ * double height=11,
+ * bool portrait=False,
+ * bool vertical=False, # <<<<<<<<<<<<<<
+ * double ranksep=0.4,
+ * double nodesep=0.25,
+ */
+ bool __pyx_v_vertical = ((bool)0);
+ double __pyx_v_ranksep = ((double)0.4);
+ double __pyx_v_nodesep = ((double)0.25);
+ __pyx_t_10basictypes_int32 __pyx_v_fontsize = ((__pyx_t_10basictypes_int32)14);
+ __pyx_t_10basictypes_int32 __pyx_v_precision = ((__pyx_t_10basictypes_int32)5);
+
+ /* "pywrapfst.pyx":1445
+ * int32 fontsize=14,
+ * int32 precision=5,
+ * bool show_weight_one=False): # <<<<<<<<<<<<<<
+ * """
+ * draw(self, filename, isymbols=None, osymbols=None, ssymbols=None,
+ */
+ bool __pyx_v_show_weight_one = ((bool)0);
+ std::string __pyx_v_filename_string;
+ std::unique_ptr<std::ofstream> __pyx_v_ostrm;
+ fst::SymbolTable *__pyx_v_ssymbols_ptr;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ PyObject *__pyx_t_10 = NULL;
+ PyObject *__pyx_t_11 = NULL;
+ PyObject *__pyx_t_12 = NULL;
+ PyObject *__pyx_t_13 = NULL;
+ PyObject *__pyx_t_14 = NULL;
+ int __pyx_t_15;
+ PyObject *__pyx_t_16 = NULL;
+ std::string __pyx_t_17;
+ int __pyx_t_18;
+ int __pyx_t_19;
+ fst::SymbolTable *__pyx_t_20;
+ fst::SymbolTable const *__pyx_t_21;
+ fst::SymbolTable const *__pyx_t_22;
+ __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_show_weight_one = __pyx_optional_args->show_weight_one;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":1430
+ * return _init_XFst(new fst.FstClass(deref(self._fst)))
+ *
+ * cpdef void draw(self, # <<<<<<<<<<<<<<
+ * filename,
+ * _SymbolTable isymbols=None,
+ */
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_draw); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_15draw)) {
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_acceptor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyFloat_FromDouble(__pyx_v_width); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = PyFloat_FromDouble(__pyx_v_height); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1430, __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, 1430, __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, 1430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = PyFloat_FromDouble(__pyx_v_ranksep); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_9 = PyFloat_FromDouble(__pyx_v_nodesep); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1430, __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, 1430, __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, 1430, __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, 1430, __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[16] = {__pyx_t_14, __pyx_v_filename, ((PyObject *)__pyx_v_isymbols), ((PyObject *)__pyx_v_osymbols), ((PyObject *)__pyx_v_ssymbols), __pyx_t_3, __pyx_v_title, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_15, 15+__pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1430, __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[16] = {__pyx_t_14, __pyx_v_filename, ((PyObject *)__pyx_v_isymbols), ((PyObject *)__pyx_v_osymbols), ((PyObject *)__pyx_v_ssymbols), __pyx_t_3, __pyx_v_title, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-__pyx_t_15, 15+__pyx_t_15); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1430, __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(15+__pyx_t_15); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 1430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_16);
+ if (__pyx_t_14) {
+ __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __pyx_t_14 = NULL;
+ }
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_v_filename);
+ __Pyx_INCREF(((PyObject *)__pyx_v_isymbols));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_isymbols));
+ PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, ((PyObject *)__pyx_v_isymbols));
+ __Pyx_INCREF(((PyObject *)__pyx_v_osymbols));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_osymbols));
+ PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, ((PyObject *)__pyx_v_osymbols));
+ __Pyx_INCREF(((PyObject *)__pyx_v_ssymbols));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_ssymbols));
+ PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, ((PyObject *)__pyx_v_ssymbols));
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_16, 4+__pyx_t_15, __pyx_t_3);
+ __Pyx_INCREF(__pyx_v_title);
+ __Pyx_GIVEREF(__pyx_v_title);
+ PyTuple_SET_ITEM(__pyx_t_16, 5+__pyx_t_15, __pyx_v_title);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_16, 6+__pyx_t_15, __pyx_t_4);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_16, 7+__pyx_t_15, __pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_16, 8+__pyx_t_15, __pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_16, 9+__pyx_t_15, __pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_8);
+ PyTuple_SET_ITEM(__pyx_t_16, 10+__pyx_t_15, __pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_9);
+ PyTuple_SET_ITEM(__pyx_t_16, 11+__pyx_t_15, __pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_10);
+ PyTuple_SET_ITEM(__pyx_t_16, 12+__pyx_t_15, __pyx_t_10);
+ __Pyx_GIVEREF(__pyx_t_11);
+ PyTuple_SET_ITEM(__pyx_t_16, 13+__pyx_t_15, __pyx_t_11);
+ __Pyx_GIVEREF(__pyx_t_12);
+ PyTuple_SET_ITEM(__pyx_t_16, 14+__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, 1430, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1480
+ * See also: `text`.
+ * """
+ * cdef string filename_string = tostring(filename) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[ofstream] ostrm
+ * ostrm.reset(new ofstream(filename_string.c_str()))
+ */
+ __pyx_t_17 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1480, __pyx_L1_error)
+ __pyx_v_filename_string = __pyx_t_17;
+
+ /* "pywrapfst.pyx":1482
+ * cdef string filename_string = tostring(filename)
+ * cdef unique_ptr[ofstream] ostrm
+ * ostrm.reset(new ofstream(filename_string.c_str())) # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL
+ * if ssymbols is not None:
+ */
+ __pyx_v_ostrm.reset(new std::ofstream(__pyx_v_filename_string.c_str()));
+
+ /* "pywrapfst.pyx":1483
+ * cdef unique_ptr[ofstream] ostrm
+ * ostrm.reset(new ofstream(filename_string.c_str()))
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL # <<<<<<<<<<<<<<
+ * if ssymbols is not None:
+ * ssymbols_ptr = ssymbols._table
+ */
+ __pyx_v_ssymbols_ptr = NULL;
+
+ /* "pywrapfst.pyx":1484
+ * ostrm.reset(new ofstream(filename_string.c_str()))
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL
+ * if ssymbols is not None: # <<<<<<<<<<<<<<
+ * ssymbols_ptr = ssymbols._table
+ * fst.DrawFst(deref(self._fst),
+ */
+ __pyx_t_18 = (((PyObject *)__pyx_v_ssymbols) != Py_None);
+ __pyx_t_19 = (__pyx_t_18 != 0);
+ if (__pyx_t_19) {
+
+ /* "pywrapfst.pyx":1485
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL
+ * if ssymbols is not None:
+ * ssymbols_ptr = ssymbols._table # <<<<<<<<<<<<<<
+ * fst.DrawFst(deref(self._fst),
+ * self._fst.get().InputSymbols() if isymbols is None
+ */
+ if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1485, __pyx_L1_error)
+ }
+ __pyx_t_20 = __pyx_v_ssymbols->__pyx_base.__pyx_base._table;
+ __pyx_v_ssymbols_ptr = __pyx_t_20;
+
+ /* "pywrapfst.pyx":1484
+ * ostrm.reset(new ofstream(filename_string.c_str()))
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL
+ * if ssymbols is not None: # <<<<<<<<<<<<<<
+ * ssymbols_ptr = ssymbols._table
+ * fst.DrawFst(deref(self._fst),
+ */
+ }
+
+ /* "pywrapfst.pyx":1486
+ * if ssymbols is not None:
+ * ssymbols_ptr = ssymbols._table
+ * fst.DrawFst(deref(self._fst), # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1486, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1487
+ * ssymbols_ptr = ssymbols._table
+ * fst.DrawFst(deref(self._fst),
+ * self._fst.get().InputSymbols() if isymbols is None # <<<<<<<<<<<<<<
+ * else isymbols._table,
+ * self._fst.get().OutputSymbols() if osymbols is None
+ */
+ __pyx_t_19 = (((PyObject *)__pyx_v_isymbols) == Py_None);
+ if ((__pyx_t_19 != 0)) {
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1487, __pyx_L1_error)
+ }
+ __pyx_t_21 = __pyx_v_self->_fst.get()->InputSymbols();
+ } else {
+
+ /* "pywrapfst.pyx":1488
+ * fst.DrawFst(deref(self._fst),
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table, # <<<<<<<<<<<<<<
+ * self._fst.get().OutputSymbols() if osymbols is None
+ * else osymbols._table,
+ */
+ if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1488, __pyx_L1_error)
+ }
+ __pyx_t_21 = __pyx_v_isymbols->_table;
+ }
+
+ /* "pywrapfst.pyx":1489
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table,
+ * self._fst.get().OutputSymbols() if osymbols is None # <<<<<<<<<<<<<<
+ * else osymbols._table,
+ * ssymbols_ptr, acceptor, tostring(title), width, height, portrait,
+ */
+ __pyx_t_19 = (((PyObject *)__pyx_v_osymbols) == Py_None);
+ if ((__pyx_t_19 != 0)) {
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1489, __pyx_L1_error)
+ }
+ __pyx_t_22 = __pyx_v_self->_fst.get()->OutputSymbols();
+ } else {
+
+ /* "pywrapfst.pyx":1490
+ * else isymbols._table,
+ * self._fst.get().OutputSymbols() if osymbols is None
+ * else osymbols._table, # <<<<<<<<<<<<<<
+ * ssymbols_ptr, acceptor, tostring(title), width, height, portrait,
+ * vertical, ranksep, nodesep, fontsize, precision, show_weight_one,
+ */
+ if (unlikely(((PyObject *)__pyx_v_osymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1490, __pyx_L1_error)
+ }
+ __pyx_t_22 = __pyx_v_osymbols->_table;
+ }
+
+ /* "pywrapfst.pyx":1491
+ * self._fst.get().OutputSymbols() if osymbols is None
+ * else osymbols._table,
+ * ssymbols_ptr, acceptor, tostring(title), width, height, portrait, # <<<<<<<<<<<<<<
+ * vertical, ranksep, nodesep, fontsize, precision, show_weight_one,
+ * ostrm.get(), filename_string)
+ */
+ __pyx_t_17 = __pyx_f_9pywrapfst_tostring(__pyx_v_title, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1491, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1486
+ * if ssymbols is not None:
+ * ssymbols_ptr = ssymbols._table
+ * fst.DrawFst(deref(self._fst), # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table,
+ */
+ fst::script::DrawFst((*__pyx_v_self->_fst), __pyx_t_21, __pyx_t_22, __pyx_v_ssymbols_ptr, __pyx_v_acceptor, __pyx_t_17, __pyx_v_width, __pyx_v_height, __pyx_v_portrait, __pyx_v_vertical, __pyx_v_ranksep, __pyx_v_nodesep, __pyx_v_fontsize, __pyx_v_precision, __pyx_v_show_weight_one, __pyx_v_ostrm.get(), __pyx_v_filename_string);
+
+ /* "pywrapfst.pyx":1430
+ * return _init_XFst(new fst.FstClass(deref(self._fst)))
+ *
+ * cpdef void draw(self, # <<<<<<<<<<<<<<
+ * filename,
+ * _SymbolTable isymbols=None,
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_XDECREF(__pyx_t_10);
+ __Pyx_XDECREF(__pyx_t_11);
+ __Pyx_XDECREF(__pyx_t_12);
+ __Pyx_XDECREF(__pyx_t_13);
+ __Pyx_XDECREF(__pyx_t_14);
+ __Pyx_XDECREF(__pyx_t_16);
+ __Pyx_WriteUnraisable("pywrapfst._Fst.draw", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_15draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_14draw[] = "\n draw(self, filename, isymbols=None, osymbols=None, ssymbols=None,\n acceptor=False, title=\"\", width=8.5, height=11, portrait=False,\n vertical=False, ranksep=0.4, nodesep=0.25, fontsize=14,\n precision=5, show_weight_one=False):\n\n Writes out the FST in Graphviz text format.\n\n This method writes out the FST in the dot graph description language. The\n graph can be rendered using the `dot` executable provided by Graphviz.\n\n Args:\n filename: The string location of the output dot/Graphviz file.\n isymbols: An optional symbol table used to label input symbols.\n osymbols: An optional symbol table used to label output symbols.\n ssymbols: An optional symbol table used to label states.\n acceptor: Should the figure be rendered in acceptor format if possible?\n title: An optional string indicating the figure title.\n width: The figure width, in inches.\n height: The figure height, in inches.\n portrait: Should the figure be rendered in portrait rather than\n landscape?\n vertical: Should the figure be rendered bottom-to-top rather than\n left-to-right?\n ranksep: The minimum separation separation between ranks, in inches.\n nodesep: The minimum separation between nodes, in inches.\n fontsize: Font size, in points.\n precision: Numeric precision for floats, in number of chars.\n show_weight_one: Should weights equivalent to semiring One be printed?\n\n For more information about the rendering options, see `man dot`.\n\n See also: `text`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_15draw(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_filename = 0;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = 0;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = 0;
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols = 0;
+ bool __pyx_v_acceptor;
+ PyObject *__pyx_v_title = 0;
+ double __pyx_v_width;
+ double __pyx_v_height;
+ bool __pyx_v_portrait;
+ bool __pyx_v_vertical;
+ double __pyx_v_ranksep;
+ double __pyx_v_nodesep;
+ __pyx_t_10basictypes_int32 __pyx_v_fontsize;
+ __pyx_t_10basictypes_int32 __pyx_v_precision;
+ bool __pyx_v_show_weight_one;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("draw (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_isymbols,&__pyx_n_s_osymbols,&__pyx_n_s_ssymbols,&__pyx_n_s_acceptor,&__pyx_n_s_title,&__pyx_n_s_width,&__pyx_n_s_height,&__pyx_n_s_portrait,&__pyx_n_s_vertical,&__pyx_n_s_ranksep,&__pyx_n_s_nodesep,&__pyx_n_s_fontsize,&__pyx_n_s_precision,&__pyx_n_s_show_weight_one,0};
+ PyObject* values[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+ /* "pywrapfst.pyx":1432
+ * cpdef void draw(self,
+ * filename,
+ * _SymbolTable isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable osymbols=None,
+ * SymbolTable ssymbols=None,
+ */
+ values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1433
+ * filename,
+ * _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None, # <<<<<<<<<<<<<<
+ * SymbolTable ssymbols=None,
+ * bool acceptor=False,
+ */
+ values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1434
+ * _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None,
+ * SymbolTable ssymbols=None, # <<<<<<<<<<<<<<
+ * bool acceptor=False,
+ * title=b"",
+ */
+ values[3] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None);
+ values[5] = ((PyObject *)__pyx_kp_b_);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
+ case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
+ case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
+ case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
+ case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
+ case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
+ case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+ case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_isymbols);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osymbols);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ssymbols);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acceptor);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_title);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_width);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ case 7:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_height);
+ if (value) { values[7] = value; kw_args--; }
+ }
+ case 8:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_portrait);
+ if (value) { values[8] = value; kw_args--; }
+ }
+ case 9:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_vertical);
+ if (value) { values[9] = value; kw_args--; }
+ }
+ case 10:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ranksep);
+ if (value) { values[10] = value; kw_args--; }
+ }
+ case 11:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nodesep);
+ if (value) { values[11] = value; kw_args--; }
+ }
+ case 12:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fontsize);
+ if (value) { values[12] = value; kw_args--; }
+ }
+ case 13:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_precision);
+ if (value) { values[13] = value; kw_args--; }
+ }
+ case 14:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_show_weight_one);
+ if (value) { values[14] = 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, 1430, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
+ case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
+ case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
+ case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
+ case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
+ case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
+ case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+ case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_filename = values[0];
+ __pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]);
+ __pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[2]);
+ __pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst_SymbolTable *)values[3]);
+ if (values[4]) {
+ __pyx_v_acceptor = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_acceptor == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1435, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":1435
+ * _SymbolTable osymbols=None,
+ * SymbolTable ssymbols=None,
+ * bool acceptor=False, # <<<<<<<<<<<<<<
+ * title=b"",
+ * double width=8.5,
+ */
+ __pyx_v_acceptor = ((bool)0);
+ }
+ __pyx_v_title = values[5];
+ if (values[6]) {
+ __pyx_v_width = __pyx_PyFloat_AsDouble(values[6]); if (unlikely((__pyx_v_width == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1437, __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, 1438, __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, 1439, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":1439
+ * 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, 1440, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":1440
+ * 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, 1441, __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, 1442, __pyx_L3_error)
+ } else {
+ __pyx_v_nodesep = ((double)0.25);
+ }
+ if (values[12]) {
+ __pyx_v_fontsize = __Pyx_PyInt_As_int32_t(values[12]); if (unlikely((__pyx_v_fontsize == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1443, __pyx_L3_error)
+ } else {
+ __pyx_v_fontsize = ((__pyx_t_10basictypes_int32)14);
+ }
+ if (values[13]) {
+ __pyx_v_precision = __Pyx_PyInt_As_int32_t(values[13]); if (unlikely((__pyx_v_precision == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1444, __pyx_L3_error)
+ } else {
+ __pyx_v_precision = ((__pyx_t_10basictypes_int32)5);
+ }
+ if (values[14]) {
+ __pyx_v_show_weight_one = __Pyx_PyObject_IsTrue(values[14]); if (unlikely((__pyx_v_show_weight_one == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1445, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":1445
+ * int32 fontsize=14,
+ * int32 precision=5,
+ * bool show_weight_one=False): # <<<<<<<<<<<<<<
+ * """
+ * draw(self, filename, isymbols=None, osymbols=None, ssymbols=None,
+ */
+ __pyx_v_show_weight_one = ((bool)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("draw", 0, 1, 15, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1430, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.draw", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "isymbols", 0))) __PYX_ERR(0, 1432, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "osymbols", 0))) __PYX_ERR(0, 1433, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "ssymbols", 0))) __PYX_ERR(0, 1434, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_14draw(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), __pyx_v_filename, __pyx_v_isymbols, __pyx_v_osymbols, __pyx_v_ssymbols, __pyx_v_acceptor, __pyx_v_title, __pyx_v_width, __pyx_v_height, __pyx_v_portrait, __pyx_v_vertical, __pyx_v_ranksep, __pyx_v_nodesep, __pyx_v_fontsize, __pyx_v_precision, __pyx_v_show_weight_one);
+
+ /* "pywrapfst.pyx":1430
+ * return _init_XFst(new fst.FstClass(deref(self._fst)))
+ *
+ * cpdef void draw(self, # <<<<<<<<<<<<<<
+ * filename,
+ * _SymbolTable isymbols=None,
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_14draw(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, PyObject *__pyx_v_title, double __pyx_v_width, double __pyx_v_height, bool __pyx_v_portrait, bool __pyx_v_vertical, double __pyx_v_ranksep, double __pyx_v_nodesep, __pyx_t_10basictypes_int32 __pyx_v_fontsize, __pyx_t_10basictypes_int32 __pyx_v_precision, bool __pyx_v_show_weight_one) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_4_Fst_draw __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("draw", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1.__pyx_n = 14;
+ __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.show_weight_one = __pyx_v_show_weight_one;
+ __pyx_vtabptr_9pywrapfst__Fst->draw(__pyx_v_self, __pyx_v_filename, 1, &__pyx_t_1);
+ __pyx_t_2 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1430, __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":1495
+ * ostrm.get(), filename_string)
+ *
+ * cpdef Weight final(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * final(self, state)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_17final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static struct __pyx_obj_9pywrapfst_Weight *__pyx_f_9pywrapfst_4_Fst_final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_weight = 0;
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("final", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_final); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_17final)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_Weight))))) __PYX_ERR(0, 1495, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1510
+ * FstIndexError: State index out of range.
+ * """
+ * cdef Weight weight = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state)))
+ * return weight
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1510, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 1510, __pyx_L1_error)
+ __pyx_v_weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":1511
+ * """
+ * cdef Weight weight = Weight.__new__(Weight)
+ * weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state))) # <<<<<<<<<<<<<<
+ * return weight
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_weight) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 1511, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1511, __pyx_L1_error)
+ }
+ __pyx_v_weight->_weight.reset(new fst::script::WeightClass(__pyx_v_self->_fst.get()->Final(__pyx_v_state)));
+
+ /* "pywrapfst.pyx":1512
+ * cdef Weight weight = Weight.__new__(Weight)
+ * weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state)))
+ * return weight # <<<<<<<<<<<<<<
+ *
+ * cpdef string fst_type(self):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_weight));
+ __pyx_r = __pyx_v_weight;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1495
+ * ostrm.get(), filename_string)
+ *
+ * cpdef Weight final(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * final(self, state)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._Fst.final", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_weight);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_17final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_16final[] = "\n final(self, state)\n\n Returns the final weight of a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The final Weight of that state.\n\n Raises:\n FstIndexError: State index out of range.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_17final(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("final (wrapper)", 0);
+ assert(__pyx_arg_state); {
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1495, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.final", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_16final(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_16final(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("final", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_final(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1495, __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":1514
+ * return weight
+ *
+ * cpdef string fst_type(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().FstType()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_19fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("fst_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_fst_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1514, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_19fst_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1514, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1514, __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, 1514, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1515
+ *
+ * cpdef string fst_type(self):
+ * return self._fst.get().FstType() # <<<<<<<<<<<<<<
+ *
+ * cpdef _FstSymbolTable input_symbols(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1515, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_fst.get()->FstType();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1514
+ * return weight
+ *
+ * cpdef string fst_type(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().FstType()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_19fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_19fst_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("fst_type (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_18fst_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_18fst_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("fst_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_fst_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1514, __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":1517
+ * return self._fst.get().FstType()
+ *
+ * cpdef _FstSymbolTable input_symbols(self): # <<<<<<<<<<<<<<
+ * if self._fst.get().InputSymbols() == NULL:
+ * return
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_21input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_t_5;
+ __Pyx_RefNannySetupContext("input_symbols", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_input_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1517, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_21input_symbols)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1517, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1517, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__FstSymbolTable))))) __PYX_ERR(0, 1517, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1518
+ *
+ * cpdef _FstSymbolTable input_symbols(self):
+ * if self._fst.get().InputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1518, __pyx_L1_error)
+ }
+ __pyx_t_5 = ((__pyx_v_self->_fst.get()->InputSymbols() == NULL) != 0);
+ if (__pyx_t_5) {
+
+ /* "pywrapfst.pyx":1519
+ * cpdef _FstSymbolTable input_symbols(self):
+ * if self._fst.get().InputSymbols() == NULL:
+ * return # <<<<<<<<<<<<<<
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ * self._fst.get().InputSymbols()), self._fst)
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)Py_None); __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1518
+ *
+ * cpdef _FstSymbolTable input_symbols(self):
+ * if self._fst.get().InputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ }
+
+ /* "pywrapfst.pyx":1520
+ * if self._fst.get().InputSymbols() == NULL:
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols()), self._fst)
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+
+ /* "pywrapfst.pyx":1521
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ * self._fst.get().InputSymbols()), self._fst) # <<<<<<<<<<<<<<
+ *
+ * cpdef size_t num_arcs(self, int64 state) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1521, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1520
+ * if self._fst.get().InputSymbols() == NULL:
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols()), self._fst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1521, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1521
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ * self._fst.get().InputSymbols()), self._fst) # <<<<<<<<<<<<<<
+ *
+ * cpdef size_t num_arcs(self, int64 state) except *:
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_FstSymbolTable(const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_fst.get()->InputSymbols()), __pyx_v_self->_fst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1520, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1517
+ * return self._fst.get().FstType()
+ *
+ * cpdef _FstSymbolTable input_symbols(self): # <<<<<<<<<<<<<<
+ * if self._fst.get().InputSymbols() == NULL:
+ * return
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._Fst.input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_21input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_21input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("input_symbols (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_20input_symbols(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_20input_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("input_symbols", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_input_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1517, __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":1523
+ * self._fst.get().InputSymbols()), self._fst)
+ *
+ * cpdef size_t num_arcs(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * """
+ * num_arcs(self, state)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_23num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static size_t __pyx_f_9pywrapfst_4_Fst_num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) {
+ size_t __pyx_v_result;
+ size_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ size_t __pyx_t_7;
+ int __pyx_t_8;
+ __Pyx_RefNannySetupContext("num_arcs", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_23num_arcs)) {
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_7;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1540
+ * See also: `num_states`.
+ * """
+ * cdef size_t result = self._fst.get().NumArcs(state) # <<<<<<<<<<<<<<
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range")
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1540, __pyx_L1_error)
+ }
+ __pyx_v_result = __pyx_v_self->_fst.get()->NumArcs(__pyx_v_state);
+
+ /* "pywrapfst.pyx":1541
+ * """
+ * cdef size_t result = self._fst.get().NumArcs(state)
+ * if result == SIZE_MAX: # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * return result
+ */
+ __pyx_t_8 = ((__pyx_v_result == SIZE_MAX) != 0);
+ if (__pyx_t_8) {
+
+ /* "pywrapfst.pyx":1542
+ * cdef size_t result = self._fst.get().NumArcs(state)
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1542, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1542, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 1542, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1541
+ * """
+ * cdef size_t result = self._fst.get().NumArcs(state)
+ * if result == SIZE_MAX: # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":1543
+ * 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":1523
+ * self._fst.get().InputSymbols()), self._fst)
+ *
+ * cpdef size_t num_arcs(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * """
+ * num_arcs(self, state)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._Fst.num_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_23num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_22num_arcs[] = "\n num_arcs(self, state)\n\n Returns the number of arcs leaving a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The number of arcs leaving that state.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `num_states`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_23num_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("num_arcs (wrapper)", 0);
+ assert(__pyx_arg_state); {
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1523, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.num_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_22num_arcs(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_22num_arcs(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ size_t __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("num_arcs", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_f_9pywrapfst_4_Fst_num_arcs(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1523, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1523, __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":1545
+ * return result
+ *
+ * cpdef size_t num_input_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * """
+ * num_input_epsilsons(self, state)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_25num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static size_t __pyx_f_9pywrapfst_4_Fst_num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) {
+ size_t __pyx_v_result;
+ size_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ size_t __pyx_t_7;
+ int __pyx_t_8;
+ __Pyx_RefNannySetupContext("num_input_epsilons", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_input_epsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_25num_input_epsilons)) {
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_7;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1562
+ * See also: `num_output_epsilons`.
+ * """
+ * cdef size_t result = self._fst.get().NumInputEpsilons(state) # <<<<<<<<<<<<<<
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range")
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1562, __pyx_L1_error)
+ }
+ __pyx_v_result = __pyx_v_self->_fst.get()->NumInputEpsilons(__pyx_v_state);
+
+ /* "pywrapfst.pyx":1563
+ * """
+ * cdef size_t result = self._fst.get().NumInputEpsilons(state)
+ * if result == SIZE_MAX: # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * return result
+ */
+ __pyx_t_8 = ((__pyx_v_result == SIZE_MAX) != 0);
+ if (__pyx_t_8) {
+
+ /* "pywrapfst.pyx":1564
+ * cdef size_t result = self._fst.get().NumInputEpsilons(state)
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1564, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1564, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 1564, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1563
+ * """
+ * cdef size_t result = self._fst.get().NumInputEpsilons(state)
+ * if result == SIZE_MAX: # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":1565
+ * 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":1545
+ * return result
+ *
+ * cpdef size_t num_input_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * """
+ * num_input_epsilsons(self, state)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._Fst.num_input_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_25num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_24num_input_epsilons[] = "\n num_input_epsilsons(self, state)\n\n Returns the number of arcs with epsilon input labels leaving a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The number of epsilon-input-labeled arcs leaving that state.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `num_output_epsilons`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_25num_input_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("num_input_epsilons (wrapper)", 0);
+ assert(__pyx_arg_state); {
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1545, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.num_input_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_24num_input_epsilons(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_24num_input_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ size_t __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("num_input_epsilons", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_f_9pywrapfst_4_Fst_num_input_epsilons(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1545, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1545, __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":1567
+ * return result
+ *
+ * cpdef size_t num_output_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * """
+ * num_output_epsilsons(self, state)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_27num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static size_t __pyx_f_9pywrapfst_4_Fst_num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) {
+ size_t __pyx_v_result;
+ size_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ size_t __pyx_t_7;
+ int __pyx_t_8;
+ __Pyx_RefNannySetupContext("num_output_epsilons", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_output_epsilons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_27num_output_epsilons)) {
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_7;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1584
+ * See also: `num_input_epsilons`.
+ * """
+ * cdef size_t result = self._fst.get().NumOutputEpsilons(state) # <<<<<<<<<<<<<<
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range")
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1584, __pyx_L1_error)
+ }
+ __pyx_v_result = __pyx_v_self->_fst.get()->NumOutputEpsilons(__pyx_v_state);
+
+ /* "pywrapfst.pyx":1585
+ * """
+ * cdef size_t result = self._fst.get().NumOutputEpsilons(state)
+ * if result == SIZE_MAX: # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * return result
+ */
+ __pyx_t_8 = ((__pyx_v_result == SIZE_MAX) != 0);
+ if (__pyx_t_8) {
+
+ /* "pywrapfst.pyx":1586
+ * cdef size_t result = self._fst.get().NumOutputEpsilons(state)
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1586, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1586, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 1586, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1585
+ * """
+ * cdef size_t result = self._fst.get().NumOutputEpsilons(state)
+ * if result == SIZE_MAX: # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":1587
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range")
+ * return result # <<<<<<<<<<<<<<
+ *
+ * cpdef _FstSymbolTable output_symbols(self):
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1567
+ * return result
+ *
+ * cpdef size_t num_output_epsilons(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * """
+ * num_output_epsilsons(self, state)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._Fst.num_output_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_27num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_26num_output_epsilons[] = "\n num_output_epsilsons(self, state)\n\n Returns the number of arcs with epsilon output labels leaving a state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n The number of epsilon-output-labeled arcs leaving that state.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `num_input_epsilons`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_27num_output_epsilons(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("num_output_epsilons (wrapper)", 0);
+ assert(__pyx_arg_state); {
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1567, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.num_output_epsilons", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_26num_output_epsilons(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_26num_output_epsilons(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ size_t __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("num_output_epsilons", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_f_9pywrapfst_4_Fst_num_output_epsilons(__pyx_v_self, __pyx_v_state, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1567, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyInt_FromSize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1567, __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":1589
+ * return result
+ *
+ * cpdef _FstSymbolTable output_symbols(self): # <<<<<<<<<<<<<<
+ * if self._fst.get().OutputSymbols() == NULL:
+ * return
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_29output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_f_9pywrapfst_4_Fst_output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_t_5;
+ __Pyx_RefNannySetupContext("output_symbols", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_output_symbols); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1589, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_29output_symbols)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1589, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1589, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__FstSymbolTable))))) __PYX_ERR(0, 1589, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1590
+ *
+ * cpdef _FstSymbolTable output_symbols(self):
+ * if self._fst.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1590, __pyx_L1_error)
+ }
+ __pyx_t_5 = ((__pyx_v_self->_fst.get()->OutputSymbols() == NULL) != 0);
+ if (__pyx_t_5) {
+
+ /* "pywrapfst.pyx":1591
+ * cpdef _FstSymbolTable output_symbols(self):
+ * if self._fst.get().OutputSymbols() == NULL:
+ * return # <<<<<<<<<<<<<<
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ * self._fst.get().OutputSymbols()), self._fst)
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)Py_None); __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1590
+ *
+ * cpdef _FstSymbolTable output_symbols(self):
+ * if self._fst.get().OutputSymbols() == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ */
+ }
+
+ /* "pywrapfst.pyx":1592
+ * if self._fst.get().OutputSymbols() == NULL:
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._fst.get().OutputSymbols()), self._fst)
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+
+ /* "pywrapfst.pyx":1593
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ * self._fst.get().OutputSymbols()), self._fst) # <<<<<<<<<<<<<<
+ *
+ * cpdef uint64 properties(self, uint64 mask, bool test):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1593, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1592
+ * if self._fst.get().OutputSymbols() == NULL:
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr]( # <<<<<<<<<<<<<<
+ * self._fst.get().OutputSymbols()), self._fst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1593, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":1593
+ * return
+ * return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ * self._fst.get().OutputSymbols()), self._fst) # <<<<<<<<<<<<<<
+ *
+ * cpdef uint64 properties(self, uint64 mask, bool test):
+ */
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_FstSymbolTable(const_cast<__pyx_t_9pywrapfst_SymbolTable_ptr>(__pyx_v_self->_fst.get()->OutputSymbols()), __pyx_v_self->_fst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1592, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)__pyx_t_1);
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1589
+ * return result
+ *
+ * cpdef _FstSymbolTable output_symbols(self): # <<<<<<<<<<<<<<
+ * if self._fst.get().OutputSymbols() == NULL:
+ * return
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._Fst.output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_29output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_29output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("output_symbols (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_28output_symbols(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_28output_symbols(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("output_symbols", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_output_symbols(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1589, __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":1595
+ * self._fst.get().OutputSymbols()), self._fst)
+ *
+ * cpdef uint64 properties(self, uint64 mask, bool test): # <<<<<<<<<<<<<<
+ * """
+ * properties(self, mask, test)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_31properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static __pyx_t_10basictypes_uint64 __pyx_f_9pywrapfst_4_Fst_properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_uint64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ __pyx_t_10basictypes_uint64 __pyx_t_9;
+ __Pyx_RefNannySetupContext("properties", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_properties); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1595, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_31properties)) {
+ __pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1595, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_test); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1595, __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, 1595, __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, 1595, __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, 1595, __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, 1595, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_9 = __Pyx_PyInt_As_uint64_t(__pyx_t_2); if (unlikely((__pyx_t_9 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1595, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_9;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1613
+ * A 64-bit bitmask representing the requested properties.
+ * """
+ * return self._fst.get().Properties(mask, test) # <<<<<<<<<<<<<<
+ *
+ * cpdef int64 start(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1613, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_fst.get()->Properties(__pyx_v_mask, __pyx_v_test);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1595
+ * self._fst.get().OutputSymbols()), self._fst)
+ *
+ * cpdef uint64 properties(self, uint64 mask, bool test): # <<<<<<<<<<<<<<
+ * """
+ * properties(self, mask, test)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_WriteUnraisable("pywrapfst._Fst.properties", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_31properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_30properties[] = "\n properties(self, mask, test)\n\n Provides property bits.\n\n This method provides user access to the properties attributes for the FST.\n The resulting value is a long integer, but when it is cast to a boolean,\n it represents whether or not the FST has the `mask` property.\n\n Args:\n mask: The property mask to be compared to the FST's properties.\n test: Should any unknown values be computed before comparing against\n the mask?\n\n Returns:\n A 64-bit bitmask representing the requested properties.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_31properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_uint64 __pyx_v_mask;
+ bool __pyx_v_test;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("properties (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_mask,&__pyx_n_s_test,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_test)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("properties", 1, 2, 2, 1); __PYX_ERR(0, 1595, __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, 1595, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_mask = __Pyx_PyInt_As_uint64_t(values[0]); if (unlikely((__pyx_v_mask == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1595, __pyx_L3_error)
+ __pyx_v_test = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_test == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1595, __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, 1595, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.properties", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_30properties(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), __pyx_v_mask, __pyx_v_test);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_30properties(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_mask, bool __pyx_v_test) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("properties", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_f_9pywrapfst_4_Fst_properties(__pyx_v_self, __pyx_v_mask, __pyx_v_test, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1595, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._Fst.properties", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1615
+ * return self._fst.get().Properties(mask, test)
+ *
+ * cpdef int64 start(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().Start()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_33start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_4_Fst_start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_5;
+ __Pyx_RefNannySetupContext("start", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_start); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1615, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_33start)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1615, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1615, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1615, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1616
+ *
+ * cpdef int64 start(self):
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 1616, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_fst.get()->Start();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1615
+ * return self._fst.get().Properties(mask, test)
+ *
+ * cpdef int64 start(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().Start()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_33start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_33start(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("start (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_32start(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_32start(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("start", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_4_Fst_start(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1615, __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":1618
+ * return self._fst.get().Start()
+ *
+ * cpdef StateIterator states(self): # <<<<<<<<<<<<<<
+ * """
+ * states(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_35states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst_StateIterator *__pyx_f_9pywrapfst_4_Fst_states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_StateIterator *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("states", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1618, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_35states)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1618, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1618, __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, 1618, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1629
+ * See also: `arcs`, `mutable_arcs`.
+ * """
+ * return StateIterator(self) # <<<<<<<<<<<<<<
+ *
+ * cpdef string text(self, _SymbolTable isymbols=None,
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1629, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_StateIterator), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1629, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1618
+ * return self._fst.get().Start()
+ *
+ * cpdef StateIterator states(self): # <<<<<<<<<<<<<<
+ * """
+ * states(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._Fst.states", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_35states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_34states[] = "\n states(self)\n\n Returns an iterator over all states in the FST.\n\n Returns:\n A StateIterator object for the FST.\n\n See also: `arcs`, `mutable_arcs`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_35states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("states (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_34states(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_34states(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("states", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_4_Fst_states(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1618, __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":1631
+ * return StateIterator(self)
+ *
+ * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None,
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""):
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_37text(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args) {
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1632
+ *
+ * cpdef string text(self, _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, # <<<<<<<<<<<<<<
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""):
+ * """
+ */
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1633
+ * cpdef string text(self, _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None,
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): # <<<<<<<<<<<<<<
+ * """
+ * text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False,
+ */
+ bool __pyx_v_acceptor = ((bool)0);
+ bool __pyx_v_show_weight_one = ((bool)0);
+ PyObject *__pyx_v_missing_sym = ((PyObject *)__pyx_kp_b_);
+ fst::SymbolTable *__pyx_v_ssymbols_ptr;
+ std::stringstream __pyx_v_sstrm;
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ std::string __pyx_t_9;
+ int __pyx_t_10;
+ int __pyx_t_11;
+ fst::SymbolTable *__pyx_t_12;
+ fst::SymbolTable const *__pyx_t_13;
+ fst::SymbolTable const *__pyx_t_14;
+ std::string __pyx_t_15;
+ __Pyx_RefNannySetupContext("text", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_isymbols = __pyx_optional_args->isymbols;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_osymbols = __pyx_optional_args->osymbols;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_ssymbols = __pyx_optional_args->ssymbols;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_acceptor = __pyx_optional_args->acceptor;
+ if (__pyx_optional_args->__pyx_n > 4) {
+ __pyx_v_show_weight_one = __pyx_optional_args->show_weight_one;
+ if (__pyx_optional_args->__pyx_n > 5) {
+ __pyx_v_missing_sym = __pyx_optional_args->missing_sym;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":1631
+ * return StateIterator(self)
+ *
+ * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None,
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""):
+ */
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_text); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1631, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_37text)) {
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_acceptor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1631, __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, 1631, __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, 1631, __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, 1631, __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, 1631, __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, 1631, __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, 1631, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_9;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1656
+ * """
+ * # Prints FST to stringstream, then returns resulting string.
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL # <<<<<<<<<<<<<<
+ * if ssymbols is not None:
+ * ssymbols_ptr = ssymbols._table
+ */
+ __pyx_v_ssymbols_ptr = NULL;
+
+ /* "pywrapfst.pyx":1657
+ * # Prints FST to stringstream, then returns resulting string.
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL
+ * if ssymbols is not None: # <<<<<<<<<<<<<<
+ * ssymbols_ptr = ssymbols._table
+ * cdef stringstream sstrm
+ */
+ __pyx_t_10 = (((PyObject *)__pyx_v_ssymbols) != Py_None);
+ __pyx_t_11 = (__pyx_t_10 != 0);
+ if (__pyx_t_11) {
+
+ /* "pywrapfst.pyx":1658
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL
+ * if ssymbols is not None:
+ * ssymbols_ptr = ssymbols._table # <<<<<<<<<<<<<<
+ * cdef stringstream sstrm
+ * fst.PrintFst(deref(self._fst), sstrm, "<pywrapfst>",
+ */
+ if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1658, __pyx_L1_error)
+ }
+ __pyx_t_12 = __pyx_v_ssymbols->_table;
+ __pyx_v_ssymbols_ptr = __pyx_t_12;
+
+ /* "pywrapfst.pyx":1657
+ * # Prints FST to stringstream, then returns resulting string.
+ * cdef fst.SymbolTable *ssymbols_ptr = NULL
+ * if ssymbols is not None: # <<<<<<<<<<<<<<
+ * ssymbols_ptr = ssymbols._table
+ * cdef stringstream sstrm
+ */
+ }
+
+ /* "pywrapfst.pyx":1660
+ * ssymbols_ptr = ssymbols._table
+ * cdef stringstream sstrm
+ * fst.PrintFst(deref(self._fst), sstrm, "<pywrapfst>", # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1660, __pyx_L1_error)
+ }
+ __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b_pywrapfst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1660, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1661
+ * cdef stringstream sstrm
+ * fst.PrintFst(deref(self._fst), sstrm, "<pywrapfst>",
+ * self._fst.get().InputSymbols() if isymbols is None # <<<<<<<<<<<<<<
+ * else isymbols._table,
+ * self._fst.get().OutputSymbols() if osymbols is None
+ */
+ __pyx_t_11 = (((PyObject *)__pyx_v_isymbols) == Py_None);
+ if ((__pyx_t_11 != 0)) {
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1661, __pyx_L1_error)
+ }
+ __pyx_t_13 = __pyx_v_self->_fst.get()->InputSymbols();
+ } else {
+
+ /* "pywrapfst.pyx":1662
+ * fst.PrintFst(deref(self._fst), sstrm, "<pywrapfst>",
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table, # <<<<<<<<<<<<<<
+ * self._fst.get().OutputSymbols() if osymbols is None
+ * else osymbols._table,
+ */
+ if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1662, __pyx_L1_error)
+ }
+ __pyx_t_13 = __pyx_v_isymbols->_table;
+ }
+
+ /* "pywrapfst.pyx":1663
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table,
+ * self._fst.get().OutputSymbols() if osymbols is None # <<<<<<<<<<<<<<
+ * else osymbols._table,
+ * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym))
+ */
+ __pyx_t_11 = (((PyObject *)__pyx_v_osymbols) == Py_None);
+ if ((__pyx_t_11 != 0)) {
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1663, __pyx_L1_error)
+ }
+ __pyx_t_14 = __pyx_v_self->_fst.get()->OutputSymbols();
+ } else {
+
+ /* "pywrapfst.pyx":1664
+ * else isymbols._table,
+ * self._fst.get().OutputSymbols() if osymbols is None
+ * else osymbols._table, # <<<<<<<<<<<<<<
+ * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym))
+ * return sstrm.str()
+ */
+ if (unlikely(((PyObject *)__pyx_v_osymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 1664, __pyx_L1_error)
+ }
+ __pyx_t_14 = __pyx_v_osymbols->_table;
+ }
+
+ /* "pywrapfst.pyx":1665
+ * self._fst.get().OutputSymbols() if osymbols is None
+ * else osymbols._table,
+ * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym)) # <<<<<<<<<<<<<<
+ * return sstrm.str()
+ *
+ */
+ __pyx_t_15 = __pyx_f_9pywrapfst_tostring(__pyx_v_missing_sym, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1665, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1660
+ * ssymbols_ptr = ssymbols._table
+ * cdef stringstream sstrm
+ * fst.PrintFst(deref(self._fst), sstrm, "<pywrapfst>", # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols() if isymbols is None
+ * else isymbols._table,
+ */
+ fst::script::PrintFst((*__pyx_v_self->_fst), __pyx_v_sstrm, __pyx_t_9, __pyx_t_13, __pyx_t_14, __pyx_v_ssymbols_ptr, __pyx_v_acceptor, __pyx_v_show_weight_one, __pyx_t_15);
+
+ /* "pywrapfst.pyx":1666
+ * else osymbols._table,
+ * ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym))
+ * return sstrm.str() # <<<<<<<<<<<<<<
+ *
+ * cpdef bool verify(self):
+ */
+ __pyx_r = __pyx_v_sstrm.str();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1631
+ * return StateIterator(self)
+ *
+ * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None,
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""):
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_WriteUnraisable("pywrapfst._Fst.text", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_37text(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_36text[] = "\n text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False,\n show_weight_one=False, missing_sym=\"\")\n\n Produces a human-readable string representation of the FST.\n\n This method generates a human-readable string representation of the FST.\n The caller may optionally specify SymbolTables used to label input labels,\n output labels, or state labels, respectively.\n\n Args:\n isymbols: An optional symbol table used to label input symbols.\n osymbols: An optional symbol table used to label output symbols.\n ssymbols: An optional symbol table used to label states.\n acceptor: Should the FST be rendered in acceptor format if possible?\n show_weight_one: Should weights equivalent to semiring One be printed?\n missing_symbol: The string to be printed when symbol table lookup fails.\n\n Returns:\n A formatted string representing the machine.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_37text(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols = 0;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols = 0;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols = 0;
+ bool __pyx_v_acceptor;
+ bool __pyx_v_show_weight_one;
+ PyObject *__pyx_v_missing_sym = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("text (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_isymbols,&__pyx_n_s_osymbols,&__pyx_n_s_ssymbols,&__pyx_n_s_acceptor,&__pyx_n_s_show_weight_one,&__pyx_n_s_missing_sym,0};
+ PyObject* values[6] = {0,0,0,0,0,0};
+ values[0] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":1632
+ *
+ * cpdef string text(self, _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None, # <<<<<<<<<<<<<<
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""):
+ * """
+ */
+ values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+ values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+ values[5] = ((PyObject *)__pyx_kp_b_);
+ 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);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_isymbols);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osymbols);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ssymbols);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acceptor);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_show_weight_one);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_missing_sym);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "text") < 0)) __PYX_ERR(0, 1631, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]);
+ __pyx_v_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]);
+ __pyx_v_ssymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[2]);
+ if (values[3]) {
+ __pyx_v_acceptor = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_acceptor == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1633, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":1633
+ * cpdef string text(self, _SymbolTable isymbols=None,
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None,
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""): # <<<<<<<<<<<<<<
+ * """
+ * text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False,
+ */
+ __pyx_v_acceptor = ((bool)0);
+ }
+ if (values[4]) {
+ __pyx_v_show_weight_one = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_show_weight_one == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1633, __pyx_L3_error)
+ } else {
+ __pyx_v_show_weight_one = ((bool)0);
+ }
+ __pyx_v_missing_sym = values[5];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("text", 0, 0, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1631, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._Fst.text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "isymbols", 0))) __PYX_ERR(0, 1631, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "osymbols", 0))) __PYX_ERR(0, 1632, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "ssymbols", 0))) __PYX_ERR(0, 1632, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_36text(((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":1631
+ * return StateIterator(self)
+ *
+ * cpdef string text(self, _SymbolTable isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable osymbols=None, _SymbolTable ssymbols=None,
+ * bool acceptor=False, bool show_weight_one=False, missing_sym=b""):
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_36text(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_show_weight_one, PyObject *__pyx_v_missing_sym) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ struct __pyx_opt_args_9pywrapfst_4_Fst_text __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("text", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 6;
+ __pyx_t_2.isymbols = __pyx_v_isymbols;
+ __pyx_t_2.osymbols = __pyx_v_osymbols;
+ __pyx_t_2.ssymbols = __pyx_v_ssymbols;
+ __pyx_t_2.acceptor = __pyx_v_acceptor;
+ __pyx_t_2.show_weight_one = __pyx_v_show_weight_one;
+ __pyx_t_2.missing_sym = __pyx_v_missing_sym;
+ __pyx_t_1 = __pyx_vtabptr_9pywrapfst__Fst->text(__pyx_v_self, 1, &__pyx_t_2);
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1631, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._Fst.text", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1668
+ * return sstrm.str()
+ *
+ * cpdef bool verify(self): # <<<<<<<<<<<<<<
+ * """
+ * verify(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_39verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_4_Fst_verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("verify", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_verify); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1668, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_39verify)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1668, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1668, __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, 1668, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1677
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 1677, __pyx_L1_error)
+ }
+ __pyx_r = fst::script::Verify((*__pyx_v_self->_fst));
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1668
+ * return sstrm.str()
+ *
+ * cpdef bool verify(self): # <<<<<<<<<<<<<<
+ * """
+ * verify(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst._Fst.verify", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_39verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_38verify[] = "\n verify(self)\n\n Verifies that an FST's contents are sane.\n\n Returns:\n True if the contents are sane, False otherwise.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_39verify(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("verify (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_38verify(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_38verify(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("verify", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_4_Fst_verify(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1668, __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":1679
+ * return fst.Verify(deref(self._fst))
+ *
+ * cpdef string weight_type(self): # <<<<<<<<<<<<<<
+ * """
+ * weight_type(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_41weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("weight_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_weight_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1679, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_41weight_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1679, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1679, __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, 1679, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1688
+ * A string representing the weight type.
+ * """
+ * return self._fst.get().WeightType() # <<<<<<<<<<<<<<
+ *
+ * cpdef void write(self, filename) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1688, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_fst.get()->WeightType();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1679
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_41weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_40weight_type[] = "\n weight_type(self)\n\n Provides the FST's weight type.\n\n Returns:\n A string representing the weight type.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_41weight_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("weight_type (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_40weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_40weight_type(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("weight_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_weight_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1679, __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":1690
+ * return self._fst.get().WeightType()
+ *
+ * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<<
+ * """
+ * write(self, filename)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_43write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/
+static void __pyx_f_9pywrapfst_4_Fst_write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ std::string __pyx_t_6;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("write", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1690, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_43write)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_filename); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1690, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1690, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1690, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1690, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_filename);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1690, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1704
+ * FstIOError: Write failed.
+ * """
+ * if not self._fst.get().Write(tostring(filename)): # <<<<<<<<<<<<<<
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1704, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1704, __pyx_L1_error)
+ __pyx_t_7 = ((!(__pyx_v_self->_fst.get()->Write(__pyx_t_6) != 0)) != 0);
+ if (__pyx_t_7) {
+
+ /* "pywrapfst.pyx":1705
+ * """
+ * if not self._fst.get().Write(tostring(filename)):
+ * raise FstIOError("Write failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ *
+ * cpdef string WriteToString(self):
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Write_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_filename};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1705, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 1705, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1704
+ * FstIOError: Write failed.
+ * """
+ * if not self._fst.get().Write(tostring(filename)): # <<<<<<<<<<<<<<
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ */
+ }
+
+ /* "pywrapfst.pyx":1690
+ * return self._fst.get().WeightType()
+ *
+ * cpdef void write(self, filename) except *: # <<<<<<<<<<<<<<
+ * """
+ * write(self, filename)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._Fst.write", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_43write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename); /*proto*/
+static char __pyx_doc_9pywrapfst_4_Fst_42write[] = "\n write(self, filename)\n\n Serializes FST to a file.\n\n This method writes the FST to a file in a binary format.\n\n Args:\n filename: The string location of the output file.\n\n Raises:\n FstIOError: Write failed.\n ";
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_43write(PyObject *__pyx_v_self, PyObject *__pyx_v_filename) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("write (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_42write(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), ((PyObject *)__pyx_v_filename));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_42write(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, PyObject *__pyx_v_filename) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("write", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_f_9pywrapfst_4_Fst_write(__pyx_v_self, __pyx_v_filename, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1690, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1690, __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":1707
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ * cpdef string WriteToString(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().WriteToString()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_45WriteToString(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_4_Fst_WriteToString(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("WriteToString", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_WriteToString); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1707, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_45WriteToString)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1707, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1707, __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, 1707, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1708
+ *
+ * cpdef string WriteToString(self):
+ * return self._fst.get().WriteToString() # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1708, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_fst.get()->WriteToString();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1707
+ * raise FstIOError("Write failed: {!r}".format(filename))
+ *
+ * cpdef string WriteToString(self): # <<<<<<<<<<<<<<
+ * return self._fst.get().WriteToString()
+ *
+ */
+
+ /* 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.WriteToString", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_45WriteToString(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_4_Fst_45WriteToString(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("WriteToString (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_4_Fst_44WriteToString(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_4_Fst_44WriteToString(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("WriteToString", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_4_Fst_WriteToString(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1707, __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.WriteToString", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1721
+ * """
+ *
+ * cdef void _check_mutating_imethod(self) except *: # <<<<<<<<<<<<<<
+ * """Checks whether an operation mutating the FST has produced an error.
+ *
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__check_mutating_imethod(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("_check_mutating_imethod", 0);
+
+ /* "pywrapfst.pyx":1726
+ * This function is not visible to Python users.
+ * """
+ * if self._fst.get().Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<<
+ * raise FstOpError("Operation failed")
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1726, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((__pyx_v_self->__pyx_base._fst.get()->Properties(fst::kError, 1) == fst::kError) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":1727
+ * """
+ * if self._fst.get().Properties(fst.kError, True) == fst.kError:
+ * raise FstOpError("Operation failed") # <<<<<<<<<<<<<<
+ *
+ * cdef void _add_arc(self, int64 state, Arc arc) except *:
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1727, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1727, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 1727, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1726
+ * This function is not visible to Python users.
+ * """
+ * if self._fst.get().Properties(fst.kError, True) == fst.kError: # <<<<<<<<<<<<<<
+ * raise FstOpError("Operation failed")
+ *
+ */
+ }
+
+ /* "pywrapfst.pyx":1721
+ * """
+ *
+ * cdef void _check_mutating_imethod(self) except *: # <<<<<<<<<<<<<<
+ * """Checks whether an operation mutating the FST has produced an error.
+ *
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._check_mutating_imethod", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1729
+ * raise FstOpError("Operation failed")
+ *
+ * cdef void _add_arc(self, int64 state, Arc arc) except *: # <<<<<<<<<<<<<<
+ * if not self._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("_add_arc", 0);
+
+ /* "pywrapfst.pyx":1730
+ *
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 1730, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_self->__pyx_base._fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":1731
+ * cdef void _add_arc(self, int64 state, Arc arc) except *:
+ * if not self._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * if not self._mfst.get().AddArc(state, deref(arc._arc)):
+ * raise FstOpError("Incompatible or invalid weight type")
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1731, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1731, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 1731, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1730
+ *
+ * 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":1732
+ * if not self._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ * if not self._mfst.get().AddArc(state, deref(arc._arc)): # <<<<<<<<<<<<<<
+ * raise FstOpError("Incompatible or invalid weight type")
+ * self._check_mutating_imethod()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1732, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_arc) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc");
+ __PYX_ERR(0, 1732, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->AddArc(__pyx_v_state, (*__pyx_v_arc->_arc)) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":1733
+ * raise FstIndexError("State index out of range")
+ * if not self._mfst.get().AddArc(state, deref(arc._arc)):
+ * raise FstOpError("Incompatible or invalid weight type") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1733, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1733, __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, 1733, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1732
+ * if not self._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ * if not self._mfst.get().AddArc(state, deref(arc._arc)): # <<<<<<<<<<<<<<
+ * raise FstOpError("Incompatible or invalid weight type")
+ * self._check_mutating_imethod()
+ */
+ }
+
+ /* "pywrapfst.pyx":1734
+ * if not self._mfst.get().AddArc(state, deref(arc._arc)):
+ * raise FstOpError("Incompatible or invalid weight type")
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def add_arc(self, int64 state, Arc arc):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1734, __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, 1734, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1729
+ * raise FstOpError("Operation failed")
+ *
+ * cdef void _add_arc(self, int64 state, Arc arc) except *: # <<<<<<<<<<<<<<
+ * if not self._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1736
+ * self._check_mutating_imethod()
+ *
+ * def add_arc(self, int64 state, Arc arc): # <<<<<<<<<<<<<<
+ * """
+ * add_arc(self, state, arc)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_1add_arc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_add_arc[] = "\n add_arc(self, state, arc)\n\n Adds a new arc to the FST and return self.\n\n Args:\n state: The integer index of the source state.\n arc: The arc to add.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n FstOpdexError: Incompatible or invalid weight type.\n\n See also: `add_state`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_1add_arc(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("add_arc (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_arc,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("add_arc", 1, 2, 2, 1); __PYX_ERR(0, 1736, __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, 1736, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1736, __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, 1736, __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, 1736, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_add_arc(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_arc);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_add_arc(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("add_arc", 0);
+
+ /* "pywrapfst.pyx":1755
+ * See also: `add_state`.
+ * """
+ * self._add_arc(state, arc) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_add_arc");
+ __PYX_ERR(0, 1755, __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, 1755, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1756
+ * """
+ * self._add_arc(state, arc)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cpdef int64 add_state(self) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1736
+ * self._check_mutating_imethod()
+ *
+ * def add_arc(self, int64 state, Arc arc): # <<<<<<<<<<<<<<
+ * """
+ * add_arc(self, state, arc)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.add_arc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1758
+ * return self
+ *
+ * cpdef int64 add_state(self) except *: # <<<<<<<<<<<<<<
+ * """
+ * add_state(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_int64 __pyx_v_result;
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_5;
+ __Pyx_RefNannySetupContext("add_state", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1758, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_3add_state)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1758, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1758, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1758, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":1769
+ * See also: `add_arc`, `set_start`, `set_final`.
+ * """
+ * cdef int64 result = self._mfst.get().AddState() # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ * return result
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1769, __pyx_L1_error)
+ }
+ __pyx_v_result = __pyx_v_self->_mfst.get()->AddState();
+
+ /* "pywrapfst.pyx":1770
+ * """
+ * cdef int64 result = self._mfst.get().AddState()
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1770, __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, 1770, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1771
+ * cdef int64 result = self._mfst.get().AddState()
+ * self._check_mutating_imethod()
+ * return result # <<<<<<<<<<<<<<
+ *
+ * cdef void _arcsort(self, st=b"ilabel") except *:
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1758
+ * return self
+ *
+ * cpdef int64 add_state(self) except *: # <<<<<<<<<<<<<<
+ * """
+ * add_state(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._MutableFst.add_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_2add_state[] = "\n add_state(self)\n\n Adds a new state to the FST and returns the state ID.\n\n Returns:\n The integer index of the new state.\n\n See also: `add_arc`, `set_start`, `set_final`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_3add_state(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("add_state (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_2add_state(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_2add_state(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __pyx_t_10basictypes_int64 __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("add_state", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_f_9pywrapfst_11_MutableFst_add_state(__pyx_v_self, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1758, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1758, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("pywrapfst._MutableFst.add_state", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1773
+ * return result
+ *
+ * cdef void _arcsort(self, st=b"ilabel") except *: # <<<<<<<<<<<<<<
+ * cdef fst.ArcSortType sort_type
+ * if not fst.GetArcSortType(tostring(st), addr(sort_type)):
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args) {
+ PyObject *__pyx_v_st = ((PyObject *)__pyx_n_b_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;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ __Pyx_RefNannySetupContext("_arcsort", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_st = __pyx_optional_args->st;
+ }
+ }
+
+ /* "pywrapfst.pyx":1775
+ * cdef void _arcsort(self, st=b"ilabel") except *:
+ * cdef fst.ArcSortType sort_type
+ * if not fst.GetArcSortType(tostring(st), addr(sort_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown sort type {!r}".format(sort_type))
+ * fst.ArcSort(self._mfst.get(), sort_type)
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_st, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1775, __pyx_L1_error)
+ __pyx_t_2 = ((!(fst::script::GetArcSortType(__pyx_t_1, (&__pyx_v_sort_type)) != 0)) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":1776
+ * cdef fst.ArcSortType sort_type
+ * if not fst.GetArcSortType(tostring(st), addr(sort_type)):
+ * raise FstArgError("Unknown sort type {!r}".format(sort_type)) # <<<<<<<<<<<<<<
+ * fst.ArcSort(self._mfst.get(), sort_type)
+ * self._check_mutating_imethod()
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_sort_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = __Pyx_PyInt_From_enum__fst_3a__3a_script_3a__3a_ArcSortType(__pyx_v_sort_type); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_8)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_8) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_7};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_7};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_7);
+ __pyx_t_7 = 0;
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1776, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 1776, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1775
+ * cdef void _arcsort(self, st=b"ilabel") except *:
+ * cdef fst.ArcSortType sort_type
+ * if not fst.GetArcSortType(tostring(st), addr(sort_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown sort type {!r}".format(sort_type))
+ * fst.ArcSort(self._mfst.get(), sort_type)
+ */
+ }
+
+ /* "pywrapfst.pyx":1777
+ * if not fst.GetArcSortType(tostring(st), addr(sort_type)):
+ * raise FstArgError("Unknown sort type {!r}".format(sort_type))
+ * fst.ArcSort(self._mfst.get(), sort_type) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1777, __pyx_L1_error)
+ }
+ fst::script::ArcSort(__pyx_v_self->_mfst.get(), __pyx_v_sort_type);
+
+ /* "pywrapfst.pyx":1778
+ * raise FstArgError("Unknown sort type {!r}".format(sort_type))
+ * fst.ArcSort(self._mfst.get(), sort_type)
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def arcsort(self, st=b"ilabel"):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1778, __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, 1778, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1773
+ * return result
+ *
+ * cdef void _arcsort(self, st=b"ilabel") except *: # <<<<<<<<<<<<<<
+ * cdef fst.ArcSortType sort_type
+ * if not fst.GetArcSortType(tostring(st), 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_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._arcsort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1780
+ * self._check_mutating_imethod()
+ *
+ * def arcsort(self, st=b"ilabel"): # <<<<<<<<<<<<<<
+ * """
+ * arcsort(self, st="ilabel")
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_5arcsort(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_4arcsort[] = "\n arcsort(self, st=\"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 st: Either \"ilabel\" (sort arcs according to input labels) or\n \"olabel\" (sort arcs according to output labels).\n\n Returns:\n self.\n\n Raises:\n FstArgError: Unknown sort type.\n\n See also: `topsort`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_5arcsort(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_st = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("arcsort (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_st,0};
+ PyObject* values[1] = {0};
+ values[0] = ((PyObject *)__pyx_n_b_ilabel);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_st);
+ 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, 1780, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_st = 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, 1780, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.arcsort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_4arcsort(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_st);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_4arcsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_st) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort __pyx_t_1;
+ __Pyx_RefNannySetupContext("arcsort", 0);
+
+ /* "pywrapfst.pyx":1801
+ * See also: `topsort`.
+ * """
+ * self._arcsort(st) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arcsort");
+ __PYX_ERR(0, 1801, __pyx_L1_error)
+ }
+ __pyx_t_1.__pyx_n = 1;
+ __pyx_t_1.st = __pyx_v_st;
+ ((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, 1801, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1802
+ * """
+ * self._arcsort(st)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _closure(self, bool closure_plus=False) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1780
+ * self._check_mutating_imethod()
+ *
+ * def arcsort(self, st=b"ilabel"): # <<<<<<<<<<<<<<
+ * """
+ * arcsort(self, st="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":1804
+ * return self
+ *
+ * cdef void _closure(self, bool closure_plus=False) except *: # <<<<<<<<<<<<<<
+ * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus))
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args) {
+ bool __pyx_v_closure_plus = ((bool)0);
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_closure", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_closure_plus = __pyx_optional_args->closure_plus;
+ }
+ }
+
+ /* "pywrapfst.pyx":1805
+ *
+ * cdef void _closure(self, bool closure_plus=False) except *:
+ * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus)) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1805, __pyx_L1_error)
+ }
+ fst::script::Closure(__pyx_v_self->_mfst.get(), fst::script::GetClosureType(__pyx_v_closure_plus));
+
+ /* "pywrapfst.pyx":1806
+ * cdef void _closure(self, bool closure_plus=False) except *:
+ * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus))
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def closure(self, bool closure_plus=False):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1806, __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, 1806, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1804
+ * return self
+ *
+ * cdef void _closure(self, bool closure_plus=False) except *: # <<<<<<<<<<<<<<
+ * fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus))
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._closure", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1808
+ * self._check_mutating_imethod()
+ *
+ * def closure(self, bool closure_plus=False): # <<<<<<<<<<<<<<
+ * """
+ * closure(self, closure_plus=False)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_7closure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_6closure[] = "\n closure(self, closure_plus=False)\n\n Computes concatenative closure.\n\n This operation destructively converts the FST to its concatenative closure.\n If A transduces string x to y with weight a, then the closure transduces x\n to y with weight a, xx to yy with weight a \\otimes a, xxx to yyy with weight\n a \\otimes a \\otimes a, and so on. The empty string is also transduced to\n itself with semiring One if `closure_plus` is False.\n\n Args:\n closure_plus: If False, do not accept the empty string.\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_7closure(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ bool __pyx_v_closure_plus;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("closure (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_closure_plus,0};
+ PyObject* values[1] = {0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_closure_plus);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "closure") < 0)) __PYX_ERR(0, 1808, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 1808, __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, 1808, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.closure", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_6closure(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_closure_plus);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_6closure(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_closure_plus) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure __pyx_t_1;
+ __Pyx_RefNannySetupContext("closure", 0);
+
+ /* "pywrapfst.pyx":1826
+ * self.
+ * """
+ * self._closure(closure_plus) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_closure");
+ __PYX_ERR(0, 1826, __pyx_L1_error)
+ }
+ __pyx_t_1.__pyx_n = 1;
+ __pyx_t_1.closure_plus = __pyx_v_closure_plus;
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_closure(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1826, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1827
+ * """
+ * self._closure(closure_plus)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _concat(self, _Fst ifst) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1808
+ * self._check_mutating_imethod()
+ *
+ * def closure(self, bool closure_plus=False): # <<<<<<<<<<<<<<
+ * """
+ * closure(self, closure_plus=False)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.closure", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1829
+ * return self
+ *
+ * cdef void _concat(self, _Fst ifst) except *: # <<<<<<<<<<<<<<
+ * fst.Concat(self._mfst.get(), deref(ifst._fst))
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_concat", 0);
+
+ /* "pywrapfst.pyx":1830
+ *
+ * cdef void _concat(self, _Fst ifst) except *:
+ * fst.Concat(self._mfst.get(), deref(ifst._fst)) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1830, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 1830, __pyx_L1_error)
+ }
+ fst::script::Concat(__pyx_v_self->_mfst.get(), (*__pyx_v_ifst->_fst));
+
+ /* "pywrapfst.pyx":1831
+ * cdef void _concat(self, _Fst ifst) except *:
+ * fst.Concat(self._mfst.get(), deref(ifst._fst))
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def concat(self, _Fst ifst):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1831, __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, 1831, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1829
+ * return self
+ *
+ * cdef void _concat(self, _Fst ifst) except *: # <<<<<<<<<<<<<<
+ * fst.Concat(self._mfst.get(), deref(ifst._fst))
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._concat", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1833
+ * self._check_mutating_imethod()
+ *
+ * def concat(self, _Fst ifst): # <<<<<<<<<<<<<<
+ * """
+ * concat(self, ifst)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_9concat(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_8concat[] = "\n concat(self, ifst)\n\n Computes the concatenation (product) of two FSTs.\n\n This operation destructively concatenates the FST with a second FST. If A\n transduces string x to y with weight a and B transduces string w to v with\n weight b, then their concatenation transduces string xw to yv with weight a\n \\otimes b.\n\n Args:\n ifst: The second input FST.\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_9concat(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("concat (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 1833, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_8concat(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_ifst));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_8concat(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("concat", 0);
+
+ /* "pywrapfst.pyx":1850
+ * self.
+ * """
+ * self._concat(ifst) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_concat");
+ __PYX_ERR(0, 1850, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_concat(__pyx_v_self, __pyx_v_ifst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1850, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1851
+ * """
+ * self._concat(ifst)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _connect(self) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1833
+ * self._check_mutating_imethod()
+ *
+ * def concat(self, _Fst ifst): # <<<<<<<<<<<<<<
+ * """
+ * concat(self, ifst)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.concat", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1853
+ * return self
+ *
+ * cdef void _connect(self) except *: # <<<<<<<<<<<<<<
+ * fst.Connect(self._mfst.get())
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_connect", 0);
+
+ /* "pywrapfst.pyx":1854
+ *
+ * cdef void _connect(self) except *:
+ * fst.Connect(self._mfst.get()) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1854, __pyx_L1_error)
+ }
+ fst::script::Connect(__pyx_v_self->_mfst.get());
+
+ /* "pywrapfst.pyx":1855
+ * cdef void _connect(self) except *:
+ * fst.Connect(self._mfst.get())
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def connect(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1855, __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, 1855, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1853
+ * return self
+ *
+ * cdef void _connect(self) except *: # <<<<<<<<<<<<<<
+ * fst.Connect(self._mfst.get())
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1857
+ * self._check_mutating_imethod()
+ *
+ * def connect(self): # <<<<<<<<<<<<<<
+ * """
+ * connect(self)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_11connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_10connect[] = "\n connect(self)\n\n Removes unsuccessful paths.\n\n This operation destructively trims the FST, removing states and arcs that\n are not part of any successful path.\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_11connect(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("connect (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_10connect(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_10connect(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("connect", 0);
+
+ /* "pywrapfst.pyx":1869
+ * self.
+ * """
+ * self._connect() # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_connect");
+ __PYX_ERR(0, 1869, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_connect(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1869, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1870
+ * """
+ * self._connect()
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _decode(self, EncodeMapper encoder) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1857
+ * self._check_mutating_imethod()
+ *
+ * def connect(self): # <<<<<<<<<<<<<<
+ * """
+ * connect(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1872
+ * return self
+ *
+ * cdef void _decode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<<
+ * fst.Decode(self._mfst.get(), deref(encoder._encoder))
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_decode", 0);
+
+ /* "pywrapfst.pyx":1873
+ *
+ * cdef void _decode(self, EncodeMapper encoder) except *:
+ * fst.Decode(self._mfst.get(), deref(encoder._encoder)) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1873, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_encoder) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1873, __pyx_L1_error)
+ }
+ fst::script::Decode(__pyx_v_self->_mfst.get(), (*__pyx_v_encoder->_encoder));
+
+ /* "pywrapfst.pyx":1874
+ * cdef void _decode(self, EncodeMapper encoder) except *:
+ * fst.Decode(self._mfst.get(), deref(encoder._encoder))
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def decode(self, EncodeMapper encoder):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1874, __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, 1874, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1872
+ * return self
+ *
+ * cdef void _decode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<<
+ * fst.Decode(self._mfst.get(), deref(encoder._encoder))
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._decode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1876
+ * self._check_mutating_imethod()
+ *
+ * def decode(self, EncodeMapper encoder): # <<<<<<<<<<<<<<
+ * """
+ * decode(self, encoder)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_13decode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_12decode[] = "\n decode(self, encoder)\n\n Decodes encoded labels and/or weights.\n\n This operation reverses the encoding performed by `encode`.\n\n Args:\n encoder: An EncodeMapper object used to encode the FST.\n\n Returns:\n self.\n\n See also: `encode`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_13decode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("decode (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_encoder), __pyx_ptype_9pywrapfst_EncodeMapper, 1, "encoder", 0))) __PYX_ERR(0, 1876, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_12decode(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_encoder));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_12decode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("decode", 0);
+
+ /* "pywrapfst.pyx":1892
+ * See also: `encode`.
+ * """
+ * self._decode(encoder) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_decode");
+ __PYX_ERR(0, 1892, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_decode(__pyx_v_self, __pyx_v_encoder); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1892, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1893
+ * """
+ * self._decode(encoder)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _delete_arcs(self, int64 state, size_t n=0) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1876
+ * self._check_mutating_imethod()
+ *
+ * def decode(self, EncodeMapper encoder): # <<<<<<<<<<<<<<
+ * """
+ * decode(self, encoder)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.decode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1895
+ * return self
+ *
+ * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: # <<<<<<<<<<<<<<
+ * if not (self._mfst.get().DeleteArcs(state, n) if n else
+ * self._mfst.get().DeleteArcs(state)):
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args) {
+ size_t __pyx_v_n = ((size_t)0);
+ __Pyx_RefNannyDeclarations
+ bool __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("_delete_arcs", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_n = __pyx_optional_args->n;
+ }
+ }
+
+ /* "pywrapfst.pyx":1896
+ *
+ * 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 '%s'", "_mfst");
+ __PYX_ERR(0, 1896, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_v_self->_mfst.get()->DeleteArcs(__pyx_v_state, __pyx_v_n);
+ } else {
+
+ /* "pywrapfst.pyx":1897
+ * 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 '%s'", "_mfst");
+ __PYX_ERR(0, 1897, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_v_self->_mfst.get()->DeleteArcs(__pyx_v_state);
+ }
+
+ /* "pywrapfst.pyx":1896
+ *
+ * cdef void _delete_arcs(self, int64 state, size_t n=0) except *:
+ * if not (self._mfst.get().DeleteArcs(state, n) if n else # <<<<<<<<<<<<<<
+ * self._mfst.get().DeleteArcs(state)):
+ * raise FstIndexError("State index out of range")
+ */
+ __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":1898
+ * if not (self._mfst.get().DeleteArcs(state, n) if n else
+ * self._mfst.get().DeleteArcs(state)):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1898, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1898, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 1898, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1896
+ *
+ * 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":1899
+ * 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 '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1899, __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, 1899, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1895
+ * return self
+ *
+ * cdef void _delete_arcs(self, int64 state, size_t n=0) except *: # <<<<<<<<<<<<<<
+ * if not (self._mfst.get().DeleteArcs(state, n) if n else
+ * self._mfst.get().DeleteArcs(state)):
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._delete_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1901
+ * self._check_mutating_imethod()
+ *
+ * def delete_arcs(self, int64 state, size_t n=0): # <<<<<<<<<<<<<<
+ * """
+ * delete_arcs(self, state, n=0)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_15delete_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_14delete_arcs[] = "\n delete_arcs(self, state, n=0)\n\n Deletes arcs leaving a particular state.\n\n Args:\n state: The integer index of a state.\n n: An optional argument indicating how many arcs to be deleted. If this\n argument is omitted or passed as zero, all arcs from this state are\n deleted.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `delete_states`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_15delete_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ size_t __pyx_v_n;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("delete_arcs (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_n,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "delete_arcs") < 0)) __PYX_ERR(0, 1901, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1901, __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, 1901, __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, 1901, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.delete_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_14delete_arcs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_n);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_14delete_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs __pyx_t_1;
+ __Pyx_RefNannySetupContext("delete_arcs", 0);
+
+ /* "pywrapfst.pyx":1921
+ * See also: `delete_states`.
+ * """
+ * self._delete_arcs(state, n) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_delete_arcs");
+ __PYX_ERR(0, 1921, __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, 1921, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1922
+ * """
+ * 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":1901
+ * 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":1924
+ * return self
+ *
+ * cdef void _delete_states(self, states=None) except *: # <<<<<<<<<<<<<<
+ * # Only the former signature has a possible indexing failure.
+ * if states:
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args) {
+ PyObject *__pyx_v_states = ((PyObject *)Py_None);
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ std::vector<__pyx_t_10basictypes_int64> __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("_delete_states", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_states = __pyx_optional_args->states;
+ }
+ }
+
+ /* "pywrapfst.pyx":1926
+ * 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(<const vector[int64]> 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, 1926, __pyx_L1_error)
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":1927
+ * # Only the former signature has a possible indexing failure.
+ * if states:
+ * if not self._mfst.get().DeleteStates(<const vector[int64]> 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 '%s'", "_mfst");
+ __PYX_ERR(0, 1927, __pyx_L1_error)
+ }
+ __pyx_t_2 = __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(__pyx_v_states); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1927, __pyx_L1_error)
+ __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->DeleteStates(((std::vector<__pyx_t_10basictypes_int64> const )__pyx_t_2)) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":1928
+ * if states:
+ * if not self._mfst.get().DeleteStates(<const vector[int64]> states):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * else:
+ * self._mfst.get().DeleteStates()
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1928, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1928, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 1928, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1927
+ * # Only the former signature has a possible indexing failure.
+ * if states:
+ * if not self._mfst.get().DeleteStates(<const vector[int64]> states): # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * else:
+ */
+ }
+
+ /* "pywrapfst.pyx":1926
+ * 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(<const vector[int64]> states):
+ * raise FstIndexError("State index out of range")
+ */
+ goto __pyx_L3;
+ }
+
+ /* "pywrapfst.pyx":1930
+ * 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 '%s'", "_mfst");
+ __PYX_ERR(0, 1930, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst.get()->DeleteStates();
+ }
+ __pyx_L3:;
+
+ /* "pywrapfst.pyx":1931
+ * 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 '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1931, __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, 1931, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1924
+ * return self
+ *
+ * cdef void _delete_states(self, states=None) except *: # <<<<<<<<<<<<<<
+ * # Only the former signature has a possible indexing failure.
+ * if states:
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._delete_states", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1933
+ * self._check_mutating_imethod()
+ *
+ * def delete_states(self, states=None): # <<<<<<<<<<<<<<
+ * """
+ * delete_states(self, states=None)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_17delete_states(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_16delete_states[] = "\n delete_states(self, states=None)\n\n Deletes states.\n\n Args:\n states: An optional iterable of integer indices of the states to be\n deleted. If this argument is omitted, all states are deleted.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `delete_arcs`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_17delete_states(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_states = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("delete_states (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_states,0};
+ PyObject* values[1] = {0};
+ values[0] = ((PyObject *)Py_None);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_states);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "delete_states") < 0)) __PYX_ERR(0, 1933, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 1933, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.delete_states", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_16delete_states(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_states);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_16delete_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_states) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states __pyx_t_1;
+ __Pyx_RefNannySetupContext("delete_states", 0);
+
+ /* "pywrapfst.pyx":1951
+ * See also: `delete_arcs`.
+ * """
+ * self._delete_states(states) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_delete_states");
+ __PYX_ERR(0, 1951, __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, 1951, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1952
+ * """
+ * self._delete_states(states)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _encode(self, EncodeMapper encoder) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1933
+ * 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":1954
+ * return self
+ *
+ * cdef void _encode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<<
+ * fst.Encode(self._mfst.get(), encoder._encoder.get())
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_encode", 0);
+
+ /* "pywrapfst.pyx":1955
+ *
+ * cdef void _encode(self, EncodeMapper encoder) except *:
+ * fst.Encode(self._mfst.get(), encoder._encoder.get()) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1955, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_encoder) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encoder");
+ __PYX_ERR(0, 1955, __pyx_L1_error)
+ }
+ fst::script::Encode(__pyx_v_self->_mfst.get(), __pyx_v_encoder->_encoder.get());
+
+ /* "pywrapfst.pyx":1956
+ * cdef void _encode(self, EncodeMapper encoder) except *:
+ * fst.Encode(self._mfst.get(), encoder._encoder.get())
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def encode(self, EncodeMapper encoder):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1956, __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, 1956, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1954
+ * return self
+ *
+ * cdef void _encode(self, EncodeMapper encoder) except *: # <<<<<<<<<<<<<<
+ * fst.Encode(self._mfst.get(), encoder._encoder.get())
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._encode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1958
+ * self._check_mutating_imethod()
+ *
+ * def encode(self, EncodeMapper encoder): # <<<<<<<<<<<<<<
+ * """
+ * encode(self, encoder)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_19encode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_18encode[] = "\n encode(self, encoder)\n\n Encodes labels and/or weights.\n\n This operation allows for the representation of a weighted transducer as a\n weighted acceptor, an unweighted transducer, or an unweighted acceptor by\n considering the pair (input label, output label), the pair (input label,\n weight), or the triple (input label, output label, weight) as a single\n label. Applying this operation mutates the EncodeMapper argument, which\n can then be used to decode.\n\n Args:\n encoder: An EncodeMapper object to be used as the encoder.\n\n Returns:\n self.\n\n See also: `decode`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_19encode(PyObject *__pyx_v_self, PyObject *__pyx_v_encoder) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("encode (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_encoder), __pyx_ptype_9pywrapfst_EncodeMapper, 1, "encoder", 0))) __PYX_ERR(0, 1958, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_18encode(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst_EncodeMapper *)__pyx_v_encoder));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_18encode(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst_EncodeMapper *__pyx_v_encoder) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("encode", 0);
+
+ /* "pywrapfst.pyx":1979
+ * See also: `decode`.
+ * """
+ * self._encode(encoder) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_encode");
+ __PYX_ERR(0, 1979, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_encode(__pyx_v_self, __pyx_v_encoder); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1979, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1980
+ * """
+ * self._encode(encoder)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _invert(self) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1958
+ * self._check_mutating_imethod()
+ *
+ * def encode(self, EncodeMapper encoder): # <<<<<<<<<<<<<<
+ * """
+ * encode(self, encoder)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.encode", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":1982
+ * return self
+ *
+ * cdef void _invert(self) except *: # <<<<<<<<<<<<<<
+ * fst.Invert(self._mfst.get())
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_invert", 0);
+
+ /* "pywrapfst.pyx":1983
+ *
+ * cdef void _invert(self) except *:
+ * fst.Invert(self._mfst.get()) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 1983, __pyx_L1_error)
+ }
+ fst::script::Invert(__pyx_v_self->_mfst.get());
+
+ /* "pywrapfst.pyx":1984
+ * cdef void _invert(self) except *:
+ * fst.Invert(self._mfst.get())
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def invert(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 1984, __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, 1984, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1982
+ * return self
+ *
+ * cdef void _invert(self) except *: # <<<<<<<<<<<<<<
+ * fst.Invert(self._mfst.get())
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._invert", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":1986
+ * self._check_mutating_imethod()
+ *
+ * def invert(self): # <<<<<<<<<<<<<<
+ * """
+ * invert(self)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_21invert(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_20invert[] = "\n invert(self)\n\n Inverts the FST's transduction.\n\n This operation destructively inverts the FST's transduction by exchanging\n input and output labels.\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_21invert(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("invert (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_20invert(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_20invert(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("invert", 0);
+
+ /* "pywrapfst.pyx":1998
+ * self.
+ * """
+ * self._invert() # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_invert");
+ __PYX_ERR(0, 1998, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_invert(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1998, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":1999
+ * """
+ * self._invert()
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _minimize(self, float delta=fst.kDelta,
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":1986
+ * self._check_mutating_imethod()
+ *
+ * def invert(self): # <<<<<<<<<<<<<<
+ * """
+ * invert(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.invert", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2001
+ * return self
+ *
+ * cdef void _minimize(self, float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * bool allow_nondet=False) except *:
+ * # This runs in-place when the second argument is null.
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args) {
+ float __pyx_v_delta = __pyx_k__11;
+
+ /* "pywrapfst.pyx":2002
+ *
+ * cdef void _minimize(self, float delta=fst.kDelta,
+ * bool allow_nondet=False) except *: # <<<<<<<<<<<<<<
+ * # This runs in-place when the second argument is null.
+ * fst.Minimize(self._mfst.get(), NULL, delta, allow_nondet)
+ */
+ bool __pyx_v_allow_nondet = ((bool)0);
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_minimize", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_allow_nondet = __pyx_optional_args->allow_nondet;
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":2004
+ * 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 '%s'", "_mfst");
+ __PYX_ERR(0, 2004, __pyx_L1_error)
+ }
+ fst::script::Minimize(__pyx_v_self->_mfst.get(), NULL, __pyx_v_delta, __pyx_v_allow_nondet);
+
+ /* "pywrapfst.pyx":2005
+ * # 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.kDelta, bool allow_nondet=False):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2005, __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, 2005, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2001
+ * return self
+ *
+ * cdef void _minimize(self, float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * bool allow_nondet=False) except *:
+ * # This runs in-place when the second argument is null.
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._minimize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2007
+ * self._check_mutating_imethod()
+ *
+ * def minimize(self, float delta=fst.kDelta, bool allow_nondet=False): # <<<<<<<<<<<<<<
+ * """
+ * minimize(self, delta=0.0009765625, allow_nondet=False)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_23minimize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_22minimize[] = "\n minimize(self, delta=0.0009765625, allow_nondet=False)\n\n Minimizes the FST.\n\n This operation destructively performs the minimization of deterministic\n weighted automata and transducers. If the input FST A is an acceptor, this\n operation produces the minimal acceptor B equivalent to A, i.e. the\n acceptor with a minimal number of states that is equivalent to A. If the\n input FST A is a transducer, this operation internally builds an equivalent\n transducer with a minimal number of states. However, this minimality is\n obtained by allowing transition having strings of symbols as output labels,\n this known in the litterature as a real-time transducer. Such transducers\n are not directly supported by the library. This function will convert such\n transducer by expanding each string-labeled transition into a sequence of\n transitions. This will results in the creation of new states, hence losing\n the minimality property.\n\n Args:\n delta: Comparison/quantization delta.\n allow_nondet: Attempt minimization of non-deterministic FST?\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_23minimize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ float __pyx_v_delta;
+ CYTHON_UNUSED bool __pyx_v_allow_nondet;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("minimize (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_allow_nondet,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_nondet);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "minimize") < 0)) __PYX_ERR(0, 2007, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 2007, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__12;
+ }
+ 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, 2007, __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, 2007, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.minimize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_22minimize(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_allow_nondet);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_22minimize(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, CYTHON_UNUSED bool __pyx_v_allow_nondet) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize __pyx_t_1;
+ __Pyx_RefNannySetupContext("minimize", 0);
+
+ /* "pywrapfst.pyx":2033
+ * self.
+ * """
+ * self._minimize(delta) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_minimize");
+ __PYX_ERR(0, 2033, __pyx_L1_error)
+ }
+ __pyx_t_1.__pyx_n = 1;
+ __pyx_t_1.delta = __pyx_v_delta;
+ ((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, 2033, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2034
+ * """
+ * self._minimize(delta)
+ * 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":2007
+ * self._check_mutating_imethod()
+ *
+ * def minimize(self, float delta=fst.kDelta, bool allow_nondet=False): # <<<<<<<<<<<<<<
+ * """
+ * minimize(self, delta=0.0009765625, 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":2036
+ * return self
+ *
+ * cpdef MutableArcIterator mutable_arcs(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * mutable_arcs(self, state)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("mutable_arcs", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_mutable_arcs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst_MutableArcIterator))))) __PYX_ERR(0, 2036, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2051
+ * See also: `arcs`, `states`.
+ * """
+ * return MutableArcIterator(self, state) # <<<<<<<<<<<<<<
+ *
+ * def mutable_input_symbols(self):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2051, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2051, __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, 2051, __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":2036
+ * return self
+ *
+ * cpdef MutableArcIterator mutable_arcs(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * mutable_arcs(self, state)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst._MutableFst.mutable_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_24mutable_arcs[] = "\n mutable_arcs(self, state)\n\n Returns a iterator over arcs leaving some state which supports\n arc mutation.\n\n Args:\n s: The source state ID.\n\n Returns:\n A MutableArcIterator over arcs leaving state `s`.\n\n See also: `arcs`, `states`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("mutable_arcs (wrapper)", 0);
+ assert(__pyx_arg_state); {
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2036, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.mutable_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_24mutable_arcs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_24mutable_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("mutable_arcs", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs(__pyx_v_self, __pyx_v_state, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2036, __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":2053
+ * return MutableArcIterator(self, state)
+ *
+ * def mutable_input_symbols(self): # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols()
+ * if tst == NULL:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_27mutable_input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_27mutable_input_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("mutable_input_symbols (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_26mutable_input_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_26mutable_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ fst::SymbolTable *__pyx_v_tst;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("mutable_input_symbols", 0);
+
+ /* "pywrapfst.pyx":2054
+ *
+ * def mutable_input_symbols(self):
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols() # <<<<<<<<<<<<<<
+ * if tst == NULL:
+ * return
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2054, __pyx_L1_error)
+ }
+ __pyx_v_tst = __pyx_v_self->_mfst.get()->MutableInputSymbols();
+
+ /* "pywrapfst.pyx":2055
+ * def mutable_input_symbols(self):
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols()
+ * if tst == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ */
+ __pyx_t_1 = ((__pyx_v_tst == NULL) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2056
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols()
+ * if tst == NULL:
+ * return # <<<<<<<<<<<<<<
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2055
+ * def mutable_input_symbols(self):
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols()
+ * if tst == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ */
+ }
+
+ /* "pywrapfst.pyx":2057
+ * if tst == NULL:
+ * return
+ * return _init_MutableFstSymbolTable(tst, self._mfst) # <<<<<<<<<<<<<<
+ *
+ * def mutable_output_symbols(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2057, __pyx_L1_error)
+ }
+ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFstSymbolTable(__pyx_v_tst, __pyx_v_self->_mfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2057, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2053
+ * return MutableArcIterator(self, state)
+ *
+ * def mutable_input_symbols(self): # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols()
+ * if tst == NULL:
+ */
+
+ /* 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":2059
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ *
+ * def mutable_output_symbols(self): # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols()
+ * if tst == NULL:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_29mutable_output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_29mutable_output_symbols(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("mutable_output_symbols (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_28mutable_output_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_28mutable_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ fst::SymbolTable *__pyx_v_tst;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("mutable_output_symbols", 0);
+
+ /* "pywrapfst.pyx":2060
+ *
+ * def mutable_output_symbols(self):
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols() # <<<<<<<<<<<<<<
+ * if tst == NULL:
+ * return
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2060, __pyx_L1_error)
+ }
+ __pyx_v_tst = __pyx_v_self->_mfst.get()->MutableOutputSymbols();
+
+ /* "pywrapfst.pyx":2061
+ * def mutable_output_symbols(self):
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols()
+ * if tst == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ */
+ __pyx_t_1 = ((__pyx_v_tst == NULL) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2062
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols()
+ * if tst == NULL:
+ * return # <<<<<<<<<<<<<<
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2061
+ * def mutable_output_symbols(self):
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols()
+ * if tst == NULL: # <<<<<<<<<<<<<<
+ * return
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ */
+ }
+
+ /* "pywrapfst.pyx":2063
+ * if tst == NULL:
+ * return
+ * return _init_MutableFstSymbolTable(tst, self._mfst) # <<<<<<<<<<<<<<
+ *
+ * cpdef int64 num_states(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2063, __pyx_L1_error)
+ }
+ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFstSymbolTable(__pyx_v_tst, __pyx_v_self->_mfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2063, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2059
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ *
+ * def mutable_output_symbols(self): # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols()
+ * if tst == NULL:
+ */
+
+ /* 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":2065
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ *
+ * cpdef int64 num_states(self): # <<<<<<<<<<<<<<
+ * return self._mfst.get().NumStates()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_31num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_11_MutableFst_num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_5;
+ __Pyx_RefNannySetupContext("num_states", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_num_states); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2065, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_31num_states)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2065, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2065, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2065, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2066
+ *
+ * cpdef int64 num_states(self):
+ * return self._mfst.get().NumStates() # <<<<<<<<<<<<<<
+ *
+ * cdef void _project(self, bool project_output=False) except *:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2066, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_mfst.get()->NumStates();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2065
+ * return _init_MutableFstSymbolTable(tst, self._mfst)
+ *
+ * cpdef int64 num_states(self): # <<<<<<<<<<<<<<
+ * return self._mfst.get().NumStates()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_31num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_31num_states(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("num_states (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_30num_states(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_30num_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("num_states", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_11_MutableFst_num_states(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2065, __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":2068
+ * return self._mfst.get().NumStates()
+ *
+ * cdef void _project(self, bool project_output=False) except *: # <<<<<<<<<<<<<<
+ * fst.Project(self._mfst.get(), fst.GetProjectType(project_output))
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args) {
+ bool __pyx_v_project_output = ((bool)0);
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_project", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_project_output = __pyx_optional_args->project_output;
+ }
+ }
+
+ /* "pywrapfst.pyx":2069
+ *
+ * cdef void _project(self, bool project_output=False) except *:
+ * fst.Project(self._mfst.get(), fst.GetProjectType(project_output)) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2069, __pyx_L1_error)
+ }
+ fst::script::Project(__pyx_v_self->_mfst.get(), fst::script::GetProjectType(__pyx_v_project_output));
+
+ /* "pywrapfst.pyx":2070
+ * cdef void _project(self, bool project_output=False) except *:
+ * fst.Project(self._mfst.get(), fst.GetProjectType(project_output))
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def project(self, bool project_output=False):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2070, __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, 2070, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2068
+ * return self._mfst.get().NumStates()
+ *
+ * cdef void _project(self, bool project_output=False) except *: # <<<<<<<<<<<<<<
+ * fst.Project(self._mfst.get(), fst.GetProjectType(project_output))
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._project", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2072
+ * self._check_mutating_imethod()
+ *
+ * def project(self, bool project_output=False): # <<<<<<<<<<<<<<
+ * """
+ * project(self, project_output=False)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_33project(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_32project[] = "\n project(self, project_output=False)\n\n Converts the FST to an acceptor using input or output labels.\n\n This operation destructively projects an FST onto its domain or range by\n either copying each arc's input label to its output label (the default) or\n vice versa.\n\n Args:\n project_output: Should the output labels be projected?\n\n Returns:\n self.\n\n See also: `decode`, `encode`, `relabel_pairs`, `relabel_symbols`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_33project(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ bool __pyx_v_project_output;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("project (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_project_output,0};
+ PyObject* values[1] = {0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_project_output);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "project") < 0)) __PYX_ERR(0, 2072, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ if (values[0]) {
+ __pyx_v_project_output = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_project_output == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2072, __pyx_L3_error)
+ } else {
+ __pyx_v_project_output = ((bool)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("project", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2072, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.project", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_32project(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_project_output);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_32project(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_project_output) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__project __pyx_t_1;
+ __Pyx_RefNannySetupContext("project", 0);
+
+ /* "pywrapfst.pyx":2090
+ * See also: `decode`, `encode`, `relabel_pairs`, `relabel_symbols`.
+ * """
+ * self._project(project_output) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_project");
+ __PYX_ERR(0, 2090, __pyx_L1_error)
+ }
+ __pyx_t_1.__pyx_n = 1;
+ __pyx_t_1.project_output = __pyx_v_project_output;
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_project(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2090, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2091
+ * """
+ * self._project(project_output)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId,
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2072
+ * self._check_mutating_imethod()
+ *
+ * def project(self, bool project_output=False): # <<<<<<<<<<<<<<
+ * """
+ * project(self, project_output=False)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.project", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2093
+ * return self
+ *
+ * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None) except *:
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args) {
+ float __pyx_v_delta = __pyx_k__13;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__14;
+
+ /* "pywrapfst.pyx":2094
+ *
+ * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId,
+ * weight=None) except *: # <<<<<<<<<<<<<<
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ fst::script::WeightClass __pyx_v_wc;
+ __Pyx_RefNannyDeclarations
+ fst::script::WeightClass __pyx_t_1;
+ __Pyx_RefNannySetupContext("_prune", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_nstate = __pyx_optional_args->nstate;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":2096
+ * weight=None) except *:
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), # <<<<<<<<<<<<<<
+ * weight)
+ * fst.Prune(self._mfst.get(), wc, nstate, delta)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 2096, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2097
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ * weight) # <<<<<<<<<<<<<<
+ * fst.Prune(self._mfst.get(), wc, nstate, delta)
+ * self._check_mutating_imethod()
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2096, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_1;
+
+ /* "pywrapfst.pyx":2098
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ * weight)
+ * fst.Prune(self._mfst.get(), wc, nstate, delta) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2098, __pyx_L1_error)
+ }
+ fst::script::Prune(__pyx_v_self->_mfst.get(), __pyx_v_wc, __pyx_v_nstate, __pyx_v_delta);
+
+ /* "pywrapfst.pyx":2099
+ * weight)
+ * fst.Prune(self._mfst.get(), wc, nstate, delta)
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def prune(self,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2099, __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, 2099, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2093
+ * return self
+ *
+ * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None) except *:
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._prune", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2101
+ * self._check_mutating_imethod()
+ *
+ * def prune(self, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_35prune(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_34prune[] = "\n prune(self, delta=0.0009765625, nstate=-1, weight=None)\n\n Removes paths with weights below a certain threshold.\n\n This operation deletes states and arcs in the input FST that do not belong\n to a successful path whose weight is no more (w.r.t the natural semiring\n order) than the threshold t \\otimes-times the weight of the shortest path in\n the input FST. Weights must be commutative and have the path property.\n\n Args:\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n self.\n\n See also: The constructive variant.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_35prune(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ float __pyx_v_delta;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("prune (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_weight,0};
+ PyObject* values[3] = {0,0,0};
+
+ /* "pywrapfst.pyx":2104
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * prune(self, delta=0.0009765625, nstate=-1, 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);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "prune") < 0)) __PYX_ERR(0, 2101, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 2102, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__15;
+ }
+ if (values[1]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2103, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__16;
+ }
+ __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, 2101, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.prune", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_34prune(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_nstate, __pyx_v_weight);
+
+ /* "pywrapfst.pyx":2101
+ * self._check_mutating_imethod()
+ *
+ * def prune(self, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_34prune(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune __pyx_t_1;
+ __Pyx_RefNannySetupContext("prune", 0);
+
+ /* "pywrapfst.pyx":2126
+ * See also: The constructive variant.
+ * """
+ * self._prune(delta, nstate, weight) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_prune");
+ __PYX_ERR(0, 2126, __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, 2126, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2127
+ * """
+ * 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":2101
+ * 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":2129
+ * return self
+ *
+ * cdef void _push(self, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False,
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args) {
+ float __pyx_v_delta = __pyx_k__17;
+
+ /* "pywrapfst.pyx":2131
+ * cdef void _push(self,
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False, # <<<<<<<<<<<<<<
+ * bool to_final=False) except *:
+ * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta,
+ */
+ bool __pyx_v_remove_total_weight = ((bool)0);
+
+ /* "pywrapfst.pyx":2132
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False,
+ * bool to_final=False) except *: # <<<<<<<<<<<<<<
+ * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta,
+ * remove_total_weight)
+ */
+ bool __pyx_v_to_final = ((bool)0);
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_push", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_remove_total_weight = __pyx_optional_args->remove_total_weight;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_to_final = __pyx_optional_args->to_final;
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":2133
+ * bool remove_total_weight=False,
+ * bool to_final=False) except *:
+ * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta, # <<<<<<<<<<<<<<
+ * remove_total_weight)
+ * self._check_mutating_imethod()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2133, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2134
+ * bool to_final=False) except *:
+ * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta,
+ * remove_total_weight) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ fst::script::Push(__pyx_v_self->_mfst.get(), fst::script::GetReweightType(__pyx_v_to_final), __pyx_v_delta, __pyx_v_remove_total_weight);
+
+ /* "pywrapfst.pyx":2135
+ * fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta,
+ * remove_total_weight)
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def push(self,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2135, __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, 2135, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2129
+ * return self
+ *
+ * cdef void _push(self, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False,
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._push", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2137
+ * self._check_mutating_imethod()
+ *
+ * def push(self, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_37push(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_36push[] = "\n push(self, delta=0.0009765625, remove_total_weight=False, to_final=False)\n\n Pushes weights towards the initial or final states.\n\n This operation destructively produces an equivalent transducer by pushing\n the weights towards the initial state or toward the final states. When\n pushing weights towards the initial state, the sum of the weight of the\n outgoing transitions and final weight at any non-initial state is equal to\n one in the resulting machine. When pushing weights towards the final states,\n the sum of the weight of the incoming transitions at any state is equal to\n one. Weights need to be left distributive when pushing towards the initial\n state and right distributive when pushing towards the final states.\n\n Args:\n delta: Comparison/quantization delta.\n remove_total_weight: If pushing weights, should the total weight be\n removed?\n to_final: Push towards final states?\n\n Returns:\n self.\n\n See also: The constructive variant, which also supports label pushing.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_37push(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ float __pyx_v_delta;
+ bool __pyx_v_remove_total_weight;
+ bool __pyx_v_to_final;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("push (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delta,&__pyx_n_s_remove_total_weight,&__pyx_n_s_to_final,0};
+ PyObject* values[3] = {0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_total_weight);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_to_final);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "push") < 0)) __PYX_ERR(0, 2137, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 2138, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__18;
+ }
+ 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, 2139, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":2139
+ * def push(self,
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False, # <<<<<<<<<<<<<<
+ * bool to_final=False):
+ * """
+ */
+ __pyx_v_remove_total_weight = ((bool)0);
+ }
+ if (values[2]) {
+ __pyx_v_to_final = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_to_final == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2140, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":2140
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False,
+ * bool to_final=False): # <<<<<<<<<<<<<<
+ * """
+ * push(self, delta=0.0009765625, remove_total_weight=False, to_final=False)
+ */
+ __pyx_v_to_final = ((bool)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("push", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2137, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.push", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_36push(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_delta, __pyx_v_remove_total_weight, __pyx_v_to_final);
+
+ /* "pywrapfst.pyx":2137
+ * self._check_mutating_imethod()
+ *
+ * def push(self, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False,
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_36push(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, float __pyx_v_delta, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__push __pyx_t_1;
+ __Pyx_RefNannySetupContext("push", 0);
+
+ /* "pywrapfst.pyx":2166
+ * See also: The constructive variant, which also supports label pushing.
+ * """
+ * self._push(delta, remove_total_weight, to_final) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_push");
+ __PYX_ERR(0, 2166, __pyx_L1_error)
+ }
+ __pyx_t_1.__pyx_n = 3;
+ __pyx_t_1.delta = __pyx_v_delta;
+ __pyx_t_1.remove_total_weight = __pyx_v_remove_total_weight;
+ __pyx_t_1.to_final = __pyx_v_to_final;
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_push(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2166, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2167
+ * """
+ * 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":2137
+ * self._check_mutating_imethod()
+ *
+ * def push(self, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * bool remove_total_weight=False,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.push", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2169
+ * return self
+ *
+ * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: # <<<<<<<<<<<<<<
+ * cdef unique_ptr[vector[fst.LabelPair]] _ipairs
+ * _ipairs.reset(new vector[fst.LabelPair]())
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args) {
+ PyObject *__pyx_v_ipairs = ((PyObject *)Py_None);
+ PyObject *__pyx_v_opairs = ((PyObject *)Py_None);
+ std::unique_ptr<std::vector<__pyx_t_3fst_LabelPair> > __pyx_v__ipairs;
+ std::unique_ptr<std::vector<__pyx_t_3fst_LabelPair> > __pyx_v__opairs;
+ __pyx_t_10basictypes_int64 __pyx_v_before;
+ __pyx_t_10basictypes_int64 __pyx_v_after;
+ __Pyx_RefNannyDeclarations
+ std::vector<__pyx_t_3fst_LabelPair> *__pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ Py_ssize_t __pyx_t_4;
+ PyObject *(*__pyx_t_5)(PyObject *);
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ PyObject *(*__pyx_t_10)(PyObject *);
+ __pyx_t_10basictypes_int64 __pyx_t_11;
+ __pyx_t_10basictypes_int64 __pyx_t_12;
+ __pyx_t_3fst_LabelPair __pyx_t_13;
+ int __pyx_t_14;
+ __Pyx_RefNannySetupContext("_relabel_pairs", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_ipairs = __pyx_optional_args->ipairs;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_opairs = __pyx_optional_args->opairs;
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":2171
+ * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *:
+ * cdef unique_ptr[vector[fst.LabelPair]] _ipairs
+ * _ipairs.reset(new vector[fst.LabelPair]()) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[vector[fst.LabelPair]] _opairs
+ * _opairs.reset(new vector[fst.LabelPair]())
+ */
+ try {
+ __pyx_t_1 = new std::vector<__pyx_t_3fst_LabelPair> ();
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2171, __pyx_L1_error)
+ }
+ __pyx_v__ipairs.reset(__pyx_t_1);
+
+ /* "pywrapfst.pyx":2173
+ * _ipairs.reset(new vector[fst.LabelPair]())
+ * cdef unique_ptr[vector[fst.LabelPair]] _opairs
+ * _opairs.reset(new vector[fst.LabelPair]()) # <<<<<<<<<<<<<<
+ * cdef int64 before
+ * cdef int64 after
+ */
+ try {
+ __pyx_t_1 = new std::vector<__pyx_t_3fst_LabelPair> ();
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2173, __pyx_L1_error)
+ }
+ __pyx_v__opairs.reset(__pyx_t_1);
+
+ /* "pywrapfst.pyx":2176
+ * cdef int64 before
+ * cdef int64 after
+ * if ipairs: # <<<<<<<<<<<<<<
+ * for (before, after) in ipairs:
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ */
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_ipairs); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2176, __pyx_L1_error)
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2177
+ * cdef int64 after
+ * if ipairs:
+ * for (before, after) in ipairs: # <<<<<<<<<<<<<<
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ * if opairs:
+ */
+ if (likely(PyList_CheckExact(__pyx_v_ipairs)) || PyTuple_CheckExact(__pyx_v_ipairs)) {
+ __pyx_t_3 = __pyx_v_ipairs; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
+ __pyx_t_5 = NULL;
+ } else {
+ __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_ipairs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ }
+ for (;;) {
+ if (likely(!__pyx_t_5)) {
+ if (likely(PyList_CheckExact(__pyx_t_3))) {
+ if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ #else
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ #endif
+ } else {
+ if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ #else
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ #endif
+ }
+ } else {
+ __pyx_t_6 = __pyx_t_5(__pyx_t_3);
+ if (unlikely(!__pyx_t_6)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 2177, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_6);
+ }
+ if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
+ PyObject* sequence = __pyx_t_6;
+ #if !CYTHON_COMPILING_IN_PYPY
+ Py_ssize_t size = Py_SIZE(sequence);
+ #else
+ Py_ssize_t size = PySequence_Size(sequence);
+ #endif
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(0, 2177, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ if (likely(PyTuple_CheckExact(sequence))) {
+ __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1);
+ } else {
+ __pyx_t_7 = PyList_GET_ITEM(sequence, 0);
+ __pyx_t_8 = PyList_GET_ITEM(sequence, 1);
+ }
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_8);
+ #else
+ __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ #endif
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else {
+ Py_ssize_t index = -1;
+ __pyx_t_9 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
+ index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_7);
+ index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L6_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_8);
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __pyx_t_10 = NULL;
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ goto __pyx_L7_unpacking_done;
+ __pyx_L6_unpacking_failed:;
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_10 = NULL;
+ if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+ __PYX_ERR(0, 2177, __pyx_L1_error)
+ __pyx_L7_unpacking_done:;
+ }
+ __pyx_t_11 = __Pyx_PyInt_As_int64_t(__pyx_t_7); if (unlikely((__pyx_t_11 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_12 = __Pyx_PyInt_As_int64_t(__pyx_t_8); if (unlikely((__pyx_t_12 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2177, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_v_before = __pyx_t_11;
+ __pyx_v_after = __pyx_t_12;
+
+ /* "pywrapfst.pyx":2178
+ * if ipairs:
+ * for (before, after) in ipairs:
+ * _ipairs.get().push_back(fst.LabelPair(before, after)) # <<<<<<<<<<<<<<
+ * if opairs:
+ * for (before, after) in opairs:
+ */
+ try {
+ __pyx_t_13 = __pyx_t_3fst_LabelPair(__pyx_v_before, __pyx_v_after);
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2178, __pyx_L1_error)
+ }
+ try {
+ __pyx_v__ipairs.get()->push_back(__pyx_t_13);
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2178, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2177
+ * cdef int64 after
+ * if ipairs:
+ * for (before, after) in ipairs: # <<<<<<<<<<<<<<
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ * if opairs:
+ */
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":2176
+ * cdef int64 before
+ * cdef int64 after
+ * if ipairs: # <<<<<<<<<<<<<<
+ * for (before, after) in ipairs:
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ */
+ }
+
+ /* "pywrapfst.pyx":2179
+ * for (before, after) in ipairs:
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ * if opairs: # <<<<<<<<<<<<<<
+ * for (before, after) in opairs:
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ */
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_opairs); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2179, __pyx_L1_error)
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2180
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ * if opairs:
+ * for (before, after) in opairs: # <<<<<<<<<<<<<<
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ * if _ipairs.get().empty() and _opairs.get().empty():
+ */
+ if (likely(PyList_CheckExact(__pyx_v_opairs)) || PyTuple_CheckExact(__pyx_v_opairs)) {
+ __pyx_t_3 = __pyx_v_opairs; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
+ __pyx_t_5 = NULL;
+ } else {
+ __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_opairs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ }
+ for (;;) {
+ if (likely(!__pyx_t_5)) {
+ if (likely(PyList_CheckExact(__pyx_t_3))) {
+ if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ #else
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ #endif
+ } else {
+ if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ #else
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ #endif
+ }
+ } else {
+ __pyx_t_6 = __pyx_t_5(__pyx_t_3);
+ if (unlikely(!__pyx_t_6)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 2180, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_6);
+ }
+ if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
+ PyObject* sequence = __pyx_t_6;
+ #if !CYTHON_COMPILING_IN_PYPY
+ Py_ssize_t size = Py_SIZE(sequence);
+ #else
+ Py_ssize_t size = PySequence_Size(sequence);
+ #endif
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(0, 2180, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ if (likely(PyTuple_CheckExact(sequence))) {
+ __pyx_t_8 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
+ } else {
+ __pyx_t_8 = PyList_GET_ITEM(sequence, 0);
+ __pyx_t_7 = PyList_GET_ITEM(sequence, 1);
+ }
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(__pyx_t_7);
+ #else
+ __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ #endif
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else {
+ Py_ssize_t index = -1;
+ __pyx_t_9 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
+ index = 0; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L11_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_8);
+ index = 1; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L11_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __pyx_t_10 = NULL;
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ goto __pyx_L12_unpacking_done;
+ __pyx_L11_unpacking_failed:;
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __pyx_t_10 = NULL;
+ if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+ __PYX_ERR(0, 2180, __pyx_L1_error)
+ __pyx_L12_unpacking_done:;
+ }
+ __pyx_t_12 = __Pyx_PyInt_As_int64_t(__pyx_t_8); if (unlikely((__pyx_t_12 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_t_11 = __Pyx_PyInt_As_int64_t(__pyx_t_7); if (unlikely((__pyx_t_11 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2180, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_v_before = __pyx_t_12;
+ __pyx_v_after = __pyx_t_11;
+
+ /* "pywrapfst.pyx":2181
+ * if opairs:
+ * for (before, after) in opairs:
+ * _opairs.get().push_back(fst.LabelPair(before, after)) # <<<<<<<<<<<<<<
+ * if _ipairs.get().empty() and _opairs.get().empty():
+ * raise FstArgError("No relabeling pairs specified.")
+ */
+ try {
+ __pyx_t_13 = __pyx_t_3fst_LabelPair(__pyx_v_before, __pyx_v_after);
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2181, __pyx_L1_error)
+ }
+ try {
+ __pyx_v__opairs.get()->push_back(__pyx_t_13);
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2181, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2180
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ * if opairs:
+ * for (before, after) in opairs: # <<<<<<<<<<<<<<
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ * if _ipairs.get().empty() and _opairs.get().empty():
+ */
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":2179
+ * for (before, after) in ipairs:
+ * _ipairs.get().push_back(fst.LabelPair(before, after))
+ * if opairs: # <<<<<<<<<<<<<<
+ * for (before, after) in opairs:
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ */
+ }
+
+ /* "pywrapfst.pyx":2182
+ * for (before, after) in opairs:
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ * if _ipairs.get().empty() and _opairs.get().empty(): # <<<<<<<<<<<<<<
+ * raise FstArgError("No relabeling pairs specified.")
+ * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs))
+ */
+ __pyx_t_14 = (__pyx_v__ipairs.get()->empty() != 0);
+ if (__pyx_t_14) {
+ } else {
+ __pyx_t_2 = __pyx_t_14;
+ goto __pyx_L14_bool_binop_done;
+ }
+ __pyx_t_14 = (__pyx_v__opairs.get()->empty() != 0);
+ __pyx_t_2 = __pyx_t_14;
+ __pyx_L14_bool_binop_done:;
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2183
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ * if _ipairs.get().empty() and _opairs.get().empty():
+ * raise FstArgError("No relabeling pairs specified.") # <<<<<<<<<<<<<<
+ * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs))
+ * self._check_mutating_imethod()
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __PYX_ERR(0, 2183, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2182
+ * for (before, after) in opairs:
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ * if _ipairs.get().empty() and _opairs.get().empty(): # <<<<<<<<<<<<<<
+ * raise FstArgError("No relabeling pairs specified.")
+ * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs))
+ */
+ }
+
+ /* "pywrapfst.pyx":2184
+ * if _ipairs.get().empty() and _opairs.get().empty():
+ * raise FstArgError("No relabeling pairs specified.")
+ * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs)) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2184, __pyx_L1_error)
+ }
+ fst::script::Relabel(__pyx_v_self->_mfst.get(), (*__pyx_v__ipairs), (*__pyx_v__opairs));
+
+ /* "pywrapfst.pyx":2185
+ * raise FstArgError("No relabeling pairs specified.")
+ * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs))
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def relabel_pairs(self, ipairs=None, opairs=None):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2185, __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, 2185, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2169
+ * return self
+ *
+ * cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *: # <<<<<<<<<<<<<<
+ * cdef unique_ptr[vector[fst.LabelPair]] _ipairs
+ * _ipairs.reset(new vector[fst.LabelPair]())
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._relabel_pairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2187
+ * self._check_mutating_imethod()
+ *
+ * def relabel_pairs(self, ipairs=None, opairs=None): # <<<<<<<<<<<<<<
+ * """
+ * relabel_pairs(self, ipairs=None, opairs=None)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_39relabel_pairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_38relabel_pairs[] = "\n relabel_pairs(self, ipairs=None, opairs=None)\n\n Replaces input and/or output labels using pairs of labels.\n\n This operation destructively relabels the input and/or output labels of the\n FST using pairs of the form (old_ID, new_ID); omitted indices are\n identity-mapped.\n\n Args:\n ipairs: An iterable containing (older index, newer index) integer pairs.\n opairs: An iterable containing (older index, newer index) integer pairs.\n\n Returns:\n self.\n\n Raises:\n FstArgError: No relabeling pairs specified.\n\n See also: `decode`, `encode`, `project`, `relabel_tables`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_39relabel_pairs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_ipairs = 0;
+ PyObject *__pyx_v_opairs = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("relabel_pairs (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ipairs,&__pyx_n_s_opairs,0};
+ PyObject* values[2] = {0,0};
+ values[0] = ((PyObject *)Py_None);
+ values[1] = ((PyObject *)Py_None);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ipairs);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_opairs);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "relabel_pairs") < 0)) __PYX_ERR(0, 2187, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ 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, 2187, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.relabel_pairs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_38relabel_pairs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_ipairs, __pyx_v_opairs);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_38relabel_pairs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_ipairs, PyObject *__pyx_v_opairs) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs __pyx_t_1;
+ __Pyx_RefNannySetupContext("relabel_pairs", 0);
+
+ /* "pywrapfst.pyx":2209
+ * See also: `decode`, `encode`, `project`, `relabel_tables`.
+ * """
+ * self._relabel_pairs(ipairs, opairs) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_relabel_pairs");
+ __PYX_ERR(0, 2209, __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, 2209, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2210
+ * """
+ * 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":2187
+ * 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":2212
+ * return self
+ *
+ * cdef void _relabel_tables(self, # <<<<<<<<<<<<<<
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None,
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args) {
+
+ /* "pywrapfst.pyx":2213
+ *
+ * cdef void _relabel_tables(self,
+ * _SymbolTable old_isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable new_isymbols=None,
+ * bool attach_new_isymbols=True,
+ */
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":2214
+ * cdef void _relabel_tables(self,
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None, # <<<<<<<<<<<<<<
+ * bool attach_new_isymbols=True,
+ * _SymbolTable old_osymbols=None,
+ */
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":2215
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None,
+ * bool attach_new_isymbols=True, # <<<<<<<<<<<<<<
+ * _SymbolTable old_osymbols=None,
+ * _SymbolTable new_osymbols=None,
+ */
+ bool __pyx_v_attach_new_isymbols = ((bool)1);
+
+ /* "pywrapfst.pyx":2216
+ * _SymbolTable new_isymbols=None,
+ * bool attach_new_isymbols=True,
+ * _SymbolTable old_osymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable new_osymbols=None,
+ * bool attach_new_osymbols=True) except *:
+ */
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":2217
+ * bool attach_new_isymbols=True,
+ * _SymbolTable old_osymbols=None,
+ * _SymbolTable new_osymbols=None, # <<<<<<<<<<<<<<
+ * bool attach_new_osymbols=True) except *:
+ * if new_isymbols is None and new_osymbols is None:
+ */
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":2218
+ * _SymbolTable old_osymbols=None,
+ * _SymbolTable new_osymbols=None,
+ * bool attach_new_osymbols=True) except *: # <<<<<<<<<<<<<<
+ * if new_isymbols is None and new_osymbols is None:
+ * raise FstArgError("No new SymbolTables specified")
+ */
+ bool __pyx_v_attach_new_osymbols = ((bool)1);
+ fst::SymbolTable *__pyx_v_new_isymbols_ptr;
+ fst::SymbolTable *__pyx_v_new_osymbols_ptr;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ fst::SymbolTable *__pyx_t_6;
+ fst::SymbolTable const *__pyx_t_7;
+ fst::SymbolTable const *__pyx_t_8;
+ __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_attach_new_isymbols = __pyx_optional_args->attach_new_isymbols;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_old_osymbols = __pyx_optional_args->old_osymbols;
+ if (__pyx_optional_args->__pyx_n > 4) {
+ __pyx_v_new_osymbols = __pyx_optional_args->new_osymbols;
+ if (__pyx_optional_args->__pyx_n > 5) {
+ __pyx_v_attach_new_osymbols = __pyx_optional_args->attach_new_osymbols;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":2219
+ * _SymbolTable new_osymbols=None,
+ * bool attach_new_osymbols=True) except *:
+ * if new_isymbols is None and new_osymbols is None: # <<<<<<<<<<<<<<
+ * raise FstArgError("No new SymbolTables specified")
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ */
+ __pyx_t_2 = (((PyObject *)__pyx_v_new_isymbols) == Py_None);
+ __pyx_t_3 = (__pyx_t_2 != 0);
+ if (__pyx_t_3) {
+ } else {
+ __pyx_t_1 = __pyx_t_3;
+ goto __pyx_L4_bool_binop_done;
+ }
+ __pyx_t_3 = (((PyObject *)__pyx_v_new_osymbols) == Py_None);
+ __pyx_t_2 = (__pyx_t_3 != 0);
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L4_bool_binop_done:;
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2220
+ * bool attach_new_osymbols=True) except *:
+ * if new_isymbols is None and new_osymbols is None:
+ * raise FstArgError("No new SymbolTables specified") # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ * if new_isymbols is not None:
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2220, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2220, __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, 2220, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2219
+ * _SymbolTable new_osymbols=None,
+ * bool attach_new_osymbols=True) except *:
+ * if new_isymbols is None and new_osymbols is None: # <<<<<<<<<<<<<<
+ * raise FstArgError("No new SymbolTables specified")
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ */
+ }
+
+ /* "pywrapfst.pyx":2221
+ * if new_isymbols is None and new_osymbols is None:
+ * raise FstArgError("No new SymbolTables specified")
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL # <<<<<<<<<<<<<<
+ * if new_isymbols is not None:
+ * new_isymbols_ptr = new_isymbols._table
+ */
+ __pyx_v_new_isymbols_ptr = NULL;
+
+ /* "pywrapfst.pyx":2222
+ * raise FstArgError("No new SymbolTables specified")
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ * if new_isymbols is not None: # <<<<<<<<<<<<<<
+ * new_isymbols_ptr = new_isymbols._table
+ * cdef fst.SymbolTable *new_osymbols_ptr = NULL
+ */
+ __pyx_t_1 = (((PyObject *)__pyx_v_new_isymbols) != Py_None);
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2223
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ * if new_isymbols is not None:
+ * new_isymbols_ptr = new_isymbols._table # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *new_osymbols_ptr = NULL
+ * if new_osymbols is not None:
+ */
+ if (unlikely(((PyObject *)__pyx_v_new_isymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 2223, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_v_new_isymbols->_table;
+ __pyx_v_new_isymbols_ptr = __pyx_t_6;
+
+ /* "pywrapfst.pyx":2222
+ * raise FstArgError("No new SymbolTables specified")
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ * if new_isymbols is not None: # <<<<<<<<<<<<<<
+ * new_isymbols_ptr = new_isymbols._table
+ * cdef fst.SymbolTable *new_osymbols_ptr = NULL
+ */
+ }
+
+ /* "pywrapfst.pyx":2224
+ * if new_isymbols is not None:
+ * new_isymbols_ptr = new_isymbols._table
+ * cdef fst.SymbolTable *new_osymbols_ptr = NULL # <<<<<<<<<<<<<<
+ * if new_osymbols is not None:
+ * new_osymbols_ptr = new_osymbols._table
+ */
+ __pyx_v_new_osymbols_ptr = NULL;
+
+ /* "pywrapfst.pyx":2225
+ * new_isymbols_ptr = new_isymbols._table
+ * cdef fst.SymbolTable *new_osymbols_ptr = NULL
+ * if new_osymbols is not None: # <<<<<<<<<<<<<<
+ * new_osymbols_ptr = new_osymbols._table
+ * fst.Relabel(self._mfst.get(),
+ */
+ __pyx_t_2 = (((PyObject *)__pyx_v_new_osymbols) != Py_None);
+ __pyx_t_1 = (__pyx_t_2 != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2226
+ * cdef fst.SymbolTable *new_osymbols_ptr = NULL
+ * if new_osymbols is not None:
+ * new_osymbols_ptr = new_osymbols._table # <<<<<<<<<<<<<<
+ * fst.Relabel(self._mfst.get(),
+ * self._fst.get().InputSymbols() if old_isymbols is None else
+ */
+ if (unlikely(((PyObject *)__pyx_v_new_osymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 2226, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_v_new_osymbols->_table;
+ __pyx_v_new_osymbols_ptr = __pyx_t_6;
+
+ /* "pywrapfst.pyx":2225
+ * new_isymbols_ptr = new_isymbols._table
+ * cdef fst.SymbolTable *new_osymbols_ptr = NULL
+ * if new_osymbols is not None: # <<<<<<<<<<<<<<
+ * new_osymbols_ptr = new_osymbols._table
+ * fst.Relabel(self._mfst.get(),
+ */
+ }
+
+ /* "pywrapfst.pyx":2227
+ * if new_osymbols is not None:
+ * new_osymbols_ptr = new_osymbols._table
+ * fst.Relabel(self._mfst.get(), # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols() if old_isymbols is None else
+ * old_isymbols._table, new_isymbols_ptr, attach_new_isymbols,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2227, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2228
+ * new_osymbols_ptr = new_osymbols._table
+ * fst.Relabel(self._mfst.get(),
+ * self._fst.get().InputSymbols() if old_isymbols is None else # <<<<<<<<<<<<<<
+ * old_isymbols._table, new_isymbols_ptr, attach_new_isymbols,
+ * self._fst.get().OutputSymbols() if old_osymbols is None else
+ */
+ __pyx_t_1 = (((PyObject *)__pyx_v_old_isymbols) == Py_None);
+ if ((__pyx_t_1 != 0)) {
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 2228, __pyx_L1_error)
+ }
+ __pyx_t_7 = __pyx_v_self->__pyx_base._fst.get()->InputSymbols();
+ } else {
+
+ /* "pywrapfst.pyx":2229
+ * fst.Relabel(self._mfst.get(),
+ * self._fst.get().InputSymbols() if old_isymbols is None else
+ * old_isymbols._table, new_isymbols_ptr, attach_new_isymbols, # <<<<<<<<<<<<<<
+ * self._fst.get().OutputSymbols() if old_osymbols is None else
+ * old_osymbols._table, new_osymbols_ptr, attach_new_osymbols)
+ */
+ if (unlikely(((PyObject *)__pyx_v_old_isymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 2229, __pyx_L1_error)
+ }
+ __pyx_t_7 = __pyx_v_old_isymbols->_table;
+ }
+
+ /* "pywrapfst.pyx":2230
+ * self._fst.get().InputSymbols() if old_isymbols is None else
+ * old_isymbols._table, new_isymbols_ptr, attach_new_isymbols,
+ * self._fst.get().OutputSymbols() if old_osymbols is None else # <<<<<<<<<<<<<<
+ * old_osymbols._table, new_osymbols_ptr, attach_new_osymbols)
+ * self._check_mutating_imethod()
+ */
+ __pyx_t_1 = (((PyObject *)__pyx_v_old_osymbols) == Py_None);
+ if ((__pyx_t_1 != 0)) {
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 2230, __pyx_L1_error)
+ }
+ __pyx_t_8 = __pyx_v_self->__pyx_base._fst.get()->OutputSymbols();
+ } else {
+
+ /* "pywrapfst.pyx":2231
+ * old_isymbols._table, new_isymbols_ptr, attach_new_isymbols,
+ * self._fst.get().OutputSymbols() if old_osymbols is None else
+ * old_osymbols._table, new_osymbols_ptr, attach_new_osymbols) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_old_osymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 2231, __pyx_L1_error)
+ }
+ __pyx_t_8 = __pyx_v_old_osymbols->_table;
+ }
+
+ /* "pywrapfst.pyx":2227
+ * if new_osymbols is not None:
+ * new_osymbols_ptr = new_osymbols._table
+ * fst.Relabel(self._mfst.get(), # <<<<<<<<<<<<<<
+ * self._fst.get().InputSymbols() if old_isymbols is None else
+ * old_isymbols._table, new_isymbols_ptr, attach_new_isymbols,
+ */
+ fst::script::Relabel(__pyx_v_self->_mfst.get(), __pyx_t_7, __pyx_v_new_isymbols_ptr, __pyx_v_attach_new_isymbols, __pyx_t_8, __pyx_v_new_osymbols_ptr, __pyx_v_attach_new_osymbols);
+
+ /* "pywrapfst.pyx":2232
+ * self._fst.get().OutputSymbols() if old_osymbols is None else
+ * old_osymbols._table, new_osymbols_ptr, 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 '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2232, __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, 2232, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2212
+ * return self
+ *
+ * cdef void _relabel_tables(self, # <<<<<<<<<<<<<<
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None,
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._relabel_tables", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2234
+ * self._check_mutating_imethod()
+ *
+ * def relabel_tables(self, # <<<<<<<<<<<<<<
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_41relabel_tables(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_40relabel_tables[] = "\n relabel_tables(self, old_isymbols=None, new_isymbols=None,\n attach_new_isymbols=True, old_osymbols=None,\n new_osymbols=None, 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 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 attach_new_isymbols: Should new_osymbols be made the FST's output symbol\n table?\n\n Returns:\n self.\n\n Raises:\n FstArgError: No SymbolTable specified.\n\n See also: `decode`, `encode`, `project`, `relabel_pairs`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_41relabel_tables(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols = 0;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols = 0;
+ bool __pyx_v_attach_new_isymbols;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols = 0;
+ struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols = 0;
+ bool __pyx_v_attach_new_osymbols;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("relabel_tables (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_old_isymbols,&__pyx_n_s_new_isymbols,&__pyx_n_s_attach_new_isymbols,&__pyx_n_s_old_osymbols,&__pyx_n_s_new_osymbols,&__pyx_n_s_attach_new_osymbols,0};
+ PyObject* values[6] = {0,0,0,0,0,0};
+
+ /* "pywrapfst.pyx":2235
+ *
+ * def relabel_tables(self,
+ * _SymbolTable old_isymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable new_isymbols=None,
+ * bool attach_new_isymbols=True,
+ */
+ values[0] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":2236
+ * def relabel_tables(self,
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None, # <<<<<<<<<<<<<<
+ * bool attach_new_isymbols=True,
+ * _SymbolTable old_osymbols=None,
+ */
+ values[1] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":2238
+ * _SymbolTable new_isymbols=None,
+ * bool attach_new_isymbols=True,
+ * _SymbolTable old_osymbols=None, # <<<<<<<<<<<<<<
+ * _SymbolTable new_osymbols=None,
+ * bool attach_new_osymbols=True):
+ */
+ values[3] = (PyObject *)((struct __pyx_obj_9pywrapfst__SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":2239
+ * bool attach_new_isymbols=True,
+ * _SymbolTable old_osymbols=None,
+ * _SymbolTable new_osymbols=None, # <<<<<<<<<<<<<<
+ * bool attach_new_osymbols=True):
+ * """
+ */
+ 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 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_old_isymbols);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_new_isymbols);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_attach_new_isymbols);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_old_osymbols);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_new_osymbols);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_attach_new_osymbols);
+ if (value) { values[5] = 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, 2234, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_old_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[0]);
+ __pyx_v_new_isymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[1]);
+ if (values[2]) {
+ __pyx_v_attach_new_isymbols = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_attach_new_isymbols == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2237, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":2237
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None,
+ * bool attach_new_isymbols=True, # <<<<<<<<<<<<<<
+ * _SymbolTable old_osymbols=None,
+ * _SymbolTable new_osymbols=None,
+ */
+ __pyx_v_attach_new_isymbols = ((bool)1);
+ }
+ __pyx_v_old_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[3]);
+ __pyx_v_new_osymbols = ((struct __pyx_obj_9pywrapfst__SymbolTable *)values[4]);
+ if (values[5]) {
+ __pyx_v_attach_new_osymbols = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_attach_new_osymbols == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2240, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":2240
+ * _SymbolTable old_osymbols=None,
+ * _SymbolTable new_osymbols=None,
+ * 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, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2234, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.relabel_tables", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_old_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "old_isymbols", 0))) __PYX_ERR(0, 2235, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_new_isymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "new_isymbols", 0))) __PYX_ERR(0, 2236, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_old_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "old_osymbols", 0))) __PYX_ERR(0, 2238, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_new_osymbols), __pyx_ptype_9pywrapfst__SymbolTable, 1, "new_osymbols", 0))) __PYX_ERR(0, 2239, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_40relabel_tables(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_old_isymbols, __pyx_v_new_isymbols, __pyx_v_attach_new_isymbols, __pyx_v_old_osymbols, __pyx_v_new_osymbols, __pyx_v_attach_new_osymbols);
+
+ /* "pywrapfst.pyx":2234
+ * self._check_mutating_imethod()
+ *
+ * def relabel_tables(self, # <<<<<<<<<<<<<<
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None,
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_40relabel_tables(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_isymbols, bool __pyx_v_attach_new_isymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_old_osymbols, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_new_osymbols, bool __pyx_v_attach_new_osymbols) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables __pyx_t_1;
+ __Pyx_RefNannySetupContext("relabel_tables", 0);
+
+ /* "pywrapfst.pyx":2271
+ * See also: `decode`, `encode`, `project`, `relabel_pairs`.
+ * """
+ * self._relabel_tables(old_isymbols, new_isymbols, attach_new_isymbols, # <<<<<<<<<<<<<<
+ * old_osymbols, new_osymbols, attach_new_osymbols)
+ * return self
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_relabel_tables");
+ __PYX_ERR(0, 2271, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2272
+ * """
+ * self._relabel_tables(old_isymbols, new_isymbols, attach_new_isymbols,
+ * old_osymbols, new_osymbols, attach_new_osymbols) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ __pyx_t_1.__pyx_n = 6;
+ __pyx_t_1.old_isymbols = __pyx_v_old_isymbols;
+ __pyx_t_1.new_isymbols = __pyx_v_new_isymbols;
+ __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.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, 2271, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2273
+ * self._relabel_tables(old_isymbols, new_isymbols, attach_new_isymbols,
+ * old_osymbols, new_osymbols, 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":2234
+ * self._check_mutating_imethod()
+ *
+ * def relabel_tables(self, # <<<<<<<<<<<<<<
+ * _SymbolTable old_isymbols=None,
+ * _SymbolTable new_isymbols=None,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.relabel_tables", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2275
+ * return self
+ *
+ * cdef void _reserve_arcs(self, int64 state, size_t n) except *: # <<<<<<<<<<<<<<
+ * if not self._mfst.get().ReserveArcs(state, n):
+ * raise FstIndexError("State index out of range")
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("_reserve_arcs", 0);
+
+ /* "pywrapfst.pyx":2276
+ *
+ * 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 '%s'", "_mfst");
+ __PYX_ERR(0, 2276, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->ReserveArcs(__pyx_v_state, __pyx_v_n) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2277
+ * cdef void _reserve_arcs(self, int64 state, size_t n) except *:
+ * if not self._mfst.get().ReserveArcs(state, n):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2277, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2277, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2277, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2276
+ *
+ * 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":2278
+ * 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 '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2278, __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, 2278, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2275
+ * return self
+ *
+ * cdef void _reserve_arcs(self, int64 state, size_t n) except *: # <<<<<<<<<<<<<<
+ * if not self._mfst.get().ReserveArcs(state, n):
+ * raise FstIndexError("State index out of range")
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._reserve_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2280
+ * self._check_mutating_imethod()
+ *
+ * def reserve_arcs(self, int64 state, size_t n): # <<<<<<<<<<<<<<
+ * """
+ * reserve_arcs(self, state, n)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_43reserve_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_42reserve_arcs[] = "\n reserve_arcs(self, state, n)\n\n Reserve n arcs at a particular state (best effort).\n\n Args:\n state: The integer index of a state.\n n: The number of arcs to reserve.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `reserve_states`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_43reserve_arcs(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ size_t __pyx_v_n;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reserve_arcs (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_n,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("reserve_arcs", 1, 2, 2, 1); __PYX_ERR(0, 2280, __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, 2280, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2280, __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, 2280, __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, 2280, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.reserve_arcs", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_42reserve_arcs(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_n);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_42reserve_arcs(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, size_t __pyx_v_n) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reserve_arcs", 0);
+
+ /* "pywrapfst.pyx":2298
+ * See also: `reserve_states`.
+ * """
+ * self._reserve_arcs(state, n) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_reserve_arcs");
+ __PYX_ERR(0, 2298, __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, 2298, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2299
+ * """
+ * self._reserve_arcs(state, n)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _reserve_states(self, int64 n) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2280
+ * 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":2301
+ * return self
+ *
+ * cdef void _reserve_states(self, int64 n) except *: # <<<<<<<<<<<<<<
+ * self._mfst.get().ReserveStates(n)
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_reserve_states", 0);
+
+ /* "pywrapfst.pyx":2302
+ *
+ * cdef void _reserve_states(self, int64 n) except *:
+ * self._mfst.get().ReserveStates(n) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2302, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst.get()->ReserveStates(__pyx_v_n);
+
+ /* "pywrapfst.pyx":2303
+ * cdef void _reserve_states(self, int64 n) except *:
+ * self._mfst.get().ReserveStates(n)
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def reserve_states(self, int64 n):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2303, __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, 2303, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2301
+ * return self
+ *
+ * cdef void _reserve_states(self, int64 n) except *: # <<<<<<<<<<<<<<
+ * self._mfst.get().ReserveStates(n)
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._reserve_states", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2305
+ * self._check_mutating_imethod()
+ *
+ * def reserve_states(self, int64 n): # <<<<<<<<<<<<<<
+ * """
+ * reserve_states(self, n)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_45reserve_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_44reserve_states[] = "\n reserve_states(self, n)\n\n Reserve n states (best effort).\n\n Args:\n n: The number of states to reserve.\n\n Returns:\n self.\n\n See also: `reserve_arcs`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_45reserve_states(PyObject *__pyx_v_self, PyObject *__pyx_arg_n) {
+ __pyx_t_10basictypes_int64 __pyx_v_n;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reserve_states (wrapper)", 0);
+ assert(__pyx_arg_n); {
+ __pyx_v_n = __Pyx_PyInt_As_int64_t(__pyx_arg_n); if (unlikely((__pyx_v_n == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2305, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.reserve_states", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_44reserve_states(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_n));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_44reserve_states(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_n) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reserve_states", 0);
+
+ /* "pywrapfst.pyx":2319
+ * See also: `reserve_arcs`.
+ * """
+ * self._reserve_states(n) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_reserve_states");
+ __PYX_ERR(0, 2319, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_reserve_states(__pyx_v_self, __pyx_v_n); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2319, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2320
+ * """
+ * 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":2305
+ * self._check_mutating_imethod()
+ *
+ * def reserve_states(self, int64 n): # <<<<<<<<<<<<<<
+ * """
+ * reserve_states(self, n)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.reserve_states", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2322
+ * return self
+ *
+ * cdef void _reweight(self, potentials, bool to_final=False) except *: # <<<<<<<<<<<<<<
+ * cdef unique_ptr[vector[fst.WeightClass]] _potentials
+ * _potentials.reset(new vector[fst.WeightClass]())
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args) {
+ bool __pyx_v_to_final = ((bool)0);
+ std::unique_ptr<std::vector<fst::script::WeightClass> > __pyx_v__potentials;
+ CYTHON_UNUSED std::string __pyx_v_weight_type;
+ PyObject *__pyx_v_weight = NULL;
+ __Pyx_RefNannyDeclarations
+ std::vector<fst::script::WeightClass> *__pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t __pyx_t_3;
+ PyObject *(*__pyx_t_4)(PyObject *);
+ PyObject *__pyx_t_5 = NULL;
+ fst::script::WeightClass __pyx_t_6;
+ __Pyx_RefNannySetupContext("_reweight", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_to_final = __pyx_optional_args->to_final;
+ }
+ }
+
+ /* "pywrapfst.pyx":2324
+ * cdef void _reweight(self, potentials, bool to_final=False) except *:
+ * cdef unique_ptr[vector[fst.WeightClass]] _potentials
+ * _potentials.reset(new vector[fst.WeightClass]()) # <<<<<<<<<<<<<<
+ * cdef string weight_type = self.weight_type()
+ * for weight in potentials:
+ */
+ try {
+ __pyx_t_1 = new std::vector<fst::script::WeightClass> ();
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2324, __pyx_L1_error)
+ }
+ __pyx_v__potentials.reset(__pyx_t_1);
+
+ /* "pywrapfst.pyx":2325
+ * cdef unique_ptr[vector[fst.WeightClass]] _potentials
+ * _potentials.reset(new vector[fst.WeightClass]())
+ * cdef string weight_type = self.weight_type() # <<<<<<<<<<<<<<
+ * for weight in potentials:
+ * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(),
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 2325, __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":2326
+ * _potentials.reset(new vector[fst.WeightClass]())
+ * cdef string weight_type = self.weight_type()
+ * for weight in potentials: # <<<<<<<<<<<<<<
+ * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(),
+ * weight))
+ */
+ if (likely(PyList_CheckExact(__pyx_v_potentials)) || PyTuple_CheckExact(__pyx_v_potentials)) {
+ __pyx_t_2 = __pyx_v_potentials; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_potentials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2326, __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, 2326, __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, 2326, __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, 2326, __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, 2326, __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, 2326, __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 2326, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_5);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_weight, __pyx_t_5);
+ __pyx_t_5 = 0;
+
+ /* "pywrapfst.pyx":2327
+ * cdef string weight_type = self.weight_type()
+ * for weight in potentials:
+ * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), # <<<<<<<<<<<<<<
+ * weight))
+ * fst.Reweight(self._mfst.get(), deref(_potentials),
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 2327, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2328
+ * for weight in potentials:
+ * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(),
+ * weight)) # <<<<<<<<<<<<<<
+ * fst.Reweight(self._mfst.get(), deref(_potentials),
+ * fst.GetReweightType(to_final))
+ */
+ __pyx_t_6 = __pyx_f_9pywrapfst__get_WeightClass_or_One(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2327, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2327
+ * cdef string weight_type = self.weight_type()
+ * for weight in potentials:
+ * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(), # <<<<<<<<<<<<<<
+ * weight))
+ * fst.Reweight(self._mfst.get(), deref(_potentials),
+ */
+ try {
+ __pyx_v__potentials.get()->push_back(__pyx_t_6);
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 2327, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2326
+ * _potentials.reset(new vector[fst.WeightClass]())
+ * cdef string weight_type = self.weight_type()
+ * for weight in potentials: # <<<<<<<<<<<<<<
+ * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(),
+ * weight))
+ */
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2329
+ * _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(),
+ * weight))
+ * fst.Reweight(self._mfst.get(), deref(_potentials), # <<<<<<<<<<<<<<
+ * fst.GetReweightType(to_final))
+ * self._check_mutating_imethod()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2329, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2330
+ * weight))
+ * fst.Reweight(self._mfst.get(), deref(_potentials),
+ * fst.GetReweightType(to_final)) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ fst::script::Reweight(__pyx_v_self->_mfst.get(), (*__pyx_v__potentials), fst::script::GetReweightType(__pyx_v_to_final));
+
+ /* "pywrapfst.pyx":2331
+ * fst.Reweight(self._mfst.get(), deref(_potentials),
+ * fst.GetReweightType(to_final))
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def reweight(self, potentials, bool to_final=False):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2331, __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, 2331, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2322
+ * return self
+ *
+ * cdef void _reweight(self, potentials, bool to_final=False) except *: # <<<<<<<<<<<<<<
+ * cdef unique_ptr[vector[fst.WeightClass]] _potentials
+ * _potentials.reset(new vector[fst.WeightClass]())
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._reweight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_weight);
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2333
+ * self._check_mutating_imethod()
+ *
+ * def reweight(self, potentials, bool to_final=False): # <<<<<<<<<<<<<<
+ * """
+ * reweight(self, potentials, to_final=False)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_47reweight(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_46reweight[] = "\n reweight(self, potentials, to_final=False)\n\n Reweights an FST using an iterable of potentials.\n\n This operation destructively reweights an FST according to the potentials\n and in the direction specified by the user. An arc of weight w, with an\n origin state of potential p and destination state of potential q, is\n reweighted by p^{-1} \\otimes (w \\otimes q) when reweighting towards the\n initial state, and by (p \\otimes w) \\otimes q^{-1} when reweighting towards\n the final states. The weights must be left distributive when reweighting\n towards the initial state and right distributive when reweighting towards\n the final states (e.g., TropicalWeight and LogWeight).\n\n Args:\n potentials: An iterable of Weight or weight strings.\n to_final: Push towards final states?\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_47reweight(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_potentials = 0;
+ bool __pyx_v_to_final;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reweight (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_potentials,&__pyx_n_s_to_final,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_potentials)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_to_final);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "reweight") < 0)) __PYX_ERR(0, 2333, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 2333, __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, 2333, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.reweight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_46reweight(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_potentials, __pyx_v_to_final);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_46reweight(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, PyObject *__pyx_v_potentials, bool __pyx_v_to_final) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight __pyx_t_1;
+ __Pyx_RefNannySetupContext("reweight", 0);
+
+ /* "pywrapfst.pyx":2355
+ * 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 '%s'", "_reweight");
+ __PYX_ERR(0, 2355, __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, 2355, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2356
+ * """
+ * 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":2333
+ * 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":2358
+ * return self
+ *
+ * cdef void _rmepsilon(self, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args) {
+
+ /* "pywrapfst.pyx":2359
+ *
+ * cdef void _rmepsilon(self,
+ * bool connect=True, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+ bool __pyx_v_connect = ((bool)1);
+ float __pyx_v_delta = __pyx_k__22;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__23;
+
+ /* "pywrapfst.pyx":2362
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ * weight=None) except *: # <<<<<<<<<<<<<<
+ * # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ fst::script::WeightClass __pyx_v_wc;
+ __Pyx_RefNannyDeclarations
+ fst::script::WeightClass __pyx_t_1;
+ __Pyx_RefNannySetupContext("_rmepsilon", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_connect = __pyx_optional_args->connect;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_nstate = __pyx_optional_args->nstate;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":2364
+ * weight=None) except *:
+ * # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(), # <<<<<<<<<<<<<<
+ * weight)
+ * fst.RmEpsilon(self._mfst.get(), connect, wc, nstate, delta)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 2364, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2365
+ * # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ * weight) # <<<<<<<<<<<<<<
+ * fst.RmEpsilon(self._mfst.get(), connect, wc, nstate, delta)
+ * self._check_mutating_imethod()
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2364, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_1;
+
+ /* "pywrapfst.pyx":2366
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ * weight)
+ * fst.RmEpsilon(self._mfst.get(), connect, wc, nstate, delta) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2366, __pyx_L1_error)
+ }
+ fst::script::RmEpsilon(__pyx_v_self->_mfst.get(), __pyx_v_connect, __pyx_v_wc, __pyx_v_nstate, __pyx_v_delta);
+
+ /* "pywrapfst.pyx":2367
+ * weight)
+ * fst.RmEpsilon(self._mfst.get(), connect, wc, nstate, delta)
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def rmepsilon(self,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2367, __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, 2367, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2358
+ * return self
+ *
+ * cdef void _rmepsilon(self, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+ /* 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":2369
+ * self._check_mutating_imethod()
+ *
+ * def rmepsilon(self, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_49rmepsilon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_48rmepsilon[] = "\n rmepsilon(self, connect=True, delta=0.0009765625, nstate=-1, weight=None)\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 connect: Should output be trimmed?\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n self.\n\n See also: The constructive variant, which also supports epsilon removal in\n reverse (and which may be more efficient).\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_49rmepsilon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ bool __pyx_v_connect;
+ float __pyx_v_delta;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("rmepsilon (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_connect,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_weight,0};
+ PyObject* values[4] = {0,0,0,0};
+
+ /* "pywrapfst.pyx":2373
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * rmepsilon(self, connect=True, delta=0.0009765625, nstate=-1, 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);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rmepsilon") < 0)) __PYX_ERR(0, 2369, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ if (values[0]) {
+ __pyx_v_connect = __Pyx_PyObject_IsTrue(values[0]); if (unlikely((__pyx_v_connect == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2370, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":2370
+ *
+ * def rmepsilon(self,
+ * bool connect=True, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_v_connect = ((bool)1);
+ }
+ if (values[1]) {
+ __pyx_v_delta = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2371, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__24;
+ }
+ if (values[2]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2372, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__25;
+ }
+ __pyx_v_weight = values[3];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("rmepsilon", 0, 0, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2369, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.rmepsilon", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_48rmepsilon(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_connect, __pyx_v_delta, __pyx_v_nstate, __pyx_v_weight);
+
+ /* "pywrapfst.pyx":2369
+ * self._check_mutating_imethod()
+ *
+ * def rmepsilon(self, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_48rmepsilon(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, bool __pyx_v_connect, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon __pyx_t_1;
+ __Pyx_RefNannySetupContext("rmepsilon", 0);
+
+ /* "pywrapfst.pyx":2395
+ * reverse (and which may be more efficient).
+ * """
+ * self._rmepsilon(connect, delta, nstate, weight) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_rmepsilon");
+ __PYX_ERR(0, 2395, __pyx_L1_error)
+ }
+ __pyx_t_1.__pyx_n = 4;
+ __pyx_t_1.connect = __pyx_v_connect;
+ __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)->_rmepsilon(__pyx_v_self, &__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2395, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2396
+ * """
+ * self._rmepsilon(connect, delta, nstate, weight)
+ * 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":2369
+ * self._check_mutating_imethod()
+ *
+ * def rmepsilon(self, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+ /* 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":2398
+ * return self
+ *
+ * cdef void _set_final(self, int64 state, weight=None) except *: # <<<<<<<<<<<<<<
+ * if not self._mfst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args) {
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ fst::script::WeightClass __pyx_v_wc;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ fst::script::WeightClass __pyx_t_4;
+ __Pyx_RefNannySetupContext("_set_final", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+
+ /* "pywrapfst.pyx":2399
+ *
+ * cdef void _set_final(self, int64 state, weight=None) except *:
+ * if not self._mfst.get().ValidStateId(state): # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2399, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->ValidStateId(__pyx_v_state) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2400
+ * cdef void _set_final(self, int64 state, weight=None) except *:
+ * if not self._mfst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ * weight)
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2400, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2400, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2400, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2399
+ *
+ * cdef void _set_final(self, int64 state, weight=None) except *:
+ * if not self._mfst.get().ValidStateId(state): # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ */
+ }
+
+ /* "pywrapfst.pyx":2401
+ * if not self._mfst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(), # <<<<<<<<<<<<<<
+ * weight)
+ * if not self._mfst.get().SetFinal(state, wc):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 2401, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":2402
+ * raise FstIndexError("State index out of range")
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ * weight) # <<<<<<<<<<<<<<
+ * if not self._mfst.get().SetFinal(state, wc):
+ * raise FstOpError("incompatible or invalid weight")
+ */
+ __pyx_t_4 = __pyx_f_9pywrapfst__get_WeightClass_or_One(((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.weight_type(((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_self), 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2401, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_4;
+
+ /* "pywrapfst.pyx":2403
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ * weight)
+ * if not self._mfst.get().SetFinal(state, wc): # <<<<<<<<<<<<<<
+ * raise FstOpError("incompatible or invalid weight")
+ * self._check_mutating_imethod()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2403, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->SetFinal(__pyx_v_state, __pyx_v_wc) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2404
+ * weight)
+ * if not self._mfst.get().SetFinal(state, wc):
+ * raise FstOpError("incompatible or invalid weight") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2404, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2404, __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, 2404, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2403
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ * weight)
+ * if not self._mfst.get().SetFinal(state, wc): # <<<<<<<<<<<<<<
+ * raise FstOpError("incompatible or invalid weight")
+ * self._check_mutating_imethod()
+ */
+ }
+
+ /* "pywrapfst.pyx":2405
+ * if not self._mfst.get().SetFinal(state, wc):
+ * raise FstOpError("incompatible or invalid weight")
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def set_final(self, int64 state, weight=None):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2405, __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, 2405, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2398
+ * return self
+ *
+ * cdef void _set_final(self, int64 state, weight=None) except *: # <<<<<<<<<<<<<<
+ * if not self._mfst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._set_final", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2407
+ * self._check_mutating_imethod()
+ *
+ * def set_final(self, int64 state, weight=None): # <<<<<<<<<<<<<<
+ * """
+ * set_final(self, state, weight)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_51set_final(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_50set_final[] = "\n set_final(self, state, weight)\n\n Sets a state to be final with a fixed cost.\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 Raises:\n FstIndexError: State index out of range.\n FstOpError: incompatible or invalid weight.\n\n See also: `set_start`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_51set_final(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_final (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_state,&__pyx_n_s_weight,0};
+ PyObject* values[2] = {0,0};
+ values[1] = ((PyObject *)Py_None);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_final") < 0)) __PYX_ERR(0, 2407, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2407, __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, 2407, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.set_final", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_50set_final(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_state, __pyx_v_weight);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_50set_final(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final __pyx_t_1;
+ __Pyx_RefNannySetupContext("set_final", 0);
+
+ /* "pywrapfst.pyx":2424
+ * See also: `set_start`.
+ * """
+ * self._set_final(state, weight) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_set_final");
+ __PYX_ERR(0, 2424, __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, 2424, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2425
+ * """
+ * self._set_final(state, weight)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _set_properties(self, uint64 props, uint64 mask) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2407
+ * 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":2427
+ * return self
+ *
+ * cdef void _set_properties(self, uint64 props, uint64 mask) except *: # <<<<<<<<<<<<<<
+ * self._mfst.get().SetProperties(props, mask)
+ *
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_set_properties", 0);
+
+ /* "pywrapfst.pyx":2428
+ *
+ * cdef void _set_properties(self, uint64 props, uint64 mask) except *:
+ * self._mfst.get().SetProperties(props, mask) # <<<<<<<<<<<<<<
+ *
+ * def set_properties(self, uint64 props, uint64 mask):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2428, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst.get()->SetProperties(__pyx_v_props, __pyx_v_mask);
+
+ /* "pywrapfst.pyx":2427
+ * return self
+ *
+ * cdef void _set_properties(self, uint64 props, uint64 mask) except *: # <<<<<<<<<<<<<<
+ * self._mfst.get().SetProperties(props, mask)
+ *
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._set_properties", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2430
+ * self._mfst.get().SetProperties(props, mask)
+ *
+ * def set_properties(self, uint64 props, uint64 mask): # <<<<<<<<<<<<<<
+ * """
+ * set_properties(self, props, mask)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_53set_properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_52set_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\n setting the FST's properties.\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_53set_properties(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_uint64 __pyx_v_props;
+ __pyx_t_10basictypes_uint64 __pyx_v_mask;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_properties (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_props,&__pyx_n_s_mask,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_props)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("set_properties", 1, 2, 2, 1); __PYX_ERR(0, 2430, __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, 2430, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_props = __Pyx_PyInt_As_uint64_t(values[0]); if (unlikely((__pyx_v_props == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2430, __pyx_L3_error)
+ __pyx_v_mask = __Pyx_PyInt_As_uint64_t(values[1]); if (unlikely((__pyx_v_mask == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2430, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("set_properties", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2430, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.set_properties", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_52set_properties(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), __pyx_v_props, __pyx_v_mask);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_52set_properties(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_uint64 __pyx_v_props, __pyx_t_10basictypes_uint64 __pyx_v_mask) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_properties", 0);
+
+ /* "pywrapfst.pyx":2444
+ * self.
+ * """
+ * self._set_properties(props, mask) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_set_properties");
+ __PYX_ERR(0, 2444, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_properties(__pyx_v_self, __pyx_v_props, __pyx_v_mask); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2444, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2445
+ * """
+ * self._set_properties(props, mask)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _set_start(self, int64 state) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2430
+ * self._mfst.get().SetProperties(props, mask)
+ *
+ * def set_properties(self, uint64 props, uint64 mask): # <<<<<<<<<<<<<<
+ * """
+ * set_properties(self, props, mask)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.set_properties", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2447
+ * return self
+ *
+ * cdef void _set_start(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * if not self._mfst.get().SetStart(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("_set_start", 0);
+
+ /* "pywrapfst.pyx":2448
+ *
+ * cdef void _set_start(self, int64 state) except *:
+ * if not self._mfst.get().SetStart(state): # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * self._check_mutating_imethod()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2448, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_self->_mfst.get()->SetStart(__pyx_v_state) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2449
+ * cdef void _set_start(self, int64 state) except *:
+ * if not self._mfst.get().SetStart(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2449, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2449, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2449, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2448
+ *
+ * cdef void _set_start(self, int64 state) except *:
+ * if not self._mfst.get().SetStart(state): # <<<<<<<<<<<<<<
+ * raise FstIndexError("State index out of range")
+ * self._check_mutating_imethod()
+ */
+ }
+
+ /* "pywrapfst.pyx":2450
+ * if not self._mfst.get().SetStart(state):
+ * raise FstIndexError("State index out of range")
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def set_start(self, int64 state):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2450, __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, 2450, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2447
+ * return self
+ *
+ * cdef void _set_start(self, int64 state) except *: # <<<<<<<<<<<<<<
+ * if not self._mfst.get().SetStart(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._set_start", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2452
+ * self._check_mutating_imethod()
+ *
+ * def set_start(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * set_start(self, state)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_55set_start(PyObject *__pyx_v_self, PyObject *__pyx_arg_state); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_54set_start[] = "\n set_start(self, state)\n\n Sets the initial state.\n\n Args:\n state: The integer index of a state.\n\n Returns:\n self.\n\n Raises:\n FstIndexError: State index out of range.\n\n See also: `set_final`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_55set_start(PyObject *__pyx_v_self, PyObject *__pyx_arg_state) {
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_start (wrapper)", 0);
+ assert(__pyx_arg_state); {
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(__pyx_arg_state); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2452, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.set_start", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_54set_start(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_state));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_54set_start(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_start", 0);
+
+ /* "pywrapfst.pyx":2469
+ * See also: `set_final`.
+ * """
+ * self._set_start(state) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_set_start");
+ __PYX_ERR(0, 2469, __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, 2469, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2470
+ * """
+ * self._set_start(state)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _set_input_symbols(self, _SymbolTable syms) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2452
+ * self._check_mutating_imethod()
+ *
+ * def set_start(self, int64 state): # <<<<<<<<<<<<<<
+ * """
+ * set_start(self, state)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.set_start", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2472
+ * return self
+ *
+ * cdef void _set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * if syms is None:
+ * self._mfst.get().SetInputSymbols(NULL)
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ __Pyx_RefNannySetupContext("_set_input_symbols", 0);
+
+ /* "pywrapfst.pyx":2473
+ *
+ * cdef void _set_input_symbols(self, _SymbolTable syms) except *:
+ * if syms is None: # <<<<<<<<<<<<<<
+ * self._mfst.get().SetInputSymbols(NULL)
+ * return
+ */
+ __pyx_t_1 = (((PyObject *)__pyx_v_syms) == Py_None);
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2474
+ * cdef void _set_input_symbols(self, _SymbolTable syms) except *:
+ * if syms is None:
+ * self._mfst.get().SetInputSymbols(NULL) # <<<<<<<<<<<<<<
+ * return
+ * self._mfst.get().SetInputSymbols(syms._table)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2474, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst.get()->SetInputSymbols(NULL);
+
+ /* "pywrapfst.pyx":2475
+ * if syms is None:
+ * self._mfst.get().SetInputSymbols(NULL)
+ * return # <<<<<<<<<<<<<<
+ * self._mfst.get().SetInputSymbols(syms._table)
+ * self._check_mutating_imethod()
+ */
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2473
+ *
+ * cdef void _set_input_symbols(self, _SymbolTable syms) except *:
+ * if syms is None: # <<<<<<<<<<<<<<
+ * self._mfst.get().SetInputSymbols(NULL)
+ * return
+ */
+ }
+
+ /* "pywrapfst.pyx":2476
+ * self._mfst.get().SetInputSymbols(NULL)
+ * return
+ * self._mfst.get().SetInputSymbols(syms._table) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2476, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 2476, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst.get()->SetInputSymbols(__pyx_v_syms->_table);
+
+ /* "pywrapfst.pyx":2477
+ * return
+ * self._mfst.get().SetInputSymbols(syms._table)
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def set_input_symbols(self, _SymbolTable syms):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2477, __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, 2477, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2472
+ * return self
+ *
+ * cdef void _set_input_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * if syms is None:
+ * self._mfst.get().SetInputSymbols(NULL)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2479
+ * self._check_mutating_imethod()
+ *
+ * def set_input_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * set_input_symbols(self, syms)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_57set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_56set_input_symbols[] = "\n set_input_symbols(self, syms)\n\n Sets the input symbol table.\n\n Passing None as a value will delete the input symbol table.\n\n Args:\n syms: A SymbolTable.\n\n Returns:\n self.\n\n See also: `set_output_symbols`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_57set_input_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_input_symbols (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 2479, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_56set_input_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_56set_input_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_input_symbols", 0);
+
+ /* "pywrapfst.pyx":2495
+ * See also: `set_output_symbols`.
+ * """
+ * self._set_input_symbols(syms) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_set_input_symbols");
+ __PYX_ERR(0, 2495, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_input_symbols(__pyx_v_self, __pyx_v_syms); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2495, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2496
+ * """
+ * self._set_input_symbols(syms)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _set_output_symbols(self, _SymbolTable syms) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2479
+ * self._check_mutating_imethod()
+ *
+ * def set_input_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * set_input_symbols(self, syms)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.set_input_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2498
+ * return self
+ *
+ * cdef void _set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * if syms is None:
+ * self._mfst.get().SetOutputSymbols(NULL)
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ __Pyx_RefNannySetupContext("_set_output_symbols", 0);
+
+ /* "pywrapfst.pyx":2499
+ *
+ * cdef void _set_output_symbols(self, _SymbolTable syms) except *:
+ * if syms is None: # <<<<<<<<<<<<<<
+ * self._mfst.get().SetOutputSymbols(NULL)
+ * return
+ */
+ __pyx_t_1 = (((PyObject *)__pyx_v_syms) == Py_None);
+ __pyx_t_2 = (__pyx_t_1 != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2500
+ * cdef void _set_output_symbols(self, _SymbolTable syms) except *:
+ * if syms is None:
+ * self._mfst.get().SetOutputSymbols(NULL) # <<<<<<<<<<<<<<
+ * return
+ * self._mfst.get().SetOutputSymbols(syms._table)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2500, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst.get()->SetOutputSymbols(NULL);
+
+ /* "pywrapfst.pyx":2501
+ * if syms is None:
+ * self._mfst.get().SetOutputSymbols(NULL)
+ * return # <<<<<<<<<<<<<<
+ * self._mfst.get().SetOutputSymbols(syms._table)
+ * self._check_mutating_imethod()
+ */
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2499
+ *
+ * cdef void _set_output_symbols(self, _SymbolTable syms) except *:
+ * if syms is None: # <<<<<<<<<<<<<<
+ * self._mfst.get().SetOutputSymbols(NULL)
+ * return
+ */
+ }
+
+ /* "pywrapfst.pyx":2502
+ * self._mfst.get().SetOutputSymbols(NULL)
+ * return
+ * self._mfst.get().SetOutputSymbols(syms._table) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2502, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_syms) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 2502, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst.get()->SetOutputSymbols(__pyx_v_syms->_table);
+
+ /* "pywrapfst.pyx":2503
+ * return
+ * self._mfst.get().SetOutputSymbols(syms._table)
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def set_output_symbols(self, _SymbolTable syms):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2503, __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, 2503, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2498
+ * return self
+ *
+ * cdef void _set_output_symbols(self, _SymbolTable syms) except *: # <<<<<<<<<<<<<<
+ * if syms is None:
+ * self._mfst.get().SetOutputSymbols(NULL)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2505
+ * self._check_mutating_imethod()
+ *
+ * def set_output_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * set_output_symbols(self, syms)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_59set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_58set_output_symbols[] = "\n set_output_symbols(self, syms)\n\n Sets the output symbol table.\n\n Passing None as a value will delete the output symbol table.\n\n Args:\n syms: A SymbolTable.\n\n Returns:\n self.\n\n See also: `set_input_symbols`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_59set_output_symbols(PyObject *__pyx_v_self, PyObject *__pyx_v_syms) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_output_symbols (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_syms), __pyx_ptype_9pywrapfst__SymbolTable, 1, "syms", 0))) __PYX_ERR(0, 2505, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_58set_output_symbols(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__SymbolTable *)__pyx_v_syms));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_58set_output_symbols(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__SymbolTable *__pyx_v_syms) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_output_symbols", 0);
+
+ /* "pywrapfst.pyx":2521
+ * See also: `set_input_symbols`.
+ * """
+ * self._set_output_symbols(syms) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_set_output_symbols");
+ __PYX_ERR(0, 2521, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_set_output_symbols(__pyx_v_self, __pyx_v_syms); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2521, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2522
+ * """
+ * self._set_output_symbols(syms)
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _topsort(self) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2505
+ * self._check_mutating_imethod()
+ *
+ * def set_output_symbols(self, _SymbolTable syms): # <<<<<<<<<<<<<<
+ * """
+ * set_output_symbols(self, syms)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.set_output_symbols", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2524
+ * return self
+ *
+ * cdef void _topsort(self) except *: # <<<<<<<<<<<<<<
+ * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted.
+ * if not fst.TopSort(self._mfst.get()):
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("_topsort", 0);
+
+ /* "pywrapfst.pyx":2526
+ * cdef void _topsort(self) except *:
+ * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted.
+ * if not fst.TopSort(self._mfst.get()): # <<<<<<<<<<<<<<
+ * logging.warning("Cannot topsort cyclic FST.")
+ * self._check_mutating_imethod()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2526, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(fst::script::TopSort(__pyx_v_self->_mfst.get()) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2527
+ * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted.
+ * if not fst.TopSort(self._mfst.get()):
+ * logging.warning("Cannot topsort cyclic FST.") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2527, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warning); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2527, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2527, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2526
+ * cdef void _topsort(self) except *:
+ * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted.
+ * if not fst.TopSort(self._mfst.get()): # <<<<<<<<<<<<<<
+ * logging.warning("Cannot topsort cyclic FST.")
+ * self._check_mutating_imethod()
+ */
+ }
+
+ /* "pywrapfst.pyx":2528
+ * if not fst.TopSort(self._mfst.get()):
+ * logging.warning("Cannot topsort cyclic FST.")
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def topsort(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2528, __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, 2528, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2524
+ * return self
+ *
+ * cdef void _topsort(self) except *: # <<<<<<<<<<<<<<
+ * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted.
+ * if not fst.TopSort(self._mfst.get()):
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._MutableFst._topsort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2530
+ * self._check_mutating_imethod()
+ *
+ * def topsort(self): # <<<<<<<<<<<<<<
+ * """
+ * topsort(self)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_61topsort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_60topsort[] = "\n topsort(self)\n\n Sorts transitions by state IDs.\n\n This operation destructively topologically sorts the FST, if it is acyclic;\n otherwise it remains unchanged. Once sorted, all transitions are from lower\n state IDs to higher state IDs\n\n Returns:\n self.\n\n See also: `arcsort`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_61topsort(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("topsort (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_60topsort(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_60topsort(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("topsort", 0);
+
+ /* "pywrapfst.pyx":2545
+ * See also: `arcsort`.
+ * """
+ * self._topsort() # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_topsort");
+ __PYX_ERR(0, 2545, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_topsort(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2545, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2546
+ * """
+ * self._topsort()
+ * return self # <<<<<<<<<<<<<<
+ *
+ * cdef void _union(self, _Fst ifst) except *:
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2530
+ * self._check_mutating_imethod()
+ *
+ * def topsort(self): # <<<<<<<<<<<<<<
+ * """
+ * topsort(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.topsort", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2548
+ * return self
+ *
+ * cdef void _union(self, _Fst ifst) except *: # <<<<<<<<<<<<<<
+ * fst.Union(self._mfst.get(), deref(ifst._fst))
+ * self._check_mutating_imethod()
+ */
+
+static void __pyx_f_9pywrapfst_11_MutableFst__union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_union", 0);
+
+ /* "pywrapfst.pyx":2549
+ *
+ * cdef void _union(self, _Fst ifst) except *:
+ * fst.Union(self._mfst.get(), deref(ifst._fst)) # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2549, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 2549, __pyx_L1_error)
+ }
+ fst::script::Union(__pyx_v_self->_mfst.get(), (*__pyx_v_ifst->_fst));
+
+ /* "pywrapfst.pyx":2550
+ * cdef void _union(self, _Fst ifst) except *:
+ * fst.Union(self._mfst.get(), deref(ifst._fst))
+ * self._check_mutating_imethod() # <<<<<<<<<<<<<<
+ *
+ * def union(self, _Fst ifst):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_check_mutating_imethod");
+ __PYX_ERR(0, 2550, __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, 2550, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2548
+ * return self
+ *
+ * cdef void _union(self, _Fst ifst) except *: # <<<<<<<<<<<<<<
+ * fst.Union(self._mfst.get(), deref(ifst._fst))
+ * self._check_mutating_imethod()
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst._union", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":2552
+ * self._check_mutating_imethod()
+ *
+ * def union(self, _Fst ifst): # <<<<<<<<<<<<<<
+ * """
+ * union(self, ifst)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_63union(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst); /*proto*/
+static char __pyx_doc_9pywrapfst_11_MutableFst_62union[] = "\n union(self, ifst)\n\n Computes the union (sum) of two FSTs.\n\n This operation computes the union (sum) of two FSTs. If A transduces string\n x to y with weight a and B transduces string w to v with weight b, then\n their union transduces x to y with weight a and w to v with weight b.\n\n Args:\n ifst: The second input FST.\n\n Returns:\n self.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11_MutableFst_63union(PyObject *__pyx_v_self, PyObject *__pyx_v_ifst) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("union (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 2552, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11_MutableFst_62union(((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_v_self), ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_ifst));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11_MutableFst_62union(struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("union", 0);
+
+ /* "pywrapfst.pyx":2568
+ * self.
+ * """
+ * self._union(ifst) # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_union");
+ __PYX_ERR(0, 2568, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst__MutableFst *)__pyx_v_self->__pyx_base.__pyx_vtab)->_union(__pyx_v_self, __pyx_v_ifst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2568, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2569
+ * """
+ * self._union(ifst)
+ * return self # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __pyx_r = ((PyObject *)__pyx_v_self);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2552
+ * self._check_mutating_imethod()
+ *
+ * def union(self, _Fst ifst): # <<<<<<<<<<<<<<
+ * """
+ * union(self, ifst)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._MutableFst.union", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2594
+ *
+ *
+ * cdef _Fst _init_Fst(FstClass_ptr tfst): # <<<<<<<<<<<<<<
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed")
+ */
+
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_Fst(__pyx_t_9pywrapfst_FstClass_ptr __pyx_v_tfst) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ofst = 0;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("_init_Fst", 0);
+
+ /* "pywrapfst.pyx":2595
+ *
+ * cdef _Fst _init_Fst(FstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<<
+ * raise FstOpError("Operation failed")
+ * cdef _Fst ofst = _Fst.__new__(_Fst)
+ */
+ __pyx_t_1 = (__pyx_v_tfst->Properties(fst::kError, 1) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2596
+ * cdef _Fst _init_Fst(FstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed") # <<<<<<<<<<<<<<
+ * cdef _Fst ofst = _Fst.__new__(_Fst)
+ * ofst._fst.reset(<FstClass_ptr> tfst)
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2596, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2595
+ *
+ * cdef _Fst _init_Fst(FstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<<
+ * raise FstOpError("Operation failed")
+ * cdef _Fst ofst = _Fst.__new__(_Fst)
+ */
+ }
+
+ /* "pywrapfst.pyx":2597
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed")
+ * cdef _Fst ofst = _Fst.__new__(_Fst) # <<<<<<<<<<<<<<
+ * ofst._fst.reset(<FstClass_ptr> tfst)
+ * return ofst
+ */
+ __pyx_t_3 = __pyx_tp_new_9pywrapfst__Fst(((PyTypeObject *)__pyx_ptype_9pywrapfst__Fst), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2597, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pywrapfst__Fst)))) __PYX_ERR(0, 2597, __pyx_L1_error)
+ __pyx_v_ofst = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":2598
+ * raise FstOpError("Operation failed")
+ * cdef _Fst ofst = _Fst.__new__(_Fst)
+ * ofst._fst.reset(<FstClass_ptr> tfst) # <<<<<<<<<<<<<<
+ * return ofst
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ofst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 2598, __pyx_L1_error)
+ }
+ __pyx_v_ofst->_fst.reset(((__pyx_t_9pywrapfst_FstClass_ptr)__pyx_v_tfst));
+
+ /* "pywrapfst.pyx":2599
+ * cdef _Fst ofst = _Fst.__new__(_Fst)
+ * ofst._fst.reset(<FstClass_ptr> tfst)
+ * return ofst # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_ofst));
+ __pyx_r = __pyx_v_ofst;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2594
+ *
+ *
+ * cdef _Fst _init_Fst(FstClass_ptr tfst): # <<<<<<<<<<<<<<
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed")
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._init_Fst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_ofst);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2602
+ *
+ *
+ * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): # <<<<<<<<<<<<<<
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed")
+ */
+
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__init_MutableFst(__pyx_t_9pywrapfst_MutableFstClass_ptr __pyx_v_tfst) {
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ofst = 0;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("_init_MutableFst", 0);
+
+ /* "pywrapfst.pyx":2603
+ *
+ * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<<
+ * raise FstOpError("Operation failed")
+ * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst)
+ */
+ __pyx_t_1 = (__pyx_v_tfst->Properties(fst::kError, 1) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2604
+ * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed") # <<<<<<<<<<<<<<
+ * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst)
+ * ofst._fst.reset(<MutableFstClass_ptr> tfst)
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2604, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2604, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2604, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2603
+ *
+ * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True): # <<<<<<<<<<<<<<
+ * raise FstOpError("Operation failed")
+ * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst)
+ */
+ }
+
+ /* "pywrapfst.pyx":2605
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed")
+ * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst) # <<<<<<<<<<<<<<
+ * ofst._fst.reset(<MutableFstClass_ptr> tfst)
+ * # Makes a copy of it as the derived type! Cool.
+ */
+ __pyx_t_3 = __pyx_tp_new_9pywrapfst__MutableFst(((PyTypeObject *)__pyx_ptype_9pywrapfst__MutableFst), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2605, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pywrapfst__MutableFst)))) __PYX_ERR(0, 2605, __pyx_L1_error)
+ __pyx_v_ofst = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":2606
+ * raise FstOpError("Operation failed")
+ * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst)
+ * ofst._fst.reset(<MutableFstClass_ptr> tfst) # <<<<<<<<<<<<<<
+ * # Makes a copy of it as the derived type! Cool.
+ * ofst._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](ofst._fst)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ofst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 2606, __pyx_L1_error)
+ }
+ __pyx_v_ofst->__pyx_base._fst.reset(((__pyx_t_9pywrapfst_MutableFstClass_ptr)__pyx_v_tfst));
+
+ /* "pywrapfst.pyx":2608
+ * ofst._fst.reset(<MutableFstClass_ptr> 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 '%s'", "_fst");
+ __PYX_ERR(0, 2608, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ofst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 2608, __pyx_L1_error)
+ }
+ __pyx_v_ofst->_mfst = std::static_pointer_cast<fst::script::MutableFstClass,fst::script::FstClass>(__pyx_v_ofst->__pyx_base._fst);
+
+ /* "pywrapfst.pyx":2609
+ * # Makes a copy of it as the derived type! Cool.
+ * ofst._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](ofst._fst)
+ * return ofst # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(((PyObject *)__pyx_v_ofst));
+ __pyx_r = __pyx_v_ofst;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2602
+ *
+ *
+ * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst): # <<<<<<<<<<<<<<
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed")
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst._init_MutableFst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_ofst);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2612
+ *
+ *
+ * cdef _Fst _init_XFst(FstClass_ptr tfst): # <<<<<<<<<<<<<<
+ * if tfst.Properties(fst.kMutable, True):
+ * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst))
+ */
+
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__init_XFst(__pyx_t_9pywrapfst_FstClass_ptr __pyx_v_tfst) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("_init_XFst", 0);
+
+ /* "pywrapfst.pyx":2613
+ *
+ * cdef _Fst _init_XFst(FstClass_ptr tfst):
+ * if tfst.Properties(fst.kMutable, True): # <<<<<<<<<<<<<<
+ * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst))
+ * else:
+ */
+ __pyx_t_1 = (__pyx_v_tfst->Properties(fst::kMutable, 1) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2614
+ * cdef _Fst _init_XFst(FstClass_ptr tfst):
+ * if tfst.Properties(fst.kMutable, True):
+ * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst)) # <<<<<<<<<<<<<<
+ * else:
+ * return _init_Fst(tfst)
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(static_cast<__pyx_t_9pywrapfst_MutableFstClass_ptr>(__pyx_v_tfst))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2614, __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":2613
+ *
+ * cdef _Fst _init_XFst(FstClass_ptr tfst):
+ * if tfst.Properties(fst.kMutable, True): # <<<<<<<<<<<<<<
+ * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst))
+ * else:
+ */
+ }
+
+ /* "pywrapfst.pyx":2616
+ * 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, 2616, __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":2612
+ *
+ *
+ * cdef _Fst _init_XFst(FstClass_ptr tfst): # <<<<<<<<<<<<<<
+ * if tfst.Properties(fst.kMutable, True):
+ * return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_AddTraceback("pywrapfst._init_XFst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2619
+ *
+ *
+ * cdef _MutableFst _create_Fst(arc_type=b"standard"): # <<<<<<<<<<<<<<
+ * cdef fst.VectorFstClass *tfst = new fst.VectorFstClass(
+ * <string> tostring(arc_type))
+ */
+
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst__create_Fst(struct __pyx_opt_args_9pywrapfst__create_Fst *__pyx_optional_args) {
+ PyObject *__pyx_v_arc_type = ((PyObject *)__pyx_n_b_standard);
+ fst::script::VectorFstClass *__pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_create_Fst", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_arc_type = __pyx_optional_args->arc_type;
+ }
+ }
+
+ /* "pywrapfst.pyx":2621
+ * cdef _MutableFst _create_Fst(arc_type=b"standard"):
+ * cdef fst.VectorFstClass *tfst = new fst.VectorFstClass(
+ * <string> tostring(arc_type)) # <<<<<<<<<<<<<<
+ * if tfst == NULL:
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2621, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2620
+ *
+ * cdef _MutableFst _create_Fst(arc_type=b"standard"):
+ * cdef fst.VectorFstClass *tfst = new fst.VectorFstClass( # <<<<<<<<<<<<<<
+ * <string> tostring(arc_type))
+ * if tfst == NULL:
+ */
+ __pyx_v_tfst = new fst::script::VectorFstClass(((std::string)__pyx_t_1));
+
+ /* "pywrapfst.pyx":2622
+ * cdef fst.VectorFstClass *tfst = new fst.VectorFstClass(
+ * <string> tostring(arc_type))
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ * return _init_MutableFst(tfst)
+ */
+ __pyx_t_2 = ((__pyx_v_tfst == NULL) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2623
+ * <string> tostring(arc_type))
+ * if tfst == NULL:
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_arc_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_arc_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_arc_type};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_arc_type);
+ __Pyx_GIVEREF(__pyx_v_arc_type);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_arc_type);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2623, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2622
+ * cdef fst.VectorFstClass *tfst = new fst.VectorFstClass(
+ * <string> tostring(arc_type))
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ * return _init_MutableFst(tfst)
+ */
+ }
+
+ /* "pywrapfst.pyx":2624
+ * if tfst == NULL:
+ * raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2624, __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":2619
+ *
+ *
+ * cdef _MutableFst _create_Fst(arc_type=b"standard"): # <<<<<<<<<<<<<<
+ * cdef fst.VectorFstClass *tfst = new fst.VectorFstClass(
+ * <string> tostring(arc_type))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._create_Fst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2627
+ *
+ *
+ * cdef _Fst _read_Fst(filename, fst_type=None): # <<<<<<<<<<<<<<
+ * cdef fst.FstClass *tfst = fst.FstClass.Read(tostring(filename))
+ * if tfst == NULL:
+ */
+
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__read_Fst(PyObject *__pyx_v_filename, struct __pyx_opt_args_9pywrapfst__read_Fst *__pyx_optional_args) {
+ PyObject *__pyx_v_fst_type = ((PyObject *)Py_None);
+ fst::script::FstClass *__pyx_v_tfst;
+ std::string __pyx_v_fst_type_string;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("_read_Fst", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_fst_type = __pyx_optional_args->fst_type;
+ }
+ }
+
+ /* "pywrapfst.pyx":2628
+ *
+ * cdef _Fst _read_Fst(filename, fst_type=None):
+ * cdef fst.FstClass *tfst = fst.FstClass.Read(tostring(filename)) # <<<<<<<<<<<<<<
+ * if tfst == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2628, __pyx_L1_error)
+ __pyx_v_tfst = fst::script::FstClass::Read(__pyx_t_1);
+
+ /* "pywrapfst.pyx":2629
+ * cdef _Fst _read_Fst(filename, fst_type=None):
+ * cdef fst.FstClass *tfst = fst.FstClass.Read(tostring(filename))
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * # Converts if requested.
+ */
+ __pyx_t_2 = ((__pyx_v_tfst == NULL) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2630
+ * cdef fst.FstClass *tfst = fst.FstClass.Read(tostring(filename))
+ * if tfst == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ * # Converts if requested.
+ * cdef string fst_type_string
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_filename); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_filename};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_filename);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2630, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2629
+ * cdef _Fst _read_Fst(filename, fst_type=None):
+ * cdef fst.FstClass *tfst = fst.FstClass.Read(tostring(filename))
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filename))
+ * # Converts if requested.
+ */
+ }
+
+ /* "pywrapfst.pyx":2633
+ * # Converts if requested.
+ * cdef string fst_type_string
+ * if fst_type: # <<<<<<<<<<<<<<
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != tfst.FstType():
+ */
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_fst_type); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2633, __pyx_L1_error)
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2634
+ * cdef string fst_type_string
+ * if fst_type:
+ * fst_type_string = tostring(fst_type) # <<<<<<<<<<<<<<
+ * if fst_type_string != tfst.FstType():
+ * tfst = fst.Convert(deref(tfst), fst_type_string)
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_fst_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2634, __pyx_L1_error)
+ __pyx_v_fst_type_string = __pyx_t_1;
+
+ /* "pywrapfst.pyx":2635
+ * if fst_type:
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != tfst.FstType(): # <<<<<<<<<<<<<<
+ * tfst = fst.Convert(deref(tfst), fst_type_string)
+ * if tfst == NULL:
+ */
+ __pyx_t_2 = ((__pyx_v_fst_type_string != __pyx_v_tfst->FstType()) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2636
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != tfst.FstType():
+ * tfst = fst.Convert(deref(tfst), fst_type_string) # <<<<<<<<<<<<<<
+ * if tfst == NULL:
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ */
+ __pyx_v_tfst = fst::script::Convert((*__pyx_v_tfst), __pyx_v_fst_type_string);
+
+ /* "pywrapfst.pyx":2637
+ * if fst_type_string != tfst.FstType():
+ * tfst = fst.Convert(deref(tfst), fst_type_string)
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ * return _init_XFst(tfst)
+ */
+ __pyx_t_2 = ((__pyx_v_tfst == NULL) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":2638
+ * tfst = fst.Convert(deref(tfst), fst_type_string)
+ * if tfst == NULL:
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type)) # <<<<<<<<<<<<<<
+ * return _init_XFst(tfst)
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Conversion_to_r_failed, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_fst_type); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_fst_type};
+ __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_8);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_fst_type};
+ __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_8);
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_INCREF(__pyx_v_fst_type);
+ __Pyx_GIVEREF(__pyx_v_fst_type);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_fst_type);
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __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);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_8};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_8};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_8);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_8);
+ __pyx_t_8 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2638, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2638, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2637
+ * if fst_type_string != tfst.FstType():
+ * tfst = fst.Convert(deref(tfst), fst_type_string)
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ * return _init_XFst(tfst)
+ */
+ }
+
+ /* "pywrapfst.pyx":2635
+ * if fst_type:
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != tfst.FstType(): # <<<<<<<<<<<<<<
+ * tfst = fst.Convert(deref(tfst), fst_type_string)
+ * if tfst == NULL:
+ */
+ }
+
+ /* "pywrapfst.pyx":2633
+ * # Converts if requested.
+ * cdef string fst_type_string
+ * if fst_type: # <<<<<<<<<<<<<<
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != tfst.FstType():
+ */
+ }
+
+ /* "pywrapfst.pyx":2639
+ * if tfst == NULL:
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ * return _init_XFst(tfst) # <<<<<<<<<<<<<<
+ *
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=None):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2639, __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":2627
+ *
+ *
+ * cdef _Fst _read_Fst(filename, fst_type=None): # <<<<<<<<<<<<<<
+ * cdef fst.FstClass *tfst = fst.FstClass.Read(tostring(filename))
+ * if tfst == NULL:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._read_Fst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2641
+ * return _init_XFst(tfst)
+ *
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=None): # <<<<<<<<<<<<<<
+ * ofst = fst.FstClass.ReadFromString(fst_string)
+ * if fst_type is not None:
+ */
+
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__deserialize_Fst(PyObject *__pyx_v_fst_string, struct __pyx_opt_args_9pywrapfst__deserialize_Fst *__pyx_optional_args) {
+ PyObject *__pyx_v_fst_type = ((PyObject *)Py_None);
+ fst::script::FstClass *__pyx_v_ofst;
+ std::string __pyx_v_fst_type_string;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ __Pyx_RefNannySetupContext("_deserialize_Fst", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_fst_type = __pyx_optional_args->fst_type;
+ }
+ }
+
+ /* "pywrapfst.pyx":2642
+ *
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=None):
+ * ofst = fst.FstClass.ReadFromString(fst_string) # <<<<<<<<<<<<<<
+ * if fst_type is not None:
+ * fst_type_string = tostring(fst_type)
+ */
+ __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_fst_string); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2642, __pyx_L1_error)
+ __pyx_v_ofst = fst::script::FstClass::ReadFromString(__pyx_t_1);
+
+ /* "pywrapfst.pyx":2643
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=None):
+ * ofst = fst.FstClass.ReadFromString(fst_string)
+ * if fst_type is not None: # <<<<<<<<<<<<<<
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != ofst.FstType():
+ */
+ __pyx_t_2 = (__pyx_v_fst_type != Py_None);
+ __pyx_t_3 = (__pyx_t_2 != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":2644
+ * ofst = fst.FstClass.ReadFromString(fst_string)
+ * if fst_type is not None:
+ * fst_type_string = tostring(fst_type) # <<<<<<<<<<<<<<
+ * if fst_type_string != ofst.FstType():
+ * ofst = fst.Convert(deref(ofst), fst_type_string)
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_fst_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2644, __pyx_L1_error)
+ __pyx_v_fst_type_string = __pyx_t_1;
+
+ /* "pywrapfst.pyx":2645
+ * if fst_type is not None:
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != ofst.FstType(): # <<<<<<<<<<<<<<
+ * ofst = fst.Convert(deref(ofst), fst_type_string)
+ * if ofst == NULL:
+ */
+ __pyx_t_3 = ((__pyx_v_fst_type_string != __pyx_v_ofst->FstType()) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":2646
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != ofst.FstType():
+ * ofst = fst.Convert(deref(ofst), fst_type_string) # <<<<<<<<<<<<<<
+ * if ofst == NULL:
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ */
+ __pyx_v_ofst = fst::script::Convert((*__pyx_v_ofst), __pyx_v_fst_type_string);
+
+ /* "pywrapfst.pyx":2647
+ * if fst_type_string != ofst.FstType():
+ * ofst = fst.Convert(deref(ofst), fst_type_string)
+ * if ofst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ * return _init_XFst(ofst)
+ */
+ __pyx_t_3 = ((__pyx_v_ofst == NULL) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":2648
+ * ofst = fst.Convert(deref(ofst), fst_type_string)
+ * if ofst == NULL:
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type)) # <<<<<<<<<<<<<<
+ * return _init_XFst(ofst)
+ *
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Conversion_to_r_failed, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+ if (likely(__pyx_t_8)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
+ }
+ }
+ if (!__pyx_t_8) {
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_fst_type); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_fst_type};
+ __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_fst_type};
+ __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+ __Pyx_INCREF(__pyx_v_fst_type);
+ __Pyx_GIVEREF(__pyx_v_fst_type);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_fst_type);
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2648, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 2648, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2647
+ * if fst_type_string != ofst.FstType():
+ * ofst = fst.Convert(deref(ofst), fst_type_string)
+ * if ofst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ * return _init_XFst(ofst)
+ */
+ }
+
+ /* "pywrapfst.pyx":2645
+ * if fst_type is not None:
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != ofst.FstType(): # <<<<<<<<<<<<<<
+ * ofst = fst.Convert(deref(ofst), fst_type_string)
+ * if ofst == NULL:
+ */
+ }
+
+ /* "pywrapfst.pyx":2643
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=None):
+ * ofst = fst.FstClass.ReadFromString(fst_string)
+ * if fst_type is not None: # <<<<<<<<<<<<<<
+ * fst_type_string = tostring(fst_type)
+ * if fst_type_string != ofst.FstType():
+ */
+ }
+
+ /* "pywrapfst.pyx":2649
+ * if ofst == NULL:
+ * raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ * return _init_XFst(ofst) # <<<<<<<<<<<<<<
+ *
+ * class Fst(object):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_ofst)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2649, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_4);
+ __pyx_t_4 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2641
+ * return _init_XFst(tfst)
+ *
+ * cdef _Fst _deserialize_Fst(fst_string, fst_type=None): # <<<<<<<<<<<<<<
+ * ofst = fst.FstClass.ReadFromString(fst_string)
+ * if fst_type is not None:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_AddTraceback("pywrapfst._deserialize_Fst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2668
+ * """
+ *
+ * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<<
+ * return _create_Fst(arc_type)
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Fst_1__new__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_9pywrapfst_3Fst_1__new__ = {"__new__", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_1__new__, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_9pywrapfst_3Fst_1__new__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ CYTHON_UNUSED PyObject *__pyx_v_cls = 0;
+ PyObject *__pyx_v_arc_type = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__new__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cls,&__pyx_n_s_arc_type,0};
+ PyObject* values[2] = {0,0};
+ values[1] = ((PyObject *)((PyObject*)__pyx_n_b_standard));
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cls)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__new__") < 0)) __PYX_ERR(0, 2668, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_cls = values[0];
+ __pyx_v_arc_type = values[1];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("__new__", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2668, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Fst.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_3Fst___new__(__pyx_self, __pyx_v_cls, __pyx_v_arc_type);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Fst___new__(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_cls, PyObject *__pyx_v_arc_type) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst__create_Fst __pyx_t_2;
+ __Pyx_RefNannySetupContext("__new__", 0);
+
+ /* "pywrapfst.pyx":2669
+ *
+ * def __new__(cls, arc_type=b"standard"):
+ * return _create_Fst(arc_type) # <<<<<<<<<<<<<<
+ *
+ * @staticmethod
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.arc_type = __pyx_v_arc_type;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__create_Fst(&__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2669, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2668
+ * """
+ *
+ * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<<
+ * return _create_Fst(arc_type)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.Fst.__new__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2672
+ *
+ * @staticmethod
+ * def read(filename, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read(filename, fst_type=None)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Fst_3read(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_3Fst_2read[] = "\n read(filename, fst_type=None)\n\n Reads an FST from a file.\n\n Args:\n filename: The string location of the input file.\n fst_type: A string indicating the FST type to convert to; no conversion\n is performed if omitted or if the FST is already of the desired type.\n\n Returns:\n An FST object.\n\n Raises:\n FstIOError: Read failed.\n FstOpError: Read-time conversion failed.\n ";
+static PyMethodDef __pyx_mdef_9pywrapfst_3Fst_3read = {"read", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_3read, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_3Fst_2read};
+static PyObject *__pyx_pw_9pywrapfst_3Fst_3read(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_filename = 0;
+ PyObject *__pyx_v_fst_type = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("read (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_fst_type,0};
+ PyObject* values[2] = {0,0};
+ values[1] = ((PyObject *)((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);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fst_type);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read") < 0)) __PYX_ERR(0, 2672, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_filename = values[0];
+ __pyx_v_fst_type = values[1];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("read", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2672, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Fst.read", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_3Fst_2read(__pyx_self, __pyx_v_filename, __pyx_v_fst_type);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Fst_2read(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_fst_type) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst__read_Fst __pyx_t_2;
+ __Pyx_RefNannySetupContext("read", 0);
+
+ /* "pywrapfst.pyx":2690
+ * FstOpError: Read-time conversion failed.
+ * """
+ * return _read_Fst(filename, fst_type) # <<<<<<<<<<<<<<
+ *
+ * @staticmethod
+ */
+ __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__read_Fst(__pyx_v_filename, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2690, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2672
+ *
+ * @staticmethod
+ * def read(filename, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read(filename, fst_type=None)
+ */
+
+ /* 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":2693
+ *
+ * @staticmethod
+ * def read_from_string(fst_string, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read_from_string(fst_string, fst_type=None)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Fst_5read_from_string(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_3Fst_4read_from_string[] = "\n read_from_string(fst_string, fst_type=None)\n\n Reads an FST from a string.\n\n Args:\n fst_string: The string containing the serialized Fst.\n fst_type: A string indicating the FST type to convert to; no conversion\n is performed if omitted or if the FST is already of the desired type.\n\n Returns:\n An FST object.\n\n Raises:\n FstIOError: Read failed.\n FstOpError: Read-time conversion failed.\n ";
+static PyMethodDef __pyx_mdef_9pywrapfst_3Fst_5read_from_string = {"read_from_string", (PyCFunction)__pyx_pw_9pywrapfst_3Fst_5read_from_string, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_3Fst_4read_from_string};
+static PyObject *__pyx_pw_9pywrapfst_3Fst_5read_from_string(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_fst_string = 0;
+ PyObject *__pyx_v_fst_type = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("read_from_string (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fst_string,&__pyx_n_s_fst_type,0};
+ PyObject* values[2] = {0,0};
+ values[1] = ((PyObject *)((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);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fst_string)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fst_type);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "read_from_string") < 0)) __PYX_ERR(0, 2693, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_fst_string = values[0];
+ __pyx_v_fst_type = values[1];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("read_from_string", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2693, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Fst.read_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_3Fst_4read_from_string(__pyx_self, __pyx_v_fst_string, __pyx_v_fst_type);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Fst_4read_from_string(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_fst_string, PyObject *__pyx_v_fst_type) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst__deserialize_Fst __pyx_t_2;
+ __Pyx_RefNannySetupContext("read_from_string", 0);
+
+ /* "pywrapfst.pyx":2711
+ * FstOpError: Read-time conversion failed.
+ * """
+ * return _deserialize_Fst(fst_string, fst_type) # <<<<<<<<<<<<<<
+ *
+ * ## FST properties.
+ */
+ __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__deserialize_Fst(__pyx_v_fst_string, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2711, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2693
+ *
+ * @staticmethod
+ * def read_from_string(fst_string, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read_from_string(fst_string, fst_type=None)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.Fst.read_from_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2795
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<Arc at 0x{:x}>".format(id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Arc_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_3Arc_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc___repr__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Arc___repr__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":2796
+ *
+ * def __repr__(self):
+ * return "<Arc at 0x{:x}>".format(id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Arc_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_3)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_3) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2796, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2795
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<Arc at 0x{:x}>".format(id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.Arc.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2798
+ * return "<Arc at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): # <<<<<<<<<<<<<<
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight)
+ * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_3Arc_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_3Arc_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_int64 __pyx_v_ilabel;
+ __pyx_t_10basictypes_int64 __pyx_v_olabel;
+ PyObject *__pyx_v_weight = 0;
+ __pyx_t_10basictypes_int64 __pyx_v_nextstate;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ilabel,&__pyx_n_s_olabel,&__pyx_n_s_weight,&__pyx_n_s_nextstate,0};
+ PyObject* values[4] = {0,0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ilabel)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_olabel)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(0, 2798, __pyx_L3_error)
+ }
+ case 2:
+ if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(0, 2798, __pyx_L3_error)
+ }
+ case 3:
+ if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nextstate)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(0, 2798, __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, 2798, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ }
+ __pyx_v_ilabel = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_ilabel == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2798, __pyx_L3_error)
+ __pyx_v_olabel = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_olabel == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2798, __pyx_L3_error)
+ __pyx_v_weight = values[2];
+ __pyx_v_nextstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nextstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2798, __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, 2798, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Arc.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_2__init__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), __pyx_v_ilabel, __pyx_v_olabel, __pyx_v_weight, __pyx_v_nextstate);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_3Arc_2__init__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_ilabel, __pyx_t_10basictypes_int64 __pyx_v_olabel, PyObject *__pyx_v_weight, __pyx_t_10basictypes_int64 __pyx_v_nextstate) {
+ fst::script::WeightClass __pyx_v_wc;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ fst::script::WeightClass __pyx_t_2;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":2799
+ *
+ * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate):
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight) # <<<<<<<<<<<<<<
+ * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate))
+ *
+ */
+ __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_tropical); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2799, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst__get_WeightClass_or_One(__pyx_t_1, __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2799, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_2;
+
+ /* "pywrapfst.pyx":2800
+ * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate):
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight)
+ * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate)) # <<<<<<<<<<<<<<
+ *
+ * cpdef Arc copy(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc");
+ __PYX_ERR(0, 2800, __pyx_L1_error)
+ }
+ __pyx_v_self->_arc.reset(new fst::script::ArcClass(__pyx_v_ilabel, __pyx_v_olabel, __pyx_v_wc, __pyx_v_nextstate));
+
+ /* "pywrapfst.pyx":2798
+ * return "<Arc at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate): # <<<<<<<<<<<<<<
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight)
+ * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate))
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst.Arc.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2802
+ * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate))
+ *
+ * cpdef Arc copy(self): # <<<<<<<<<<<<<<
+ * return Arc(self.ilabel, self.olabel, self.weight, self.nextstate)
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_3Arc_5copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static struct __pyx_obj_9pywrapfst_Arc *__pyx_f_9pywrapfst_3Arc_copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst_Arc *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2802, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_3Arc_5copy)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2802, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2802, __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, 2802, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst_Arc *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2803
+ *
+ * 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, 2803, __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, 2803, __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, 2803, __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, 2803, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2803, __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, 2803, __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":2802
+ * self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate))
+ *
+ * cpdef Arc copy(self): # <<<<<<<<<<<<<<
+ * return Arc(self.ilabel, self.olabel, self.weight, self.nextstate)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.Arc.copy", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Arc_5copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_3Arc_5copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("copy (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_4copy(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Arc_4copy(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("copy", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_3Arc_copy(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2802, __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":2807
+ * property ilabel:
+ *
+ * def __get__(self): # <<<<<<<<<<<<<<
+ * return deref(self._arc).ilabel
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Arc_6ilabel_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_3Arc_6ilabel_1__get__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_6ilabel___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Arc_6ilabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "pywrapfst.pyx":2808
+ *
+ * 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 '%s'", "_arc");
+ __PYX_ERR(0, 2808, __pyx_L1_error)
+ }
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).ilabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2808, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2807
+ * 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":2810
+ * return deref(self._arc).ilabel
+ *
+ * def __set__(self, int64 value): # <<<<<<<<<<<<<<
+ * deref(self._arc).ilabel = value
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_3Arc_6ilabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/
+static int __pyx_pw_9pywrapfst_3Arc_6ilabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) {
+ __pyx_t_10basictypes_int64 __pyx_v_value;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+ assert(__pyx_arg_value); {
+ __pyx_v_value = __Pyx_PyInt_As_int64_t(__pyx_arg_value); if (unlikely((__pyx_v_value == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2810, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Arc.ilabel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_6ilabel_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_value));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_3Arc_6ilabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__set__", 0);
+
+ /* "pywrapfst.pyx":2811
+ *
+ * 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 '%s'", "_arc");
+ __PYX_ERR(0, 2811, __pyx_L1_error)
+ }
+ (*__pyx_v_self->_arc).ilabel = __pyx_v_value;
+
+ /* "pywrapfst.pyx":2810
+ * 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":2815
+ * property olabel:
+ *
+ * def __get__(self): # <<<<<<<<<<<<<<
+ * return deref(self._arc).olabel
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Arc_6olabel_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_3Arc_6olabel_1__get__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_6olabel___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Arc_6olabel___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "pywrapfst.pyx":2816
+ *
+ * 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 '%s'", "_arc");
+ __PYX_ERR(0, 2816, __pyx_L1_error)
+ }
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).olabel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2816, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2815
+ * 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":2818
+ * return deref(self._arc).olabel
+ *
+ * def __set__(self, int64 value): # <<<<<<<<<<<<<<
+ * deref(self._arc).olabel = value
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_3Arc_6olabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/
+static int __pyx_pw_9pywrapfst_3Arc_6olabel_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) {
+ __pyx_t_10basictypes_int64 __pyx_v_value;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+ assert(__pyx_arg_value); {
+ __pyx_v_value = __Pyx_PyInt_As_int64_t(__pyx_arg_value); if (unlikely((__pyx_v_value == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Arc.olabel.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_6olabel_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_value));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_3Arc_6olabel_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__set__", 0);
+
+ /* "pywrapfst.pyx":2819
+ *
+ * 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 '%s'", "_arc");
+ __PYX_ERR(0, 2819, __pyx_L1_error)
+ }
+ (*__pyx_v_self->_arc).olabel = __pyx_v_value;
+
+ /* "pywrapfst.pyx":2818
+ * 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":2823
+ * property weight:
+ *
+ * def __get__(self): # <<<<<<<<<<<<<<
+ * cdef Weight weight = Weight.__new__(Weight)
+ * weight._weight.reset(new fst.WeightClass(deref(self._arc).weight))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Arc_6weight_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_3Arc_6weight_1__get__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_6weight___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Arc_6weight___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_weight = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "pywrapfst.pyx":2824
+ *
+ * def __get__(self):
+ * cdef Weight weight = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * weight._weight.reset(new fst.WeightClass(deref(self._arc).weight))
+ * return weight
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2824, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 2824, __pyx_L1_error)
+ __pyx_v_weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":2825
+ * 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 '%s'", "_weight");
+ __PYX_ERR(0, 2825, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc");
+ __PYX_ERR(0, 2825, __pyx_L1_error)
+ }
+ __pyx_v_weight->_weight.reset(new fst::script::WeightClass((*__pyx_v_self->_arc).weight));
+
+ /* "pywrapfst.pyx":2826
+ * 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":2823
+ * 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":2828
+ * return weight
+ *
+ * def __set__(self, weight): # <<<<<<<<<<<<<<
+ * deref(self._arc).weight = _get_WeightClass_or_One(b"tropical", weight)
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_3Arc_6weight_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_weight); /*proto*/
+static int __pyx_pw_9pywrapfst_3Arc_6weight_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_weight) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_6weight_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((PyObject *)__pyx_v_weight));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_3Arc_6weight_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, PyObject *__pyx_v_weight) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ fst::script::WeightClass __pyx_t_2;
+ __Pyx_RefNannySetupContext("__set__", 0);
+
+ /* "pywrapfst.pyx":2829
+ *
+ * def __set__(self, weight):
+ * deref(self._arc).weight = _get_WeightClass_or_One(b"tropical", weight) # <<<<<<<<<<<<<<
+ *
+ * property nextstate:
+ */
+ __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_tropical); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2829, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst__get_WeightClass_or_One(__pyx_t_1, __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2829, __pyx_L1_error)
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc");
+ __PYX_ERR(0, 2829, __pyx_L1_error)
+ }
+ (*__pyx_v_self->_arc).weight = __pyx_t_2;
+
+ /* "pywrapfst.pyx":2828
+ * 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":2833
+ * property nextstate:
+ *
+ * def __get__(self): # <<<<<<<<<<<<<<
+ * return deref(self._arc).nextstate
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_3Arc_9nextstate_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_3Arc_9nextstate_1__get__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_9nextstate___get__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_3Arc_9nextstate___get__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__get__", 0);
+
+ /* "pywrapfst.pyx":2834
+ *
+ * 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 '%s'", "_arc");
+ __PYX_ERR(0, 2834, __pyx_L1_error)
+ }
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t((*__pyx_v_self->_arc).nextstate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2834, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2833
+ * 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":2836
+ * return deref(self._arc).nextstate
+ *
+ * def __set__(self, int64 value): # <<<<<<<<<<<<<<
+ * deref(self._arc).nextstate = value
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_3Arc_9nextstate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/
+static int __pyx_pw_9pywrapfst_3Arc_9nextstate_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) {
+ __pyx_t_10basictypes_int64 __pyx_v_value;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+ assert(__pyx_arg_value); {
+ __pyx_v_value = __Pyx_PyInt_As_int64_t(__pyx_arg_value); if (unlikely((__pyx_v_value == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2836, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Arc.nextstate.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_3Arc_9nextstate_2__set__(((struct __pyx_obj_9pywrapfst_Arc *)__pyx_v_self), ((__pyx_t_10basictypes_int64)__pyx_v_value));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_3Arc_9nextstate_2__set__(struct __pyx_obj_9pywrapfst_Arc *__pyx_v_self, __pyx_t_10basictypes_int64 __pyx_v_value) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__set__", 0);
+
+ /* "pywrapfst.pyx":2837
+ *
+ * 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 '%s'", "_arc");
+ __PYX_ERR(0, 2837, __pyx_L1_error)
+ }
+ (*__pyx_v_self->_arc).nextstate = __pyx_v_value;
+
+ /* "pywrapfst.pyx":2836
+ * 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;
+}
+
+/* "pywrapfst.pyx":2840
+ *
+ *
+ * cdef Arc _init_Arc(const fst.ArcClass &arc): # <<<<<<<<<<<<<<
+ * cdef Weight weight = Weight.__new__(Weight)
+ * weight._weight.reset(new fst.WeightClass(arc.weight))
+ */
+
+static struct __pyx_obj_9pywrapfst_Arc *__pyx_f_9pywrapfst__init_Arc(fst::script::ArcClass const &__pyx_v_arc) {
+ struct __pyx_obj_9pywrapfst_Weight *__pyx_v_weight = 0;
+ struct __pyx_obj_9pywrapfst_Arc *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("_init_Arc", 0);
+
+ /* "pywrapfst.pyx":2841
+ *
+ * cdef Arc _init_Arc(const fst.ArcClass &arc):
+ * cdef Weight weight = Weight.__new__(Weight) # <<<<<<<<<<<<<<
+ * weight._weight.reset(new fst.WeightClass(arc.weight))
+ * return Arc(<int64> arc.ilabel, <int64> arc.olabel, weight,
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_Weight(((PyTypeObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2841, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_Weight)))) __PYX_ERR(0, 2841, __pyx_L1_error)
+ __pyx_v_weight = ((struct __pyx_obj_9pywrapfst_Weight *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":2842
+ * cdef Arc _init_Arc(const fst.ArcClass &arc):
+ * cdef Weight weight = Weight.__new__(Weight)
+ * weight._weight.reset(new fst.WeightClass(arc.weight)) # <<<<<<<<<<<<<<
+ * return Arc(<int64> arc.ilabel, <int64> arc.olabel, weight,
+ * <int64> arc.nextstate)
+ */
+ if (unlikely(((PyObject *)__pyx_v_weight) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_weight");
+ __PYX_ERR(0, 2842, __pyx_L1_error)
+ }
+ __pyx_v_weight->_weight.reset(new fst::script::WeightClass(__pyx_v_arc.weight));
+
+ /* "pywrapfst.pyx":2843
+ * cdef Weight weight = Weight.__new__(Weight)
+ * weight._weight.reset(new fst.WeightClass(arc.weight))
+ * return Arc(<int64> arc.ilabel, <int64> arc.olabel, weight, # <<<<<<<<<<<<<<
+ * <int64> arc.nextstate)
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(((__pyx_t_10basictypes_int64)__pyx_v_arc.ilabel)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2843, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyInt_From_int64_t(((__pyx_t_10basictypes_int64)__pyx_v_arc.olabel)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2843, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":2844
+ * weight._weight.reset(new fst.WeightClass(arc.weight))
+ * return Arc(<int64> arc.ilabel, <int64> arc.olabel, weight,
+ * <int64> arc.nextstate) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_int64_t(((__pyx_t_10basictypes_int64)__pyx_v_arc.nextstate)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2844, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+
+ /* "pywrapfst.pyx":2843
+ * cdef Weight weight = Weight.__new__(Weight)
+ * weight._weight.reset(new fst.WeightClass(arc.weight))
+ * return Arc(<int64> arc.ilabel, <int64> arc.olabel, weight, # <<<<<<<<<<<<<<
+ * <int64> arc.nextstate)
+ *
+ */
+ __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2843, __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, 2843, __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":2840
+ *
+ *
+ * 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":2857
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<ArcIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator___repr__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator___repr__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":2858
+ *
+ * def __repr__(self):
+ * return "<ArcIterator at 0x{:x}>".format(id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self, _Fst ifst, int64 state):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_ArcIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_3)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_3) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2858, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2857
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<ArcIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.ArcIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2860
+ * return "<ArcIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _Fst ifst, int64 state): # <<<<<<<<<<<<<<
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_11ArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_11ArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_state,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 2860, __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, 2860, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]);
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2860, __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, 2860, __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, 2860, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_2__init__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self), __pyx_v_ifst, __pyx_v_state);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_11ArcIterator_2__init__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ std::shared_ptr<fst::script::FstClass> __pyx_t_4;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":2861
+ *
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 2861, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_ifst->_fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2862
+ * def __init__(self, _Fst ifst, int64 state):
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ * self._fst = ifst._fst
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2862, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2862, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 2862, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2861
+ *
+ * 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":2864
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 2864, __pyx_L1_error)
+ }
+ __pyx_t_4 = __pyx_v_ifst->_fst;
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 2864, __pyx_L1_error)
+ }
+ __pyx_v_self->_fst = __pyx_t_4;
+
+ /* "pywrapfst.pyx":2865
+ * # 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 '%s'", "_aiter");
+ __PYX_ERR(0, 2865, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 2865, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.reset(new fst::script::ArcIteratorClass((*__pyx_v_self->_fst), __pyx_v_state));
+
+ /* "pywrapfst.pyx":2860
+ * return "<ArcIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _Fst ifst, int64 state): # <<<<<<<<<<<<<<
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst.ArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2868
+ *
+ * # 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":2869
+ * # 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":2868
+ *
+ * # 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":2872
+ *
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self): # <<<<<<<<<<<<<<
+ * if self.done():
+ * raise StopIteration
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_7__next__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_7__next__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_6__next__(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_6__next__(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_v_result = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("__next__", 0);
+
+ /* "pywrapfst.pyx":2873
+ * # 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 '%s'", "done");
+ __PYX_ERR(0, 2873, __pyx_L1_error)
+ }
+ __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_ArcIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":2874
+ * def __next__(self):
+ * if self.done():
+ * raise StopIteration # <<<<<<<<<<<<<<
+ * result = self.value()
+ * self.next()
+ */
+ __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0);
+ __PYX_ERR(0, 2874, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2873
+ * # 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":2875
+ * 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 '%s'", "value");
+ __PYX_ERR(0, 2875, __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, 2875, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_v_result = __pyx_t_2;
+ __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2876
+ * 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 '%s'", "next");
+ __PYX_ERR(0, 2876, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_ArcIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":2877
+ * 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":2872
+ *
+ * # 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":2879
+ * return result
+ *
+ * cpdef bool done(self): # <<<<<<<<<<<<<<
+ * """
+ * done(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_11ArcIterator_done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("done", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2879, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_9done)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2879, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2879, __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, 2879, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2891
+ * True if the iterator is exhausted, False otherwise.
+ * """
+ * return self._aiter.get().Done() # <<<<<<<<<<<<<<
+ *
+ * cpdef uint32 flags(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_aiter");
+ __PYX_ERR(0, 2891, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_aiter.get()->Done();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2879
+ * 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, 0, 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 This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("done (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_8done(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_8done(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("done", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_11ArcIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2879, __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":2893
+ * return self._aiter.get().Done()
+ *
+ * cpdef uint32 flags(self): # <<<<<<<<<<<<<<
+ * """
+ * flags(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_11ArcIterator_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_uint32 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_uint32 __pyx_t_5;
+ __Pyx_RefNannySetupContext("flags", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2893, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_11flags)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2893, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2893, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2905
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 2905, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_aiter.get()->Flags();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2893
+ * return self._aiter.get().Done()
+ *
+ * cpdef uint32 flags(self): # <<<<<<<<<<<<<<
+ * """
+ * flags(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst.ArcIterator.flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 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 This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n The current iterator behavioral flags as an integer.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("flags (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_10flags(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_10flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("flags", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_f_9pywrapfst_11ArcIterator_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2893, __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":2907
+ * return self._aiter.get().Flags()
+ *
+ * cpdef void next(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_13next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2907, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_13next)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2907, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2907, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2916
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 2916, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->Next();
+
+ /* "pywrapfst.pyx":2907
+ * 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, 0, 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\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_13next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("next (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_12next(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_12next(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2907, __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":2918
+ * self._aiter.get().Next()
+ *
+ * cpdef size_t position(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_15position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static size_t __pyx_f_9pywrapfst_11ArcIterator_position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ size_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ size_t __pyx_t_5;
+ __Pyx_RefNannySetupContext("position", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2918, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_15position)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2918, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2918, __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, 2918, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2930
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 2930, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_aiter.get()->Position();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2918
+ * self._aiter.get().Next()
+ *
+ * cpdef size_t position(self): # <<<<<<<<<<<<<<
+ * """
+ * next(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, 0, 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 next(self)\n\n Returns the position of the iterator.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n The iterator's position, expressed as an integer.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_15position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("position (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_14position(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_14position(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("position", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_9pywrapfst_11ArcIterator_position(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2918, __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":2932
+ * return self._aiter.get().Position()
+ *
+ * cpdef void reset(self): # <<<<<<<<<<<<<<
+ * """
+ * reset(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_17reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2932, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_17reset)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2932, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2932, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2941
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 2941, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->Reset();
+
+ /* "pywrapfst.pyx":2932
+ * 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, 0, 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\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_17reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reset (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_16reset(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_16reset(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2932, __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":2943
+ * self._aiter.get().Reset()
+ *
+ * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<<
+ * """
+ * seek(self, a)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("seek", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_seek); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_19seek)) {
+ __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2943, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2943, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2943, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2943, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2943, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2943, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2955
+ * a: The position to seek to.
+ * """
+ * self._aiter.get().Seek(a) # <<<<<<<<<<<<<<
+ *
+ * cpdef void set_flags(self, uint32 flags, uint32 mask):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_aiter");
+ __PYX_ERR(0, 2955, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->Seek(__pyx_v_a);
+
+ /* "pywrapfst.pyx":2943
+ * self._aiter.get().Reset()
+ *
+ * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<<
+ * """
+ * seek(self, a)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_WriteUnraisable("pywrapfst.ArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 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 This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Args:\n a: The position to seek to.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a) {
+ size_t __pyx_v_a;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("seek (wrapper)", 0);
+ assert(__pyx_arg_a); {
+ __pyx_v_a = __Pyx_PyInt_As_size_t(__pyx_arg_a); if (unlikely((__pyx_v_a == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2943, __pyx_L3_error)
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.ArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_18seek(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self), ((size_t)__pyx_v_a));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_18seek(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, size_t __pyx_v_a) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("seek", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_seek(__pyx_v_self, __pyx_v_a, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __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":2957
+ * self._aiter.get().Seek(a)
+ *
+ * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<<
+ * """
+ * set_flags(self, flags, mask)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static void __pyx_f_9pywrapfst_11ArcIterator_set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("set_flags", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2957, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_21set_flags)) {
+ __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2957, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2957, __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, 2957, __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, 2957, __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, 2957, __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, 2957, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2970
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 2970, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->SetFlags(__pyx_v_flags, __pyx_v_mask);
+
+ /* "pywrapfst.pyx":2957
+ * self._aiter.get().Seek(a)
+ *
+ * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<<
+ * """
+ * set_flags(self, flags, mask)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_WriteUnraisable("pywrapfst.ArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 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 This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Args:\n flags: The properties to be set.\n mask: A mask to be applied to the `flags` argument before setting them.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_uint32 __pyx_v_flags;
+ __pyx_t_10basictypes_uint32 __pyx_v_mask;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_flags (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flags,&__pyx_n_s_mask,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, 1); __PYX_ERR(0, 2957, __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, 2957, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_flags = __Pyx_PyInt_As_uint32_t(values[0]); if (unlikely((__pyx_v_flags == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2957, __pyx_L3_error)
+ __pyx_v_mask = __Pyx_PyInt_As_uint32_t(values[1]); if (unlikely((__pyx_v_mask == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2957, __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, 2957, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.ArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_20set_flags(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self), __pyx_v_flags, __pyx_v_mask);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_20set_flags(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("set_flags", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_11ArcIterator_set_flags(__pyx_v_self, __pyx_v_flags, __pyx_v_mask, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2957, __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":2972
+ * self._aiter.get().SetFlags(flags, mask)
+ *
+ * cpdef object value(self): # <<<<<<<<<<<<<<
+ * """
+ * value(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_23value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_f_9pywrapfst_11ArcIterator_value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("value", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2972, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_23value)) {
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2972, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2972, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":2981
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 2981, __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, 2981, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2972
+ * 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, represented as a tuple.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_11ArcIterator_23value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("value (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_11ArcIterator_22value(((struct __pyx_obj_9pywrapfst_ArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_11ArcIterator_22value(struct __pyx_obj_9pywrapfst_ArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("value", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_f_9pywrapfst_11ArcIterator_value(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2972, __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;
+}
+
+/* "pywrapfst.pyx":2995
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<MutableArcIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator___repr__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator___repr__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":2996
+ *
+ * def __repr__(self):
+ * return "<MutableArcIterator at 0x{:x}>".format(id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self, _MutableFst ifst, int64 state):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MutableArcIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_3)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_3) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2996, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":2995
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<MutableArcIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":2998
+ * return "<MutableArcIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _MutableFst ifst, int64 state): # <<<<<<<<<<<<<<
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_18MutableArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_18MutableArcIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ifst = 0;
+ __pyx_t_10basictypes_int64 __pyx_v_state;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_state,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_state)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 2998, __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, 2998, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__MutableFst *)values[0]);
+ __pyx_v_state = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_state == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2998, __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, 2998, __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, 2998, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_2__init__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self), __pyx_v_ifst, __pyx_v_state);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_18MutableArcIterator_2__init__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_ifst, __pyx_t_10basictypes_int64 __pyx_v_state) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ std::shared_ptr<fst::script::MutableFstClass> __pyx_t_4;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":2999
+ *
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 2999, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(__pyx_v_ifst->__pyx_base._fst.get()->ValidStateId(__pyx_v_state) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":3000
+ * def __init__(self, _MutableFst ifst, int64 state):
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ * self._mfst = ifst._mfst
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIndexError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3000, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3000, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 3000, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2999
+ *
+ * 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":3002
+ * 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 '%s'", "_mfst");
+ __PYX_ERR(0, 3002, __pyx_L1_error)
+ }
+ __pyx_t_4 = __pyx_v_ifst->_mfst;
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 3002, __pyx_L1_error)
+ }
+ __pyx_v_self->_mfst = __pyx_t_4;
+
+ /* "pywrapfst.pyx":3003
+ * # 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)) # <<<<<<<<<<<<<<
+ *
+ * # 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3003, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_mfst");
+ __PYX_ERR(0, 3003, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.reset(new fst::script::MutableArcIteratorClass(__pyx_v_ifst->_mfst.get(), __pyx_v_state));
+
+ /* "pywrapfst.pyx":2998
+ * return "<MutableArcIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _MutableFst ifst, int64 state): # <<<<<<<<<<<<<<
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range")
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst.MutableArcIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3006
+ *
+ * # This just registers this class as a possible iterator.
+ * def __iter__(self): # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+
+/* 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) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__iter__", 0);
+
+ /* "pywrapfst.pyx":3007
+ * # 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":3006
+ *
+ * # 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":3010
+ *
+ * # 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_18MutableArcIterator_7__next__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_7__next__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_6__next__(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_6__next__(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_v_result = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("__next__", 0);
+
+ /* "pywrapfst.pyx":3011
+ * # 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 '%s'", "done");
+ __PYX_ERR(0, 3011, __pyx_L1_error)
+ }
+ __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":3012
+ * def __next__(self):
+ * if self.done():
+ * raise StopIteration # <<<<<<<<<<<<<<
+ * result = self.value()
+ * self.next()
+ */
+ __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0);
+ __PYX_ERR(0, 3012, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3011
+ * # 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":3013
+ * 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 '%s'", "value");
+ __PYX_ERR(0, 3013, __pyx_L1_error)
+ }
+ __pyx_t_2 = ((struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *)__pyx_v_self->__pyx_vtab)->value(__pyx_v_self, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3013, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_v_result = __pyx_t_2;
+ __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":3014
+ * 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 '%s'", "next");
+ __PYX_ERR(0, 3014, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":3015
+ * 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":3010
+ *
+ * # 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.MutableArcIterator.__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":3017
+ * return result
+ *
+ * cpdef bool done(self): # <<<<<<<<<<<<<<
+ * """
+ * done(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_18MutableArcIterator_done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("done", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3017, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_9done)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3017, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3017, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3017, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3029
+ * True if the iterator is exhausted, False otherwise.
+ * """
+ * return self._aiter.get().Done() # <<<<<<<<<<<<<<
+ *
+ * cpdef uint32 flags(self):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_aiter");
+ __PYX_ERR(0, 3029, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_aiter.get()->Done();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3017
+ * 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.MutableArcIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_8done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n ";
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_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_18MutableArcIterator_8done(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_8done(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("done", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_18MutableArcIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3017, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.MutableArcIterator.done", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3031
+ * return self._aiter.get().Done()
+ *
+ * cpdef uint32 flags(self): # <<<<<<<<<<<<<<
+ * """
+ * flags(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_uint32 __pyx_f_9pywrapfst_18MutableArcIterator_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_uint32 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_uint32 __pyx_t_5;
+ __Pyx_RefNannySetupContext("flags", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3031, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_11flags)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3031, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3031, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3031, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3043
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3043, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_aiter.get()->Flags();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3031
+ * return self._aiter.get().Done()
+ *
+ * cpdef uint32 flags(self): # <<<<<<<<<<<<<<
+ * """
+ * flags(self)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_11flags(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_10flags[] = "\n flags(self)\n\n Returns the current iterator behavioral flags.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n The current iterator behavioral flags as an integer.\n ";
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_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_18MutableArcIterator_10flags(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_10flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("flags", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_f_9pywrapfst_18MutableArcIterator_flags(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3031, __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":3045
+ * return self._aiter.get().Flags()
+ *
+ * cpdef void next(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_13next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3045, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_13next)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3045, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3045, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3054
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3054, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->Next();
+
+ /* "pywrapfst.pyx":3045
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_13next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_12next[] = "\n next(self)\n\n Advances the iterator.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_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_18MutableArcIterator_12next(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_12next(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3045, __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":3056
+ * self._aiter.get().Next()
+ *
+ * cpdef size_t position(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_15position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static size_t __pyx_f_9pywrapfst_18MutableArcIterator_position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ size_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ size_t __pyx_t_5;
+ __Pyx_RefNannySetupContext("position", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_position); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3056, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_15position)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3056, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3056, __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, 3056, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3068
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3068, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_aiter.get()->Position();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3056
+ * self._aiter.get().Next()
+ *
+ * cpdef size_t position(self): # <<<<<<<<<<<<<<
+ * """
+ * next(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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_15position(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_14position[] = "\n next(self)\n\n Returns the position of the iterator.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n The iterator's position, expressed as an integer.\n ";
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_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_18MutableArcIterator_14position(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_14position(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("position", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_9pywrapfst_18MutableArcIterator_position(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3056, __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":3070
+ * return self._aiter.get().Position()
+ *
+ * cpdef void reset(self): # <<<<<<<<<<<<<<
+ * """
+ * reset(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_17reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3070, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_17reset)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3070, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3070, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3079
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3079, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->Reset();
+
+ /* "pywrapfst.pyx":3070
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_17reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_16reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_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_18MutableArcIterator_16reset(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_16reset(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3070, __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":3081
+ * self._aiter.get().Reset()
+ *
+ * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<<
+ * """
+ * seek(self, a)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ __Pyx_RefNannySetupContext("seek", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_seek); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3081, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_19seek)) {
+ __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_a); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3081, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_4 = __pyx_t_1; __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3081, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3081, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3081, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3081, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3081, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3093
+ * a: The position to seek to.
+ * """
+ * self._aiter.get().Seek(a) # <<<<<<<<<<<<<<
+ *
+ * cpdef void set_flags(self, uint32 flags, uint32 mask):
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_aiter");
+ __PYX_ERR(0, 3093, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->Seek(__pyx_v_a);
+
+ /* "pywrapfst.pyx":3081
+ * self._aiter.get().Reset()
+ *
+ * cpdef void seek(self, size_t a): # <<<<<<<<<<<<<<
+ * """
+ * seek(self, a)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.seek", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_18seek[] = "\n seek(self, a)\n\n Advance the iterator to a new position.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Args:\n a: The position to seek to.\n ";
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_19seek(PyObject *__pyx_v_self, PyObject *__pyx_arg_a) {
+ size_t __pyx_v_a;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("seek (wrapper)", 0);
+ assert(__pyx_arg_a); {
+ __pyx_v_a = __Pyx_PyInt_As_size_t(__pyx_arg_a); if (unlikely((__pyx_v_a == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3081, __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_18seek(((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_18seek(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, size_t __pyx_v_a) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("seek", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_seek(__pyx_v_self, __pyx_v_a, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3081, __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":3095
+ * self._aiter.get().Seek(a)
+ *
+ * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<<
+ * """
+ * set_flags(self, flags, mask)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("set_flags", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3095, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_21set_flags)) {
+ __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3095, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3095, __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, 3095, __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, 3095, __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, 3095, __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, 3095, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3108
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3108, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->SetFlags(__pyx_v_flags, __pyx_v_mask);
+
+ /* "pywrapfst.pyx":3095
+ * self._aiter.get().Seek(a)
+ *
+ * cpdef void set_flags(self, uint32 flags, uint32 mask): # <<<<<<<<<<<<<<
+ * """
+ * set_flags(self, flags, mask)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_20set_flags[] = "\n set_flags(self, flags, mask)\n\n Sets the current iterator behavioral flags.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\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_21set_flags(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ __pyx_t_10basictypes_uint32 __pyx_v_flags;
+ __pyx_t_10basictypes_uint32 __pyx_v_mask;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_flags (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_flags,&__pyx_n_s_mask,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mask)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("set_flags", 1, 2, 2, 1); __PYX_ERR(0, 3095, __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, 3095, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_flags = __Pyx_PyInt_As_uint32_t(values[0]); if (unlikely((__pyx_v_flags == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3095, __pyx_L3_error)
+ __pyx_v_mask = __Pyx_PyInt_As_uint32_t(values[1]); if (unlikely((__pyx_v_mask == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3095, __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, 3095, __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_20set_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_20set_flags(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, __pyx_t_10basictypes_uint32 __pyx_v_flags, __pyx_t_10basictypes_uint32 __pyx_v_mask) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("set_flags", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_set_flags(__pyx_v_self, __pyx_v_flags, __pyx_v_mask, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3095, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.MutableArcIterator.set_flags", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3110
+ * self._aiter.get().SetFlags(flags, mask)
+ *
+ * cpdef void set_value(self, Arc arc): # <<<<<<<<<<<<<<
+ * """
+ * set_value(self, arc)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_23set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc); /*proto*/
+static void __pyx_f_9pywrapfst_18MutableArcIterator_set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("set_value", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3110, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_23set_value)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_arc)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3110, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_arc)};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3110, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, ((PyObject *)__pyx_v_arc)};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3110, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3110, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(((PyObject *)__pyx_v_arc));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_arc));
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_arc));
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3110, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3119
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3119, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_arc) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc");
+ __PYX_ERR(0, 3119, __pyx_L1_error)
+ }
+ __pyx_v_self->_aiter.get()->SetValue((*__pyx_v_arc->_arc));
+
+ /* "pywrapfst.pyx":3110
+ * self._aiter.get().SetFlags(flags, mask)
+ *
+ * cpdef void set_value(self, Arc arc): # <<<<<<<<<<<<<<
+ * """
+ * set_value(self, arc)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_WriteUnraisable("pywrapfst.MutableArcIterator.set_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_23set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_22set_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_23set_value(PyObject *__pyx_v_self, PyObject *__pyx_v_arc) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_value (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arc), __pyx_ptype_9pywrapfst_Arc, 1, "arc", 0))) __PYX_ERR(0, 3110, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_18MutableArcIterator_22set_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_22set_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, struct __pyx_obj_9pywrapfst_Arc *__pyx_v_arc) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("set_value", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_18MutableArcIterator_set_value(__pyx_v_self, __pyx_v_arc, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3110, __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":3121
+ * self._aiter.get().SetValue(deref(arc._arc))
+ *
+ * cpdef object value(self): # <<<<<<<<<<<<<<
+ * """
+ * value(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_25value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_f_9pywrapfst_18MutableArcIterator_value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("value", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3121, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_25value)) {
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3121, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3121, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3130
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_aiter");
+ __PYX_ERR(0, 3130, __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, 3130, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3121
+ * 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_25value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_18MutableArcIterator_24value[] = "\n value(self)\n\n Returns the current arc, represented as a tuple.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_18MutableArcIterator_25value(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_24value(((struct __pyx_obj_9pywrapfst_MutableArcIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18MutableArcIterator_24value(struct __pyx_obj_9pywrapfst_MutableArcIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("value", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_f_9pywrapfst_18MutableArcIterator_value(__pyx_v_self, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3121, __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;
+}
+
+/* "pywrapfst.pyx":3146
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<StateIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_1__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_1__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_13StateIterator___repr__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator___repr__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":3147
+ *
+ * def __repr__(self):
+ * return "<StateIterator at 0x{:x}>".format(id(self)) # <<<<<<<<<<<<<<
+ *
+ * def __init__(self, _Fst ifst):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_StateIterator_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_3)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_3) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3146
+ * """
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<StateIterator at 0x{:x}>".format(id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.StateIterator.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3149
+ * return "<StateIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _Fst ifst): # <<<<<<<<<<<<<<
+ * # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ * self._fst = ifst._fst
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_13StateIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_13StateIterator_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,0};
+ PyObject* values[1] = {0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 3149, __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, 3149, __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, 3149, __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<fst::script::FstClass> __pyx_t_1;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":3151
+ * 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 '%s'", "_fst");
+ __PYX_ERR(0, 3151, __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 '%s'", "_fst");
+ __PYX_ERR(0, 3151, __pyx_L1_error)
+ }
+ __pyx_v_self->_fst = __pyx_t_1;
+
+ /* "pywrapfst.pyx":3152
+ * # 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 '%s'", "_siter");
+ __PYX_ERR(0, 3152, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3152, __pyx_L1_error)
+ }
+ __pyx_v_self->_siter.reset(new fst::script::StateIteratorClass((*__pyx_v_self->_fst)));
+
+ /* "pywrapfst.pyx":3149
+ * return "<StateIterator at 0x{:x}>".format(id(self))
+ *
+ * def __init__(self, _Fst ifst): # <<<<<<<<<<<<<<
+ * # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ * self._fst = ifst._fst
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst.StateIterator.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3155
+ *
+ * # 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":3156
+ * # 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":3155
+ *
+ * # 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":3159
+ *
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self): # <<<<<<<<<<<<<<
+ * if self.done():
+ * raise StopIteration
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_7__next__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_7__next__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_6__next__(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_6__next__(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) {
+ __pyx_t_10basictypes_int64 __pyx_v_result;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("__next__", 0);
+
+ /* "pywrapfst.pyx":3160
+ * # 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 '%s'", "done");
+ __PYX_ERR(0, 3160, __pyx_L1_error)
+ }
+ __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":3161
+ * 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, 3161, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3160
+ * # 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":3162
+ * 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 '%s'", "value");
+ __PYX_ERR(0, 3162, __pyx_L1_error)
+ }
+ __pyx_v_result = ((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->value(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":3163
+ * 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 '%s'", "next");
+ __PYX_ERR(0, 3163, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_StateIterator *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":3164
+ * 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, 3164, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_r = __pyx_t_2;
+ __pyx_t_2 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3159
+ *
+ * # 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":3166
+ * return result
+ *
+ * cpdef bool done(self): # <<<<<<<<<<<<<<
+ * """
+ * done(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_13StateIterator_done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("done", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3166, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_9done)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3166, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3166, __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, 3166, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3178
+ * 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 '%s'", "_siter");
+ __PYX_ERR(0, 3178, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_siter.get()->Done();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3166
+ * 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, 0, 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 This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n ";
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_9done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("done (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_8done(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_8done(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("done", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_13StateIterator_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3166, __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":3180
+ * return self._siter.get().Done()
+ *
+ * cpdef void next(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_13StateIterator_next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3180, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_11next)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3180, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3180, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3189
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_siter");
+ __PYX_ERR(0, 3189, __pyx_L1_error)
+ }
+ __pyx_v_self->_siter.get()->Next();
+
+ /* "pywrapfst.pyx":3180
+ * 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, 0, 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\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_11next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("next (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_10next(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_10next(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_13StateIterator_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3180, __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":3191
+ * self._siter.get().Next()
+ *
+ * cpdef void reset(self): # <<<<<<<<<<<<<<
+ * """
+ * reset(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_13StateIterator_reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3191, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_13reset)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3191, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3191, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3200
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_siter");
+ __PYX_ERR(0, 3200, __pyx_L1_error)
+ }
+ __pyx_v_self->_siter.get()->Reset();
+
+ /* "pywrapfst.pyx":3191
+ * 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, 0, 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\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_13reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reset (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_12reset(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_12reset(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_13StateIterator_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3191, __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":3202
+ * self._siter.get().Reset()
+ *
+ * cpdef int64 value(self): # <<<<<<<<<<<<<<
+ * """
+ * value(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_15value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static __pyx_t_10basictypes_int64 __pyx_f_9pywrapfst_13StateIterator_value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self, int __pyx_skip_dispatch) {
+ __pyx_t_10basictypes_int64 __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_5;
+ __Pyx_RefNannySetupContext("value", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3202, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_15value)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3202, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3202, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_5 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3202, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":3211
+ * should use the Pythonic API.
+ * """
+ * return self._siter.get().Value() # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_siter");
+ __PYX_ERR(0, 3211, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_siter.get()->Value();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3202
+ * 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, 0, 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\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_13StateIterator_15value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("value (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_13StateIterator_14value(((struct __pyx_obj_9pywrapfst_StateIterator *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_13StateIterator_14value(struct __pyx_obj_9pywrapfst_StateIterator *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("value", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_f_9pywrapfst_13StateIterator_value(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3202, __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;
+}
+
+/* "pywrapfst.pyx":3217
+ *
+ *
+ * cdef _Fst _map(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ */
+
+static struct __pyx_obj_9pywrapfst__Fst *__pyx_f_9pywrapfst__map(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, struct __pyx_opt_args_9pywrapfst__map *__pyx_optional_args) {
+ float __pyx_v_delta = __pyx_k__34;
+ PyObject *__pyx_v_mt = ((PyObject *)__pyx_n_b_identity);
+
+ /* "pywrapfst.pyx":3220
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ * weight=None): # <<<<<<<<<<<<<<
+ * cdef fst.MapType map_type
+ * if not fst.GetMapType(tostring(mt), addr(map_type)):
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ enum fst::script::MapType __pyx_v_map_type;
+ fst::script::WeightClass __pyx_v_wc;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ fst::script::WeightClass __pyx_t_9;
+ fst::script::WeightClass __pyx_t_10;
+ __Pyx_RefNannySetupContext("_map", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_mt = __pyx_optional_args->mt;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3222
+ * weight=None):
+ * cdef fst.MapType map_type
+ * if not fst.GetMapType(tostring(mt), addr(map_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown map type: {!r}".format(mt))
+ * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(),
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_mt, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3222, __pyx_L1_error)
+ __pyx_t_2 = ((!(fst::script::GetMapType(__pyx_t_1, (&__pyx_v_map_type)) != 0)) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":3223
+ * cdef fst.MapType map_type
+ * if not fst.GetMapType(tostring(mt), addr(map_type)):
+ * raise FstArgError("Unknown map type: {!r}".format(mt)) # <<<<<<<<<<<<<<
+ * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(),
+ * weight) if mt == fst.TIMES_MAPPER else
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_map_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_mt); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_mt};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_mt};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_mt);
+ __Pyx_GIVEREF(__pyx_v_mt);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_mt);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 3223, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3222
+ * weight=None):
+ * cdef fst.MapType map_type
+ * if not fst.GetMapType(tostring(mt), addr(map_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown map type: {!r}".format(mt))
+ * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(),
+ */
+ }
+
+ /* "pywrapfst.pyx":3225
+ * raise FstArgError("Unknown map type: {!r}".format(mt))
+ * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(),
+ * weight) if mt == fst.TIMES_MAPPER else # <<<<<<<<<<<<<<
+ * _get_WeightClass_or_Zero(ifst.weight_type(), weight))
+ * return _init_XFst(fst.Map(deref(ifst._fst), map_type, delta, wc))
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__fst_3a__3a_script_3a__3a_MapType(fst::script::TIMES_MAPPER); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3225, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_mt, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3225, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3225, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":3224
+ * if not fst.GetMapType(tostring(mt), addr(map_type)):
+ * raise FstArgError("Unknown map type: {!r}".format(mt))
+ * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(), # <<<<<<<<<<<<<<
+ * weight) if mt == fst.TIMES_MAPPER else
+ * _get_WeightClass_or_Zero(ifst.weight_type(), weight))
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 3224, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3225
+ * raise FstArgError("Unknown map type: {!r}".format(mt))
+ * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(),
+ * weight) if mt == fst.TIMES_MAPPER else # <<<<<<<<<<<<<<
+ * _get_WeightClass_or_Zero(ifst.weight_type(), weight))
+ * return _init_XFst(fst.Map(deref(ifst._fst), map_type, delta, wc))
+ */
+ __pyx_t_10 = __pyx_f_9pywrapfst__get_WeightClass_or_One(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3224, __pyx_L1_error)
+ __pyx_t_9 = __pyx_t_10;
+ } else {
+
+ /* "pywrapfst.pyx":3226
+ * cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(),
+ * weight) if mt == fst.TIMES_MAPPER else
+ * _get_WeightClass_or_Zero(ifst.weight_type(), weight)) # <<<<<<<<<<<<<<
+ * return _init_XFst(fst.Map(deref(ifst._fst), map_type, delta, wc))
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 3226, __pyx_L1_error)
+ }
+ __pyx_t_10 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3226, __pyx_L1_error)
+ __pyx_t_9 = __pyx_t_10;
+ }
+ __pyx_v_wc = __pyx_t_9;
+
+ /* "pywrapfst.pyx":3227
+ * weight) if mt == fst.TIMES_MAPPER else
+ * _get_WeightClass_or_Zero(ifst.weight_type(), weight))
+ * return _init_XFst(fst.Map(deref(ifst._fst), map_type, delta, wc)) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3227, __pyx_L1_error)
+ }
+ __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(fst::script::Map((*__pyx_v_ifst->_fst), __pyx_v_map_type, __pyx_v_delta, __pyx_v_wc))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3227, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_4);
+ __pyx_t_4 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3217
+ *
+ *
+ * cdef _Fst _map(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("pywrapfst._map", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3230
+ *
+ *
+ * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_13arcmap(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__35;
+ PyObject *__pyx_v_mt = ((PyObject *)__pyx_n_b_identity);
+
+ /* "pywrapfst.pyx":3233
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * arcmap(ifst, delta=0.0009765625, mt="identity", weight=None)
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst__map __pyx_t_2;
+ __Pyx_RefNannySetupContext("arcmap", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_mt = __pyx_optional_args->mt;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3271
+ * See also: `statemap`.
+ * """
+ * return _map(ifst, delta, mt, weight) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_2.__pyx_n = 3;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.mt = __pyx_v_mt;
+ __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, 3271, __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":3230
+ *
+ *
+ * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.arcmap", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_13arcmap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_12arcmap[] = "\n arcmap(ifst, delta=0.0009765625, mt=\"identity\", weight=None)\n\n Constructively applies a transform to all arcs and final states.\n\n This operation transforms each arc and final state in the input FST using\n one of the following:\n\n * identity: maps to self.\n * input_epsilon: replaces all input labels with epsilon.\n * invert: reciprocates all non-Zero weights.\n * output_epsilon: replaces all output labels with epsilon.\n * plus: adds a constant to all weights.\n * quantize: quantizes weights.\n * rmweight: replaces all non-Zero weights with 1.\n * superfinal: redirects final states to a new superfinal state.\n * times: right-multiplies a constant to all weights.\n * to_log: converts weights to the log semiring.\n * to_log64: converts weights to the log64 semiring.\n * to_standard: converts weights to the tropical (\"standard\") semiring.\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta (ignored unless `mt` is `quantize`).\n map_type: A string matching a known mapping operation (see above).\n weight: A Weight or weight string passed to the arc-mapper; this is ignored\n unless `mt` is `plus` (in which case it defaults to semiring Zero) or\n `times` (in which case it defaults to semiring One).\n\n Returns:\n An FST with arcs and final states remapped.\n\n Raises:\n FstArgError: Unknown map type.\n\n See also: `statemap`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_13arcmap(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_mt = 0;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("arcmap (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_mt,&__pyx_n_s_weight,0};
+ PyObject* values[4] = {0,0,0,0};
+ values[2] = ((PyObject *)__pyx_n_b_identity);
+
+ /* "pywrapfst.pyx":3233
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * arcmap(ifst, delta=0.0009765625, mt="identity", 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);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mt);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "arcmap") < 0)) __PYX_ERR(0, 3230, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3231, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__35;
+ }
+ __pyx_v_mt = values[2];
+ __pyx_v_weight = values[3];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("arcmap", 0, 1, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3230, __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, 3230, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_12arcmap(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_mt, __pyx_v_weight);
+
+ /* "pywrapfst.pyx":3230
+ *
+ *
+ * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_12arcmap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_mt, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_arcmap __pyx_t_2;
+ __Pyx_RefNannySetupContext("arcmap", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 3;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.mt = __pyx_v_mt;
+ __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, 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.arcmap", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3274
+ *
+ *
+ * cpdef _MutableFst compose(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_15compose(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_cf = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3277
+ * _Fst ifst2,
+ * cf=b"auto",
+ * bool connect=True): # <<<<<<<<<<<<<<
+ * """
+ * compose(ifst1, ifst2, cf="auto", connect=True)
+ */
+ bool __pyx_v_connect = ((bool)1);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ std::unique_ptr<fst::script::ComposeOptions> __pyx_v_opts;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ enum fst::ComposeFilter __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("compose", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_cf = __pyx_optional_args->cf;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_connect = __pyx_optional_args->connect;
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3301
+ * See also: `arcsort`.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type()) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3301, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst1->__pyx_vtab)->arc_type(__pyx_v_ifst1, 0));
+
+ /* "pywrapfst.pyx":3303
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type())
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf)))) # <<<<<<<<<<<<<<
+ * fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst)
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_cf, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3303, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3303, __pyx_L1_error)
+ __pyx_v_opts.reset(new fst::script::ComposeOptions(__pyx_v_connect, __pyx_t_2));
+
+ /* "pywrapfst.pyx":3304
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ * fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3304, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3304, __pyx_L1_error)
+ }
+ fst::script::Compose((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_tfst, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3305
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ * fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3305, __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":3274
+ *
+ *
+ * cpdef _MutableFst compose(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst.compose", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_15compose(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_14compose[] = "\n compose(ifst1, ifst2, cf=\"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 cf: A string matching a known composition filter; one of: \"alt_sequence\",\n \"auto\", \"match\", \"null\", \"sequence\", \"trivial\".\n connect: Should output be trimmed?\n\n Returns:\n A composed FST.\n\n See also: `arcsort`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_15compose(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_cf = 0;
+ bool __pyx_v_connect;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("compose (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_cf,&__pyx_n_s_connect,0};
+ PyObject* values[4] = {0,0,0,0};
+ values[2] = ((PyObject *)__pyx_n_b_auto);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("compose", 0, 2, 4, 1); __PYX_ERR(0, 3274, __pyx_L3_error)
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cf);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "compose") < 0)) __PYX_ERR(0, 3274, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ 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_cf = 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, 3277, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3277
+ * _Fst ifst2,
+ * cf=b"auto",
+ * bool connect=True): # <<<<<<<<<<<<<<
+ * """
+ * compose(ifst1, ifst2, cf="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, 3274, __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, 3274, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3275, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_14compose(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_cf, __pyx_v_connect);
+
+ /* "pywrapfst.pyx":3274
+ *
+ *
+ * cpdef _MutableFst compose(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_14compose(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_cf, bool __pyx_v_connect) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_compose __pyx_t_2;
+ __Pyx_RefNannySetupContext("compose", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 2;
+ __pyx_t_2.cf = __pyx_v_cf;
+ __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, 3274, __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":3308
+ *
+ *
+ * cpdef _Fst convert(_Fst ifst, fst_type=b""): # <<<<<<<<<<<<<<
+ * """
+ * convert(ifst, fst_type="")
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_17convert(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_b_);
+ __pyx_t_9pywrapfst_FstClass_ptr __pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ __Pyx_RefNannySetupContext("convert", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_fst_type = __pyx_optional_args->fst_type;
+ }
+ }
+
+ /* "pywrapfst.pyx":3325
+ * FstOpError: Conversion failed.
+ * """
+ * cdef FstClass_ptr tfst = new fst.FstClass(deref(ifst._fst)) # <<<<<<<<<<<<<<
+ * tfst = fst.Convert(deref(ifst._fst), tostring(fst_type))
+ * # Script-land Convert returns the null pointer to signal failure.
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3325, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::FstClass((*__pyx_v_ifst->_fst));
+
+ /* "pywrapfst.pyx":3326
+ * """
+ * cdef FstClass_ptr tfst = new fst.FstClass(deref(ifst._fst))
+ * tfst = fst.Convert(deref(ifst._fst), tostring(fst_type)) # <<<<<<<<<<<<<<
+ * # Script-land Convert returns the null pointer to signal failure.
+ * if tfst == NULL:
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3326, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_fst_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3326, __pyx_L1_error)
+ __pyx_v_tfst = fst::script::Convert((*__pyx_v_ifst->_fst), __pyx_t_1);
+
+ /* "pywrapfst.pyx":3328
+ * tfst = fst.Convert(deref(ifst._fst), tostring(fst_type))
+ * # Script-land Convert returns the null pointer to signal failure.
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Conversion to {!r} failed".format(fst_type))
+ * return _init_XFst(tfst)
+ */
+ __pyx_t_2 = ((__pyx_v_tfst == NULL) != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":3329
+ * # Script-land Convert returns the null pointer to signal failure.
+ * if tfst == NULL:
+ * raise FstOpError("Conversion to {!r} failed".format(fst_type)) # <<<<<<<<<<<<<<
+ * return _init_XFst(tfst)
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Conversion_to_r_failed_2, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_6, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_fst_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_fst_type};
+ __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_fst_type};
+ __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_5);
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_INCREF(__pyx_v_fst_type);
+ __Pyx_GIVEREF(__pyx_v_fst_type);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_fst_type);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_6 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_6);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_6) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 3329, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3328
+ * tfst = fst.Convert(deref(ifst._fst), tostring(fst_type))
+ * # Script-land Convert returns the null pointer to signal failure.
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Conversion to {!r} failed".format(fst_type))
+ * return _init_XFst(tfst)
+ */
+ }
+
+ /* "pywrapfst.pyx":3330
+ * if tfst == NULL:
+ * raise FstOpError("Conversion to {!r} failed".format(fst_type))
+ * return _init_XFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3330, __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":3308
+ *
+ *
+ * cpdef _Fst convert(_Fst ifst, fst_type=b""): # <<<<<<<<<<<<<<
+ * """
+ * 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_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __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_17convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_16convert[] = "\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 None if\n no conversion is desired.\n\n Returns:\n An equivalent Fst converted to the desired FST type.\n\n Raises:\n FstOpError: Conversion failed.\n ";
+static PyObject *__pyx_pw_9pywrapfst_17convert(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ PyObject *__pyx_v_fst_type = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("convert (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_fst_type,0};
+ PyObject* values[2] = {0,0};
+ values[1] = ((PyObject *)__pyx_kp_b_);
+ 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);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fst_type);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "convert") < 0)) __PYX_ERR(0, 3308, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3308, __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, 3308, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_16convert(__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_16convert(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_fst_type) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_convert __pyx_t_2;
+ __Pyx_RefNannySetupContext("convert", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.fst_type = __pyx_v_fst_type;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_convert(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3308, __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":3333
+ *
+ *
+ * cpdef _MutableFst determinize(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * dt=b"functional",
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_19determinize(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__36;
+ PyObject *__pyx_v_dt = ((PyObject *)__pyx_n_b_functional);
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__37;
+ __pyx_t_10basictypes_int64 __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0);
+
+ /* "pywrapfst.pyx":3338
+ * int64 nstate=fst.kNoStateId,
+ * int64 subsequential_label=0,
+ * weight=None, # <<<<<<<<<<<<<<
+ * bool increment_subsequential_label=False):
+ * """
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+
+ /* "pywrapfst.pyx":3339
+ * int64 subsequential_label=0,
+ * weight=None,
+ * bool increment_subsequential_label=False): # <<<<<<<<<<<<<<
+ * """
+ * determinize(ifst, delta=0.0009765625, dt="functional", nstate=-1,
+ */
+ bool __pyx_v_increment_subsequential_label = ((bool)0);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ fst::script::WeightClass __pyx_v_wc;
+ enum fst::DeterminizeType __pyx_v_determinize_type;
+ std::unique_ptr<fst::script::DeterminizeOptions> __pyx_v_opts;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ fst::script::WeightClass __pyx_t_1;
+ std::string __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ __Pyx_RefNannySetupContext("determinize", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_dt = __pyx_optional_args->dt;
+ 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":3374
+ * See also: `disambiguate`, `rmepsilon`.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(),
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3374, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3376
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), # <<<<<<<<<<<<<<
+ * weight)
+ * cdef fst.DeterminizeType determinize_type
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 3376, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3377
+ * # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(),
+ * weight) # <<<<<<<<<<<<<<
+ * cdef fst.DeterminizeType determinize_type
+ * if not fst.GetDeterminizeType(tostring(dt), addr(determinize_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, 3376, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_1;
+
+ /* "pywrapfst.pyx":3379
+ * weight)
+ * cdef fst.DeterminizeType determinize_type
+ * if not fst.GetDeterminizeType(tostring(dt), addr(determinize_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ * cdef unique_ptr[fst.DeterminizeOptions] opts
+ */
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_dt, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3379, __pyx_L1_error)
+ __pyx_t_3 = ((!(fst::script::GetDeterminizeType(__pyx_t_2, (&__pyx_v_determinize_type)) != 0)) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":3380
+ * cdef fst.DeterminizeType determinize_type
+ * if not fst.GetDeterminizeType(tostring(dt), addr(determinize_type)):
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt)) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.DeterminizeOptions] opts
+ * opts.reset(new fst.DeterminizeOptions(delta, wc, nstate, subsequential_label,
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Unknown_determinization_type_r, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+ if (likely(__pyx_t_8)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
+ }
+ }
+ if (!__pyx_t_8) {
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_dt); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_dt};
+ __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_dt};
+ __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+ __Pyx_INCREF(__pyx_v_dt);
+ __Pyx_GIVEREF(__pyx_v_dt);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_dt);
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 3380, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3379
+ * weight)
+ * cdef fst.DeterminizeType determinize_type
+ * if not fst.GetDeterminizeType(tostring(dt), addr(determinize_type)): # <<<<<<<<<<<<<<
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ * cdef unique_ptr[fst.DeterminizeOptions] opts
+ */
+ }
+
+ /* "pywrapfst.pyx":3382
+ * raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ * cdef unique_ptr[fst.DeterminizeOptions] opts
+ * opts.reset(new fst.DeterminizeOptions(delta, wc, nstate, subsequential_label, # <<<<<<<<<<<<<<
+ * determinize_type,
+ * increment_subsequential_label))
+ */
+ __pyx_v_opts.reset(new fst::script::DeterminizeOptions(__pyx_v_delta, __pyx_v_wc, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v_determinize_type, __pyx_v_increment_subsequential_label));
+
+ /* "pywrapfst.pyx":3385
+ * determinize_type,
+ * increment_subsequential_label))
+ * fst.Determinize(deref(ifst._fst), tfst, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3385, __pyx_L1_error)
+ }
+ fst::script::Determinize((*__pyx_v_ifst->_fst), __pyx_v_tfst, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3386
+ * increment_subsequential_label))
+ * fst.Determinize(deref(ifst._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3386, __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":3333
+ *
+ *
+ * cpdef _MutableFst determinize(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * dt=b"functional",
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_AddTraceback("pywrapfst.determinize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_19determinize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_18determinize[] = "\n determinize(ifst, delta=0.0009765625, dt=\"functional\", nstate=-1,\n 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 dt: Type of determinization; one of: \"functional\" (input transducer is\n functional), \"nonfunctional\" (input transducer is not functional) and\n disambiguate\" (input transducer is not functional but only keep the min\n of ambiguous outputs).\n nstate: State number threshold.\n subsequential_label: Input label of arc corresponding to residual final\n output when producing a subsequential transducer.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n increment_subsequential_label: Increment subsequential when creating\n several arcs for the residual final output at a given state.\n\n Returns:\n An equivalent deterministic FST.\n\n Raises:\n FstArgError: Unknown determinization type.\n\n See also: `disambiguate`, `rmepsilon`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_19determinize(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_dt = 0;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ __pyx_t_10basictypes_int64 __pyx_v_subsequential_label;
+ PyObject *__pyx_v_weight = 0;
+ bool __pyx_v_increment_subsequential_label;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("determinize (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_dt,&__pyx_n_s_nstate,&__pyx_n_s_subsequential_label,&__pyx_n_s_weight,&__pyx_n_s_increment_subsequential_label,0};
+ PyObject* values[7] = {0,0,0,0,0,0,0};
+ values[2] = ((PyObject *)__pyx_n_b_functional);
+
+ /* "pywrapfst.pyx":3338
+ * 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);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dt);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_subsequential_label);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_increment_subsequential_label);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "determinize") < 0)) __PYX_ERR(0, 3333, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3334, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__36;
+ }
+ __pyx_v_dt = values[2];
+ if (values[3]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3336, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__37;
+ }
+ if (values[4]) {
+ __pyx_v_subsequential_label = __Pyx_PyInt_As_int64_t(values[4]); if (unlikely((__pyx_v_subsequential_label == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3337, __pyx_L3_error)
+ } else {
+ __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0);
+ }
+ __pyx_v_weight = values[5];
+ if (values[6]) {
+ __pyx_v_increment_subsequential_label = __Pyx_PyObject_IsTrue(values[6]); if (unlikely((__pyx_v_increment_subsequential_label == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3339, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3339
+ * int64 subsequential_label=0,
+ * weight=None,
+ * bool increment_subsequential_label=False): # <<<<<<<<<<<<<<
+ * """
+ * determinize(ifst, delta=0.0009765625, dt="functional", nstate=-1,
+ */
+ __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, 3333, __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, 3333, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_18determinize(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_dt, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v_weight, __pyx_v_increment_subsequential_label);
+
+ /* "pywrapfst.pyx":3333
+ *
+ *
+ * cpdef _MutableFst determinize(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * dt=b"functional",
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_18determinize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, PyObject *__pyx_v_dt, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight, bool __pyx_v_increment_subsequential_label) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_determinize __pyx_t_2;
+ __Pyx_RefNannySetupContext("determinize", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 6;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.dt = __pyx_v_dt;
+ __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, 3333, __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":3389
+ *
+ *
+ * cpdef _MutableFst difference(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_21difference(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_cf = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3392
+ * _Fst ifst2,
+ * cf=b"auto",
+ * bool connect=True): # <<<<<<<<<<<<<<
+ * """
+ * difference(ifst1, ifst2, cf="auto", connect=True)
+ */
+ bool __pyx_v_connect = ((bool)1);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ std::unique_ptr<fst::script::ComposeOptions> __pyx_v_opts;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ enum fst::ComposeFilter __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("difference", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_cf = __pyx_optional_args->cf;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_connect = __pyx_optional_args->connect;
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3415
+ * An FST representing the difference of the two input FSTs.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type()) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3415, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst1->__pyx_vtab)->arc_type(__pyx_v_ifst1, 0));
+
+ /* "pywrapfst.pyx":3417
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type())
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf)))) # <<<<<<<<<<<<<<
+ * fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst)
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_cf, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3417, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3417, __pyx_L1_error)
+ __pyx_v_opts.reset(new fst::script::ComposeOptions(__pyx_v_connect, __pyx_t_2));
+
+ /* "pywrapfst.pyx":3418
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ * fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3418, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3418, __pyx_L1_error)
+ }
+ fst::script::Difference((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_tfst, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3419
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ * fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3419, __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":3389
+ *
+ *
+ * cpdef _MutableFst difference(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst.difference", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_21difference(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_20difference[] = "\n difference(ifst1, ifst2, cf=\"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 cf: A string matching a known composition filter; one of: \"alt_sequence\",\n \"auto\", \"match\", \"null\", \"sequence\", \"trivial\".\n connect: Should the output FST be trimmed?\n\n Returns:\n An FST representing the difference of the two input FSTs.\n ";
+static PyObject *__pyx_pw_9pywrapfst_21difference(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_cf = 0;
+ bool __pyx_v_connect;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("difference (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_cf,&__pyx_n_s_connect,0};
+ PyObject* values[4] = {0,0,0,0};
+ values[2] = ((PyObject *)__pyx_n_b_auto);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("difference", 0, 2, 4, 1); __PYX_ERR(0, 3389, __pyx_L3_error)
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cf);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "difference") < 0)) __PYX_ERR(0, 3389, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ 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_cf = 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, 3392, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3392
+ * _Fst ifst2,
+ * cf=b"auto",
+ * bool connect=True): # <<<<<<<<<<<<<<
+ * """
+ * difference(ifst1, ifst2, cf="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, 3389, __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, 3389, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3390, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_20difference(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_cf, __pyx_v_connect);
+
+ /* "pywrapfst.pyx":3389
+ *
+ *
+ * cpdef _MutableFst difference(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_20difference(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_cf, bool __pyx_v_connect) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_difference __pyx_t_2;
+ __Pyx_RefNannySetupContext("difference", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 2;
+ __pyx_t_2.cf = __pyx_v_cf;
+ __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, 3389, __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":3422
+ *
+ *
+ * cpdef _MutableFst disambiguate(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_23disambiguate(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__38;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__39;
+ __pyx_t_10basictypes_int64 __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0);
+
+ /* "pywrapfst.pyx":3426
+ * int64 nstate=fst.kNoStateId,
+ * int64 subsequential_label=0,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * disambiguate(ifst, delta=0.0009765625, nstate=-1, subsequential_label=0,
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ fst::script::WeightClass __pyx_v_wc;
+ std::unique_ptr<fst::script::DisambiguateOptions> __pyx_v_opts;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ fst::script::WeightClass __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("disambiguate", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_nstate = __pyx_optional_args->nstate;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_subsequential_label = __pyx_optional_args->subsequential_label;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3452
+ * See also: `determinize`, `rmepsilon`.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(),
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3452, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3454
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), # <<<<<<<<<<<<<<
+ * weight)
+ * cdef unique_ptr[fst.DisambiguateOptions] opts
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 3454, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3455
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(),
+ * weight) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.DisambiguateOptions] opts
+ * opts.reset(new fst.DisambiguateOptions(delta, wc, nstate,
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3454, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_1;
+
+ /* "pywrapfst.pyx":3457
+ * weight)
+ * cdef unique_ptr[fst.DisambiguateOptions] opts
+ * opts.reset(new fst.DisambiguateOptions(delta, wc, nstate, # <<<<<<<<<<<<<<
+ * subsequential_label))
+ * fst.Disambiguate(deref(ifst._fst), tfst, deref(opts))
+ */
+ __pyx_v_opts.reset(new fst::script::DisambiguateOptions(__pyx_v_delta, __pyx_v_wc, __pyx_v_nstate, __pyx_v_subsequential_label));
+
+ /* "pywrapfst.pyx":3459
+ * opts.reset(new fst.DisambiguateOptions(delta, wc, nstate,
+ * subsequential_label))
+ * fst.Disambiguate(deref(ifst._fst), tfst, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3459, __pyx_L1_error)
+ }
+ fst::script::Disambiguate((*__pyx_v_ifst->_fst), __pyx_v_tfst, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3460
+ * subsequential_label))
+ * fst.Disambiguate(deref(ifst._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3460, __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":3422
+ *
+ *
+ * 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_23disambiguate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_22disambiguate[] = "\n disambiguate(ifst, delta=0.0009765625, nstate=-1, subsequential_label=0,\n weight=None):\n\n Constructively disambiguates a weighted transducer.\n\n This operation disambiguates a weighted transducer. The result will be an\n equivalent FST that has the property that no two successful paths have the\n same input labeling. For this algorithm, epsilon transitions are treated as\n regular symbols (cf. `rmepsilon`).\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n subsequential_label: Input label of arc corresponding to residual final\n output when producing a subsequential transducer.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n An equivalent disambiguated FST.\n\n See also: `determinize`, `rmepsilon`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_23disambiguate(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ float __pyx_v_delta;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ __pyx_t_10basictypes_int64 __pyx_v_subsequential_label;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("disambiguate (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_subsequential_label,&__pyx_n_s_weight,0};
+ PyObject* values[5] = {0,0,0,0,0};
+
+ /* "pywrapfst.pyx":3426
+ * int64 nstate=fst.kNoStateId,
+ * int64 subsequential_label=0,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * disambiguate(ifst, delta=0.0009765625, nstate=-1, subsequential_label=0,
+ */
+ 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);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_subsequential_label);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "disambiguate") < 0)) __PYX_ERR(0, 3422, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3423, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__38;
+ }
+ if (values[2]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3424, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__39;
+ }
+ if (values[3]) {
+ __pyx_v_subsequential_label = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_subsequential_label == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3425, __pyx_L3_error)
+ } else {
+ __pyx_v_subsequential_label = ((__pyx_t_10basictypes_int64)0);
+ }
+ __pyx_v_weight = values[4];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("disambiguate", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3422, __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, 3422, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_22disambiguate(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_subsequential_label, __pyx_v_weight);
+
+ /* "pywrapfst.pyx":3422
+ *
+ *
+ * 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_22disambiguate(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, __pyx_t_10basictypes_int64 __pyx_v_subsequential_label, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_disambiguate __pyx_t_2;
+ __Pyx_RefNannySetupContext("disambiguate", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 4;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.nstate = __pyx_v_nstate;
+ __pyx_t_2.subsequential_label = __pyx_v_subsequential_label;
+ __pyx_t_2.weight = __pyx_v_weight;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_disambiguate(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3422, __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":3463
+ *
+ *
+ * cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=False): # <<<<<<<<<<<<<<
+ * """
+ * epsnormalize(ifst, eps_norm_output=False)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_25epsnormalize(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);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ enum fst::EpsNormalizeType __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("epsnormalize", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_eps_norm_output = __pyx_optional_args->eps_norm_output;
+ }
+ }
+
+ /* "pywrapfst.pyx":3485
+ * See also: `rmepsilon`.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * fst.EpsNormalize(deref(ifst._fst), tfst, fst.EPS_NORM_OUTPUT if
+ * eps_norm_output else
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3485, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3486
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.EpsNormalize(deref(ifst._fst), tfst, 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 '%s'", "_fst");
+ __PYX_ERR(0, 3486, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3487
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.EpsNormalize(deref(ifst._fst), tfst, fst.EPS_NORM_OUTPUT if
+ * eps_norm_output else # <<<<<<<<<<<<<<
+ * fst.EPS_NORM_INPUT)
+ * return _init_MutableFst(tfst)
+ */
+ if ((__pyx_v_eps_norm_output != 0)) {
+
+ /* "pywrapfst.pyx":3486
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.EpsNormalize(deref(ifst._fst), tfst, fst.EPS_NORM_OUTPUT if # <<<<<<<<<<<<<<
+ * eps_norm_output else
+ * fst.EPS_NORM_INPUT)
+ */
+ __pyx_t_1 = fst::EPS_NORM_OUTPUT;
+ } else {
+
+ /* "pywrapfst.pyx":3488
+ * fst.EpsNormalize(deref(ifst._fst), tfst, fst.EPS_NORM_OUTPUT if
+ * eps_norm_output else
+ * fst.EPS_NORM_INPUT) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ __pyx_t_1 = fst::EPS_NORM_INPUT;
+ }
+
+ /* "pywrapfst.pyx":3486
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.EpsNormalize(deref(ifst._fst), tfst, fst.EPS_NORM_OUTPUT if # <<<<<<<<<<<<<<
+ * eps_norm_output else
+ * fst.EPS_NORM_INPUT)
+ */
+ fst::script::EpsNormalize((*__pyx_v_ifst->_fst), __pyx_v_tfst, __pyx_t_1);
+
+ /* "pywrapfst.pyx":3489
+ * eps_norm_output else
+ * fst.EPS_NORM_INPUT)
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3489, __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":3463
+ *
+ *
+ * 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_25epsnormalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_24epsnormalize[] = "\n epsnormalize(ifst, eps_norm_output=False)\n\n Constructively epsilon-normalizes an FST.\n\n This operation creates an equivalent FST that is epsilon-normalized. An\n acceptor is epsilon-normalized if it it is epsilon-removed (cf. `rmepsilon`).\n A transducer is input epsilon-normalized if, in addition, along any path, all\n arcs with epsilon input labels follow all arcs with non-epsilon input labels.\n Output epsilon-normalized is defined similarly. The input FST must be\n functional.\n\n Args:\n ifst: The input FST.\n eps_norm_output: Should the FST be output epsilon-normalized?\n\n Returns:\n An equivalent epsilon-normalized FST.\n\n See also: `rmepsilon`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_25epsnormalize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ bool __pyx_v_eps_norm_output;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("epsnormalize (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_eps_norm_output,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_eps_norm_output);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "epsnormalize") < 0)) __PYX_ERR(0, 3463, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3463, __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, 3463, __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, 3463, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_24epsnormalize(__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_24epsnormalize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_eps_norm_output) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_epsnormalize __pyx_t_2;
+ __Pyx_RefNannySetupContext("epsnormalize", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.eps_norm_output = __pyx_v_eps_norm_output;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_epsnormalize(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3463, __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":3492
+ *
+ *
+ * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<<
+ * """
+ * equal(ifst1, ifst2, delta=0.0009765625)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_27equal(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__40;
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("equal", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ }
+ }
+
+ /* "pywrapfst.pyx":3512
+ * See also: `equivalent`, `isomorphic`, `randequivalent`.
+ * """
+ * return fst.Equal(deref(ifst1._fst), deref(ifst2._fst), delta) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3512, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3512, __pyx_L1_error)
+ }
+ __pyx_r = fst::script::Equal((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3492
+ *
+ *
+ * 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_27equal(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_26equal[] = "\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 two transducers satisfy the above condition, else False.\n\n See also: `equivalent`, `isomorphic`, `randequivalent`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_27equal(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0;
+ float __pyx_v_delta;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("equal (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_delta,0};
+ PyObject* values[3] = {0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("equal", 0, 2, 3, 1); __PYX_ERR(0, 3492, __pyx_L3_error)
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "equal") < 0)) __PYX_ERR(0, 3492, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ 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, 3492, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__40;
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("equal", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3492, __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, 3492, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3492, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_26equal(__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_26equal(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ bool __pyx_t_1;
+ struct __pyx_opt_args_9pywrapfst_equal __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("equal", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_1 = __pyx_f_9pywrapfst_equal(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3492, __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":3515
+ *
+ *
+ * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *: # <<<<<<<<<<<<<<
+ * """
+ * equivalent(ifst1, ifst2, delta=0.0009765625)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_29equivalent(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__41;
+ bool __pyx_v_error;
+ bool __pyx_v_result;
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("equivalent", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ }
+ }
+
+ /* "pywrapfst.pyx":3539
+ * """
+ * cdef bool error
+ * cdef bool result = fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta, # <<<<<<<<<<<<<<
+ * addr(error))
+ * if error:
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3539, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3539, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3540
+ * cdef bool error
+ * cdef bool result = fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta,
+ * addr(error)) # <<<<<<<<<<<<<<
+ * if error:
+ * raise FstOpError("Equivalence test encountered error")
+ */
+ __pyx_v_result = fst::script::Equivalent((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta, (&__pyx_v_error));
+
+ /* "pywrapfst.pyx":3541
+ * cdef bool result = fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta,
+ * addr(error))
+ * if error: # <<<<<<<<<<<<<<
+ * raise FstOpError("Equivalence test encountered error")
+ * return result
+ */
+ __pyx_t_1 = (__pyx_v_error != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":3542
+ * addr(error))
+ * if error:
+ * raise FstOpError("Equivalence test encountered error") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3542, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3542, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 3542, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3541
+ * cdef bool result = fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta,
+ * addr(error))
+ * if error: # <<<<<<<<<<<<<<
+ * raise FstOpError("Equivalence test encountered error")
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":3543
+ * if error:
+ * raise FstOpError("Equivalence test encountered error")
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3515
+ *
+ *
+ * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *: # <<<<<<<<<<<<<<
+ * """
+ * equivalent(ifst1, ifst2, delta=0.0009765625)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst.equivalent", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_29equivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_28equivalent[] = "\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 two transducers satisfy the above condition, else False.\n\n Raises:\n FstOpError: Equivalence test encountered error.\n\n See also: `equal`, `isomorphic`, `randequivalent`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_29equivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0;
+ float __pyx_v_delta;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("equivalent (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_delta,0};
+ PyObject* values[3] = {0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("equivalent", 0, 2, 3, 1); __PYX_ERR(0, 3515, __pyx_L3_error)
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "equivalent") < 0)) __PYX_ERR(0, 3515, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ 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, 3515, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__41;
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("equivalent", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3515, __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, 3515, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3515, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_28equivalent(__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_28equivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ bool __pyx_t_1;
+ struct __pyx_opt_args_9pywrapfst_equivalent __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("equivalent", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_1 = __pyx_f_9pywrapfst_equivalent(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3515, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3515, __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":3546
+ *
+ *
+ * cpdef _MutableFst intersect(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_31intersect(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_cf = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3549
+ * _Fst ifst2,
+ * cf=b"auto",
+ * bool connect=True): # <<<<<<<<<<<<<<
+ * """
+ * intersect(ifst1, ifst2, cf="auto", connect=True)
+ */
+ bool __pyx_v_connect = ((bool)1);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ std::unique_ptr<fst::script::ComposeOptions> __pyx_v_opts;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ enum fst::ComposeFilter __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("intersect", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_cf = __pyx_optional_args->cf;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_connect = __pyx_optional_args->connect;
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3570
+ * An equivalent epsilon-normalized FST.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type()) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3570, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst1->__pyx_vtab)->arc_type(__pyx_v_ifst1, 0));
+
+ /* "pywrapfst.pyx":3572
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type())
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf)))) # <<<<<<<<<<<<<<
+ * fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst)
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_cf, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3572, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst__get_compose_filter(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3572, __pyx_L1_error)
+ __pyx_v_opts.reset(new fst::script::ComposeOptions(__pyx_v_connect, __pyx_t_2));
+
+ /* "pywrapfst.pyx":3573
+ * cdef unique_ptr[fst.ComposeOptions] opts
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ * fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3573, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3573, __pyx_L1_error)
+ }
+ fst::script::Intersect((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_tfst, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3574
+ * opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ * fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_3 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3574, __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":3546
+ *
+ *
+ * cpdef _MutableFst intersect(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst.intersect", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_31intersect(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_30intersect[] = "\n intersect(ifst1, ifst2, cf=\"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 cf: A string matching a known composition filter; one of: \"alt_sequence\",\n \"auto\", \"match\", \"null\", \"sequence\", \"trivial\".\n connect: Should output be trimmed?\n\n Returns:\n An equivalent epsilon-normalized FST.\n ";
+static PyObject *__pyx_pw_9pywrapfst_31intersect(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_cf = 0;
+ bool __pyx_v_connect;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("intersect (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_cf,&__pyx_n_s_connect,0};
+ PyObject* values[4] = {0,0,0,0};
+ values[2] = ((PyObject *)__pyx_n_b_auto);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("intersect", 0, 2, 4, 1); __PYX_ERR(0, 3546, __pyx_L3_error)
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cf);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "intersect") < 0)) __PYX_ERR(0, 3546, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ 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_cf = 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, 3549, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3549
+ * _Fst ifst2,
+ * cf=b"auto",
+ * bool connect=True): # <<<<<<<<<<<<<<
+ * """
+ * intersect(ifst1, ifst2, cf="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, 3546, __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, 3546, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3547, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_30intersect(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_cf, __pyx_v_connect);
+
+ /* "pywrapfst.pyx":3546
+ *
+ *
+ * cpdef _MutableFst intersect(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * cf=b"auto",
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_30intersect(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, PyObject *__pyx_v_cf, bool __pyx_v_connect) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_intersect __pyx_t_2;
+ __Pyx_RefNannySetupContext("intersect", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 2;
+ __pyx_t_2.cf = __pyx_v_cf;
+ __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, 3546, __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":3577
+ *
+ *
+ * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<<
+ * """
+ * isomorphic(ifst1, ifst2, delta=0.0009765625)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_33isomorphic(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__43;
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("isomorphic", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ }
+ }
+
+ /* "pywrapfst.pyx":3600
+ * See also: `equal`, `equivalent`, `randequivalent`.
+ * """
+ * return fst.Isomorphic(deref(ifst1._fst), deref(ifst2._fst), delta) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3600, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3600, __pyx_L1_error)
+ }
+ __pyx_r = fst::script::Isomorphic((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_delta);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3577
+ *
+ *
+ * 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_33isomorphic(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_32isomorphic[] = "\n isomorphic(ifst1, ifst2, delta=0.0009765625)\n\n Are the two acceptors isomorphic?\n\n This operation determines if two transducers with a certain required\n determinism have the same states, irrespective of numbering, and the same\n transitions with the same labels and weights, irrespective of ordering. In\n other words, FSTs A, B are isomorphic if and only if the states of A can be\n renumbered and the transitions leaving each state reordered so the two are\n equal (according to the definition given in `equal`).\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n delta: Comparison/quantization delta.\n\n Returns:\n True if the two transducers satisfy the above condition, else False.\n\n See also: `equal`, `equivalent`, `randequivalent`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_33isomorphic(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0;
+ float __pyx_v_delta;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("isomorphic (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_delta,0};
+ PyObject* values[3] = {0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("isomorphic", 0, 2, 3, 1); __PYX_ERR(0, 3577, __pyx_L3_error)
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "isomorphic") < 0)) __PYX_ERR(0, 3577, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ 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, 3577, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__43;
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("isomorphic", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3577, __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, 3577, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3577, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_32isomorphic(__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_32isomorphic(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, float __pyx_v_delta) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ bool __pyx_t_1;
+ struct __pyx_opt_args_9pywrapfst_isomorphic __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("isomorphic", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_1 = __pyx_f_9pywrapfst_isomorphic(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2);
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3577, __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":3603
+ *
+ *
+ * cpdef _MutableFst prune(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_35prune(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__44;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__45;
+
+ /* "pywrapfst.pyx":3606
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * prune(ifst, delta=0.0009765625, nstate=-1, weight=None)
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ fst::script::WeightClass __pyx_v_wc;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ fst::script::WeightClass __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ __Pyx_RefNannySetupContext("prune", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_nstate = __pyx_optional_args->nstate;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3629
+ * See also: The destructive variant.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ * fst.Prune(deref(ifst._fst), tfst, wc, nstate, delta)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3629, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3630
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) # <<<<<<<<<<<<<<
+ * fst.Prune(deref(ifst._fst), tfst, wc, nstate, delta)
+ * return _init_MutableFst(tfst)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 3630, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3630, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_1;
+
+ /* "pywrapfst.pyx":3631
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ * fst.Prune(deref(ifst._fst), tfst, wc, nstate, delta) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3631, __pyx_L1_error)
+ }
+ fst::script::Prune((*__pyx_v_ifst->_fst), __pyx_v_tfst, __pyx_v_wc, __pyx_v_nstate, __pyx_v_delta);
+
+ /* "pywrapfst.pyx":3632
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ * fst.Prune(deref(ifst._fst), tfst, wc, nstate, delta)
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3632, __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":3603
+ *
+ *
+ * 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_35prune(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_34prune[] = "\n prune(ifst, delta=0.0009765625, nstate=-1, weight=None)\n\n Constructively removes paths with weights below a certain threshold.\n\n This operation deletes states and arcs in the input FST that do not belong\n to a successful path whose weight is no more (w.r.t the natural semiring\n order) than the threshold t \\otimes-times the weight of the shortest path in\n the input FST. Weights must be commutative and have the path property.\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n weight: A Weight or weight string indicating the desired weight threshold\n below which paths are pruned; if omitted, no paths are pruned.\n\n Returns:\n A pruned FST.\n\n See also: The destructive variant.\n ";
+static PyObject *__pyx_pw_9pywrapfst_35prune(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ float __pyx_v_delta;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("prune (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_weight,0};
+ PyObject* values[4] = {0,0,0,0};
+
+ /* "pywrapfst.pyx":3606
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * prune(ifst, delta=0.0009765625, nstate=-1, 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);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "prune") < 0)) __PYX_ERR(0, 3603, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3604, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__44;
+ }
+ if (values[2]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3605, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__45;
+ }
+ __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, 3603, __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, 3603, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_34prune(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_weight);
+
+ /* "pywrapfst.pyx":3603
+ *
+ *
+ * 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_34prune(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_prune __pyx_t_2;
+ __Pyx_RefNannySetupContext("prune", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 3;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.nstate = __pyx_v_nstate;
+ __pyx_t_2.weight = __pyx_v_weight;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_prune(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3603, __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":3635
+ *
+ *
+ * cpdef _MutableFst push(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * bool push_weights=False,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_37push(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__46;
+
+ /* "pywrapfst.pyx":3637
+ * 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":3638
+ * 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":3639
+ * 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":3640
+ * 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":3641
+ * 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);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ __pyx_t_10basictypes_uint32 __pyx_v_flags;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("push", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_push_weights = __pyx_optional_args->push_weights;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_push_labels = __pyx_optional_args->push_labels;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_remove_common_affix = __pyx_optional_args->remove_common_affix;
+ if (__pyx_optional_args->__pyx_n > 4) {
+ __pyx_v_remove_total_weight = __pyx_optional_args->remove_total_weight;
+ if (__pyx_optional_args->__pyx_n > 5) {
+ __pyx_v_to_final = __pyx_optional_args->to_final;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3680
+ * """
+ * # This is copied, almost verbatim, from nlp/fst/bin/fstpush.cc.
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels,
+ * remove_common_affix, remove_total_weight)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3680, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3681
+ * # This is copied, almost verbatim, from nlp/fst/bin/fstpush.cc.
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels, # <<<<<<<<<<<<<<
+ * remove_common_affix, remove_total_weight)
+ * fst.Push(deref(ifst._fst), tfst, flags, fst.GetReweightType(to_final), delta)
+ */
+ __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":3683
+ * cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels,
+ * remove_common_affix, remove_total_weight)
+ * fst.Push(deref(ifst._fst), tfst, flags, fst.GetReweightType(to_final), delta) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3683, __pyx_L1_error)
+ }
+ fst::script::Push((*__pyx_v_ifst->_fst), __pyx_v_tfst, __pyx_v_flags, fst::script::GetReweightType(__pyx_v_to_final), __pyx_v_delta);
+
+ /* "pywrapfst.pyx":3684
+ * remove_common_affix, remove_total_weight)
+ * fst.Push(deref(ifst._fst), tfst, flags, fst.GetReweightType(to_final), delta)
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3684, __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":3635
+ *
+ *
+ * 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_37push(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_36push[] = "\n push(ifst, delta=0.0009765625, push_weights=False, push_labels=False,\n remove_common_affix=False, remove_total_weight=False, to_final=False)\n\n Constructively pushes weights/labels towards initial or final states.\n\n This operation produces an equivalent transducer by pushing the weights\n and/or the labels towards the initial state or toward the final states.\n\n When pushing weights towards the initial state, the sum of the weight of the\n outgoing transitions and final weight at any non-initial state is equal to 1\n in the resulting machine. When pushing weights towards the final states, the\n sum of the weight of the incoming transitions at any state is equal to 1.\n Weights need to be left distributive when pushing towards the initial state\n and right distributive when pushing towards the final states.\n\n Pushing labels towards the initial state consists in minimizing at every\n state the length of the longest common prefix of the output labels of the\n outgoing paths. Pushing labels towards the final states consists in\n minimizing at every state the length of the longest common suffix of the\n output labels of the incoming paths.\n\n Args:\n ifst: The input FST.\n delta: Comparison/quantization delta.\n push_weights: Should weights be pushed?\n push_labels: Should labels be pushed?\n remove_common_affix: If pushing labels, should common prefix/suffix be\n removed?\n remove_total_weight: If pushing weights, should total weight be removed?\n to_final: Push towards final states?\n\n Returns:\n An equivalent pushed FST.\n\n See also: The destructive variant.\n ";
+static PyObject *__pyx_pw_9pywrapfst_37push(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ float __pyx_v_delta;
+ bool __pyx_v_push_weights;
+ bool __pyx_v_push_labels;
+ bool __pyx_v_remove_common_affix;
+ bool __pyx_v_remove_total_weight;
+ bool __pyx_v_to_final;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("push (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_push_weights,&__pyx_n_s_push_labels,&__pyx_n_s_remove_common_affix,&__pyx_n_s_remove_total_weight,&__pyx_n_s_to_final,0};
+ PyObject* values[7] = {0,0,0,0,0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_push_weights);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_push_labels);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_common_affix);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_total_weight);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_to_final);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "push") < 0)) __PYX_ERR(0, 3635, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3636, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__46;
+ }
+ 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, 3637, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3637
+ * 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, 3638, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3638
+ * 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, 3639, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3639
+ * 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, 3640, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3640
+ * 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, 3641, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3641
+ * 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, 3635, __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, 3635, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_36push(__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":3635
+ *
+ *
+ * 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_36push(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, bool __pyx_v_push_weights, bool __pyx_v_push_labels, bool __pyx_v_remove_common_affix, bool __pyx_v_remove_total_weight, bool __pyx_v_to_final) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_push __pyx_t_2;
+ __Pyx_RefNannySetupContext("push", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 6;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.push_weights = __pyx_v_push_weights;
+ __pyx_t_2.push_labels = __pyx_v_push_labels;
+ __pyx_t_2.remove_common_affix = __pyx_v_remove_common_affix;
+ __pyx_t_2.remove_total_weight = __pyx_v_remove_total_weight;
+ __pyx_t_2.to_final = __pyx_v_to_final;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_push(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3635, __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":3687
+ *
+ *
+ * cpdef bool randequivalent(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * int32 npath=1,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_39randequivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static bool __pyx_f_9pywrapfst_randequivalent(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randequivalent *__pyx_optional_args) {
+ __pyx_t_10basictypes_int32 __pyx_v_npath = ((__pyx_t_10basictypes_int32)1);
+ float __pyx_v_delta = __pyx_k__47;
+ time_t __pyx_v_seed = ((time_t)0);
+ PyObject *__pyx_v_select = ((PyObject *)__pyx_n_b_uniform);
+ __pyx_t_10basictypes_int32 __pyx_v_max_length = __pyx_k__48;
+ enum fst::script::RandArcSelection __pyx_v_ras;
+ std::unique_ptr<fst::RandGenOptions<enum fst::script::RandArcSelection> > __pyx_v_opts;
+ bool __pyx_v_error;
+ bool __pyx_v_result;
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ enum fst::script::RandArcSelection __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("randequivalent", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_npath = __pyx_optional_args->npath;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_seed = __pyx_optional_args->seed;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_select = __pyx_optional_args->select;
+ if (__pyx_optional_args->__pyx_n > 4) {
+ __pyx_v_max_length = __pyx_optional_args->max_length;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3725
+ * See also: `equal`, `equivalent`, `isomorphic`, `randgen`.
+ * """
+ * cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select)) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts
+ * # The three trailing options will be ignored by RandEquivalent.
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_select, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3725, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst__get_rand_arc_selection(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3725, __pyx_L1_error)
+ __pyx_v_ras = __pyx_t_2;
+
+ /* "pywrapfst.pyx":3728
+ * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts
+ * # The three trailing options will be ignored by RandEquivalent.
+ * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, # <<<<<<<<<<<<<<
+ * 1, False, False))
+ * if seed == 0:
+ */
+ __pyx_v_opts.reset(new fst::RandGenOptions<enum fst::script::RandArcSelection> (__pyx_v_ras, __pyx_v_max_length, 1, 0, 0));
+
+ /* "pywrapfst.pyx":3730
+ * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length,
+ * 1, False, False))
+ * if seed == 0: # <<<<<<<<<<<<<<
+ * seed = time(NULL) + getpid()
+ * cdef bool error
+ */
+ __pyx_t_3 = ((__pyx_v_seed == 0) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":3731
+ * 1, False, False))
+ * if seed == 0:
+ * seed = time(NULL) + getpid() # <<<<<<<<<<<<<<
+ * cdef bool error
+ * cdef bool result = fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst),
+ */
+ __pyx_v_seed = (time(NULL) + getpid());
+
+ /* "pywrapfst.pyx":3730
+ * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length,
+ * 1, False, False))
+ * if seed == 0: # <<<<<<<<<<<<<<
+ * seed = time(NULL) + getpid()
+ * cdef bool error
+ */
+ }
+
+ /* "pywrapfst.pyx":3733
+ * seed = time(NULL) + getpid()
+ * cdef bool error
+ * cdef bool result = fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst), # <<<<<<<<<<<<<<
+ * npath, delta, seed, deref(opts),
+ * addr(error))
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst1) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3733, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_ifst2) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3733, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3735
+ * cdef bool result = fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst),
+ * npath, delta, seed, deref(opts),
+ * addr(error)) # <<<<<<<<<<<<<<
+ * if error:
+ * raise FstOpError("Random equivalence test encountered error")
+ */
+ __pyx_v_result = fst::script::RandEquivalent((*__pyx_v_ifst1->_fst), (*__pyx_v_ifst2->_fst), __pyx_v_npath, __pyx_v_delta, __pyx_v_seed, (*__pyx_v_opts), (&__pyx_v_error));
+
+ /* "pywrapfst.pyx":3736
+ * npath, delta, seed, deref(opts),
+ * addr(error))
+ * if error: # <<<<<<<<<<<<<<
+ * raise FstOpError("Random equivalence test encountered error")
+ * return result
+ */
+ __pyx_t_3 = (__pyx_v_error != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":3737
+ * addr(error))
+ * if error:
+ * raise FstOpError("Random equivalence test encountered error") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3737, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3737, __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, 3737, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3736
+ * npath, delta, seed, deref(opts),
+ * addr(error))
+ * if error: # <<<<<<<<<<<<<<
+ * raise FstOpError("Random equivalence test encountered error")
+ * return result
+ */
+ }
+
+ /* "pywrapfst.pyx":3738
+ * if error:
+ * raise FstOpError("Random equivalence test encountered error")
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3687
+ *
+ *
+ * cpdef bool randequivalent(_Fst ifst1, # <<<<<<<<<<<<<<
+ * _Fst ifst2,
+ * int32 npath=1,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_AddTraceback("pywrapfst.randequivalent", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_39randequivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_38randequivalent[] = "\n randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0,\n select=\"uniform\", max_length=2147483647)\n\n Are two acceptors stochastically equivalent?\n\n This operation tests whether two FSTs are equivalent by randomly generating\n paths alternatively in each of the two FSTs. For each randomly generated path,\n the algorithm computes for each of the two FSTs the sum of the weights of all\n the successful paths sharing the same input and output labels as the randomly\n generated path and checks that these two values are within `delta`.\n\n Args:\n ifst1: The first input FST.\n ifst2: The second input FST.\n npath: The number of random paths to generate.\n delta: Comparison/quantization delta.\n seed: An optional seed value for random path generation; if zero, the\n current time and process ID is used.\n select: A string matching a known random arc selection type; one of:\n \"uniform\", \"log_prob\", \"fast_log_prob\".\n max_length: The maximum length of each random path.\n\n Returns:\n True if the two transducers satisfy the above condition, else False.\n\n Raise:\n FstOpError: Random equivalence test encountered error.\n\n See also: `equal`, `equivalent`, `isomorphic`, `randgen`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_39randequivalent(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1 = 0;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2 = 0;
+ __pyx_t_10basictypes_int32 __pyx_v_npath;
+ float __pyx_v_delta;
+ time_t __pyx_v_seed;
+ PyObject *__pyx_v_select = 0;
+ __pyx_t_10basictypes_int32 __pyx_v_max_length;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("randequivalent (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst1,&__pyx_n_s_ifst2,&__pyx_n_s_npath,&__pyx_n_s_delta,&__pyx_n_s_seed,&__pyx_n_s_select,&__pyx_n_s_max_length,0};
+ PyObject* values[7] = {0,0,0,0,0,0,0};
+ values[5] = ((PyObject *)__pyx_n_b_uniform);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst1)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst2)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("randequivalent", 0, 2, 7, 1); __PYX_ERR(0, 3687, __pyx_L3_error)
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_npath);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_seed);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_select);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_length);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "randequivalent") < 0)) __PYX_ERR(0, 3687, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_ifst1 = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]);
+ __pyx_v_ifst2 = ((struct __pyx_obj_9pywrapfst__Fst *)values[1]);
+ if (values[2]) {
+ __pyx_v_npath = __Pyx_PyInt_As_int32_t(values[2]); if (unlikely((__pyx_v_npath == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3689, __pyx_L3_error)
+ } else {
+ __pyx_v_npath = ((__pyx_t_10basictypes_int32)1);
+ }
+ if (values[3]) {
+ __pyx_v_delta = __pyx_PyFloat_AsFloat(values[3]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3690, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__47;
+ }
+ if (values[4]) {
+ __pyx_v_seed = __Pyx_PyInt_As_time_t(values[4]); if (unlikely((__pyx_v_seed == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3691, __pyx_L3_error)
+ } else {
+ __pyx_v_seed = ((time_t)0);
+ }
+ __pyx_v_select = values[5];
+ if (values[6]) {
+ __pyx_v_max_length = __Pyx_PyInt_As_int32_t(values[6]); if (unlikely((__pyx_v_max_length == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3693, __pyx_L3_error)
+ } else {
+ __pyx_v_max_length = __pyx_k__48;
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("randequivalent", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3687, __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, 3687, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst2), __pyx_ptype_9pywrapfst__Fst, 1, "ifst2", 0))) __PYX_ERR(0, 3688, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_38randequivalent(__pyx_self, __pyx_v_ifst1, __pyx_v_ifst2, __pyx_v_npath, __pyx_v_delta, __pyx_v_seed, __pyx_v_select, __pyx_v_max_length);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_38randequivalent(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst1, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst2, __pyx_t_10basictypes_int32 __pyx_v_npath, float __pyx_v_delta, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ bool __pyx_t_1;
+ struct __pyx_opt_args_9pywrapfst_randequivalent __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("randequivalent", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 5;
+ __pyx_t_2.npath = __pyx_v_npath;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.seed = __pyx_v_seed;
+ __pyx_t_2.select = __pyx_v_select;
+ __pyx_t_2.max_length = __pyx_v_max_length;
+ __pyx_t_1 = __pyx_f_9pywrapfst_randequivalent(__pyx_v_ifst1, __pyx_v_ifst2, 0, &__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3687, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3687, __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":3741
+ *
+ *
+ * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<<
+ * int32 npath=1,
+ * time_t seed=0,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_41randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_randgen(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_randgen *__pyx_optional_args) {
+ __pyx_t_10basictypes_int32 __pyx_v_npath = ((__pyx_t_10basictypes_int32)1);
+ time_t __pyx_v_seed = ((time_t)0);
+ PyObject *__pyx_v_select = ((PyObject *)__pyx_n_b_uniform);
+ __pyx_t_10basictypes_int32 __pyx_v_max_length = __pyx_k__50;
+
+ /* "pywrapfst.pyx":3746
+ * select=b"uniform",
+ * int32 max_length=INT32_MAX,
+ * bool weighted=False, # <<<<<<<<<<<<<<
+ * bool remove_total_weight=False):
+ * """
+ */
+ bool __pyx_v_weighted = ((bool)0);
+
+ /* "pywrapfst.pyx":3747
+ * int32 max_length=INT32_MAX,
+ * bool weighted=False,
+ * bool remove_total_weight=False): # <<<<<<<<<<<<<<
+ * """
+ * randgen(ifst, npath=1, seed=0, select="uniform", max_length=2147483647,
+ */
+ bool __pyx_v_remove_total_weight = ((bool)0);
+ enum fst::script::RandArcSelection __pyx_v_ras;
+ std::unique_ptr<fst::RandGenOptions<enum fst::script::RandArcSelection> > __pyx_v_opts;
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ enum fst::script::RandArcSelection __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("randgen", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_npath = __pyx_optional_args->npath;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_seed = __pyx_optional_args->seed;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_select = __pyx_optional_args->select;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_max_length = __pyx_optional_args->max_length;
+ if (__pyx_optional_args->__pyx_n > 4) {
+ __pyx_v_weighted = __pyx_optional_args->weighted;
+ if (__pyx_optional_args->__pyx_n > 5) {
+ __pyx_v_remove_total_weight = __pyx_optional_args->remove_total_weight;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3779
+ * See also: `randequivalent`.
+ * """
+ * cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select)) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts
+ * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length,
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_select, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3779, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst__get_rand_arc_selection(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3779, __pyx_L1_error)
+ __pyx_v_ras = __pyx_t_2;
+
+ /* "pywrapfst.pyx":3781
+ * cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select))
+ * cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts
+ * opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length, # <<<<<<<<<<<<<<
+ * npath, weighted,
+ * remove_total_weight))
+ */
+ __pyx_v_opts.reset(new fst::RandGenOptions<enum fst::script::RandArcSelection> (__pyx_v_ras, __pyx_v_max_length, __pyx_v_npath, __pyx_v_weighted, __pyx_v_remove_total_weight));
+
+ /* "pywrapfst.pyx":3784
+ * npath, weighted,
+ * remove_total_weight))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * if seed == 0:
+ * seed = time(NULL) + getpid()
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3784, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3785
+ * remove_total_weight))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * if seed == 0: # <<<<<<<<<<<<<<
+ * seed = time(NULL) + getpid()
+ * fst.RandGen(deref(ifst._fst), tfst, seed, deref(opts))
+ */
+ __pyx_t_3 = ((__pyx_v_seed == 0) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":3786
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * if seed == 0:
+ * seed = time(NULL) + getpid() # <<<<<<<<<<<<<<
+ * fst.RandGen(deref(ifst._fst), tfst, seed, deref(opts))
+ * return _init_MutableFst(tfst)
+ */
+ __pyx_v_seed = (time(NULL) + getpid());
+
+ /* "pywrapfst.pyx":3785
+ * remove_total_weight))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * if seed == 0: # <<<<<<<<<<<<<<
+ * seed = time(NULL) + getpid()
+ * fst.RandGen(deref(ifst._fst), tfst, seed, deref(opts))
+ */
+ }
+
+ /* "pywrapfst.pyx":3787
+ * if seed == 0:
+ * seed = time(NULL) + getpid()
+ * fst.RandGen(deref(ifst._fst), tfst, seed, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3787, __pyx_L1_error)
+ }
+ fst::script::RandGen((*__pyx_v_ifst->_fst), __pyx_v_tfst, __pyx_v_seed, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3788
+ * seed = time(NULL) + getpid()
+ * fst.RandGen(deref(ifst._fst), tfst, seed, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3788, __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":3741
+ *
+ *
+ * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<<
+ * int32 npath=1,
+ * time_t seed=0,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst.randgen", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_41randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_40randgen[] = "\n randgen(ifst, npath=1, seed=0, select=\"uniform\", max_length=2147483647,\n weight=False, remove_total_weight=False)\n\n Randomly generate successful paths in an FST.\n\n This operation randomly generates a set of successful paths in the input FST.\n This relies on a mechanism for selecting arcs, specified using the `select`\n argument. The default selector, \"uniform\", randomly selects a transition\n using a uniform distribution. The \"log_prob\" selector randomly selects a\n transition w.r.t. the weights treated as negative log probabilities after\n normalizing for the total weight leaving the state. In all cases, finality is\n treated as a transition to a super-final state.\n\n Args:\n ifst: The input FST.\n npath: The number of random paths to generate.\n seed: An optional seed value for random path generation; if zero, the\n current time and process ID is used.\n select: A string matching a known random arc selection type; one of:\n \"uniform\", \"log_prob\", \"fast_log_prob\".\n max_length: The maximum length of each random path.\n weighted: Should the output be weighted by path count?\n remove_total_weight: Should the total weight be removed (ignored when\n `weighted` is False)?\n\n Returns:\n An Fst containing one or more random paths.\n\n See also: `randequivalent`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_41randgen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ __pyx_t_10basictypes_int32 __pyx_v_npath;
+ time_t __pyx_v_seed;
+ PyObject *__pyx_v_select = 0;
+ __pyx_t_10basictypes_int32 __pyx_v_max_length;
+ bool __pyx_v_weighted;
+ bool __pyx_v_remove_total_weight;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("randgen (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_npath,&__pyx_n_s_seed,&__pyx_n_s_select,&__pyx_n_s_max_length,&__pyx_n_s_weighted,&__pyx_n_s_remove_total_weight,0};
+ PyObject* values[7] = {0,0,0,0,0,0,0};
+ values[3] = ((PyObject *)__pyx_n_b_uniform);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_npath);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_seed);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_select);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_length);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weighted);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remove_total_weight);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "randgen") < 0)) __PYX_ERR(0, 3741, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)values[0]);
+ if (values[1]) {
+ __pyx_v_npath = __Pyx_PyInt_As_int32_t(values[1]); if (unlikely((__pyx_v_npath == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3742, __pyx_L3_error)
+ } else {
+ __pyx_v_npath = ((__pyx_t_10basictypes_int32)1);
+ }
+ if (values[2]) {
+ __pyx_v_seed = __Pyx_PyInt_As_time_t(values[2]); if (unlikely((__pyx_v_seed == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3743, __pyx_L3_error)
+ } else {
+ __pyx_v_seed = ((time_t)0);
+ }
+ __pyx_v_select = values[3];
+ if (values[4]) {
+ __pyx_v_max_length = __Pyx_PyInt_As_int32_t(values[4]); if (unlikely((__pyx_v_max_length == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3745, __pyx_L3_error)
+ } else {
+ __pyx_v_max_length = __pyx_k__50;
+ }
+ if (values[5]) {
+ __pyx_v_weighted = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_weighted == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3746, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3746
+ * select=b"uniform",
+ * int32 max_length=INT32_MAX,
+ * bool weighted=False, # <<<<<<<<<<<<<<
+ * bool remove_total_weight=False):
+ * """
+ */
+ __pyx_v_weighted = ((bool)0);
+ }
+ if (values[6]) {
+ __pyx_v_remove_total_weight = __Pyx_PyObject_IsTrue(values[6]); if (unlikely((__pyx_v_remove_total_weight == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3747, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3747
+ * int32 max_length=INT32_MAX,
+ * bool weighted=False,
+ * bool remove_total_weight=False): # <<<<<<<<<<<<<<
+ * """
+ * randgen(ifst, npath=1, seed=0, select="uniform", max_length=2147483647,
+ */
+ __pyx_v_remove_total_weight = ((bool)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("randgen", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3741, __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, 3741, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_40randgen(__pyx_self, __pyx_v_ifst, __pyx_v_npath, __pyx_v_seed, __pyx_v_select, __pyx_v_max_length, __pyx_v_weighted, __pyx_v_remove_total_weight);
+
+ /* "pywrapfst.pyx":3741
+ *
+ *
+ * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<<
+ * int32 npath=1,
+ * time_t seed=0,
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_40randgen(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, __pyx_t_10basictypes_int32 __pyx_v_npath, time_t __pyx_v_seed, PyObject *__pyx_v_select, __pyx_t_10basictypes_int32 __pyx_v_max_length, bool __pyx_v_weighted, bool __pyx_v_remove_total_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_randgen __pyx_t_2;
+ __Pyx_RefNannySetupContext("randgen", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 6;
+ __pyx_t_2.npath = __pyx_v_npath;
+ __pyx_t_2.seed = __pyx_v_seed;
+ __pyx_t_2.select = __pyx_v_select;
+ __pyx_t_2.max_length = __pyx_v_max_length;
+ __pyx_t_2.remove_total_weight = __pyx_v_weighted;
+ __pyx_t_2.weighted = __pyx_v_remove_total_weight;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_randgen(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3741, __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":3791
+ *
+ *
+ * cpdef _MutableFst replace(pairs, # <<<<<<<<<<<<<<
+ * call_arc_labeling=b"input",
+ * return_arc_labeling=b"neither",
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_43replace(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_replace(PyObject *__pyx_v_pairs, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_replace *__pyx_optional_args) {
+ PyObject *__pyx_v_call_arc_labeling = ((PyObject *)__pyx_n_b_input);
+ PyObject *__pyx_v_return_arc_labeling = ((PyObject *)__pyx_n_b_neither);
+
+ /* "pywrapfst.pyx":3794
+ * call_arc_labeling=b"input",
+ * return_arc_labeling=b"neither",
+ * bool epsilon_on_replace=False, # <<<<<<<<<<<<<<
+ * int64 return_label=0):
+ * """
+ */
+ bool __pyx_v_epsilon_on_replace = ((bool)0);
+ __pyx_t_10basictypes_int64 __pyx_v_return_label = ((__pyx_t_10basictypes_int64)0);
+ std::vector<__pyx_t_3fst_LabelFstClassPair> __pyx_v__pairs;
+ __pyx_t_10basictypes_int64 __pyx_v_root_label;
+ __pyx_t_10basictypes_int64 __pyx_v_label;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ PyObject *__pyx_v_it = NULL;
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ enum fst::ReplaceLabelType __pyx_v_cal;
+ enum fst::ReplaceLabelType __pyx_v_ral;
+ std::unique_ptr<fst::script::ReplaceOptions> __pyx_v_opts;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *(*__pyx_t_5)(PyObject *);
+ __pyx_t_10basictypes_int64 __pyx_t_6;
+ __pyx_t_3fst_LabelFstClassPair __pyx_t_7;
+ Py_ssize_t __pyx_t_8;
+ PyObject *(*__pyx_t_9)(PyObject *);
+ PyObject *__pyx_t_10 = NULL;
+ std::string __pyx_t_11;
+ enum fst::ReplaceLabelType __pyx_t_12;
+ __Pyx_RefNannySetupContext("replace", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_call_arc_labeling = __pyx_optional_args->call_arc_labeling;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_return_arc_labeling = __pyx_optional_args->return_arc_labeling;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_epsilon_on_replace = __pyx_optional_args->epsilon_on_replace;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_return_label = __pyx_optional_args->return_label;
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3836
+ * cdef int64 label
+ * cdef _Fst ifst
+ * it = iter(pairs) # <<<<<<<<<<<<<<
+ * (root_label, ifst) = next(it)
+ * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get()))
+ */
+ __pyx_t_1 = PyObject_GetIter(__pyx_v_pairs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3836, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_v_it = __pyx_t_1;
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":3837
+ * cdef _Fst ifst
+ * it = iter(pairs)
+ * (root_label, ifst) = next(it) # <<<<<<<<<<<<<<
+ * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get()))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ */
+ __pyx_t_1 = __Pyx_PyIter_Next(__pyx_v_it); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3837, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
+ PyObject* sequence = __pyx_t_1;
+ #if !CYTHON_COMPILING_IN_PYPY
+ Py_ssize_t size = Py_SIZE(sequence);
+ #else
+ Py_ssize_t size = PySequence_Size(sequence);
+ #endif
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(0, 3837, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ if (likely(PyTuple_CheckExact(sequence))) {
+ __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
+ } else {
+ __pyx_t_2 = PyList_GET_ITEM(sequence, 0);
+ __pyx_t_3 = PyList_GET_ITEM(sequence, 1);
+ }
+ __Pyx_INCREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_3);
+ #else
+ __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3837, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3837, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ #endif
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ } else {
+ Py_ssize_t index = -1;
+ __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3837, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext;
+ index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_2);
+ index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_3);
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(0, 3837, __pyx_L1_error)
+ __pyx_t_5 = NULL;
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ goto __pyx_L4_unpacking_done;
+ __pyx_L3_unpacking_failed:;
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_5 = NULL;
+ if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+ __PYX_ERR(0, 3837, __pyx_L1_error)
+ __pyx_L4_unpacking_done:;
+ }
+ __pyx_t_6 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_6 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3837, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pywrapfst__Fst))))) __PYX_ERR(0, 3837, __pyx_L1_error)
+ __pyx_v_root_label = __pyx_t_6;
+ __pyx_v_ifst = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":3838
+ * it = iter(pairs)
+ * (root_label, ifst) = next(it)
+ * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get())) # <<<<<<<<<<<<<<
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * for (label, ifst) in it:
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3838, __pyx_L1_error)
+ }
+ try {
+ __pyx_t_7 = __pyx_t_3fst_LabelFstClassPair(__pyx_v_root_label, __pyx_v_ifst->_fst.get());
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 3838, __pyx_L1_error)
+ }
+ try {
+ __pyx_v__pairs.push_back(__pyx_t_7);
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 3838, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3839
+ * (root_label, ifst) = next(it)
+ * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get()))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * for (label, ifst) in it:
+ * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get()))
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3839, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3840
+ * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get()))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * for (label, ifst) in it: # <<<<<<<<<<<<<<
+ * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get()))
+ * cdef fst.ReplaceLabelType cal = _get_replace_label_type(
+ */
+ if (likely(PyList_CheckExact(__pyx_v_it)) || PyTuple_CheckExact(__pyx_v_it)) {
+ __pyx_t_1 = __pyx_v_it; __Pyx_INCREF(__pyx_t_1); __pyx_t_8 = 0;
+ __pyx_t_9 = NULL;
+ } else {
+ __pyx_t_8 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_it); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_9 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ }
+ for (;;) {
+ if (likely(!__pyx_t_9)) {
+ if (likely(PyList_CheckExact(__pyx_t_1))) {
+ if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ #else
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ #endif
+ } else {
+ if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ #else
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ #endif
+ }
+ } else {
+ __pyx_t_3 = __pyx_t_9(__pyx_t_1);
+ if (unlikely(!__pyx_t_3)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 3840, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_3);
+ }
+ if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
+ PyObject* sequence = __pyx_t_3;
+ #if !CYTHON_COMPILING_IN_PYPY
+ Py_ssize_t size = Py_SIZE(sequence);
+ #else
+ Py_ssize_t size = PySequence_Size(sequence);
+ #endif
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(0, 3840, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ if (likely(PyTuple_CheckExact(sequence))) {
+ __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
+ } else {
+ __pyx_t_2 = PyList_GET_ITEM(sequence, 0);
+ __pyx_t_4 = PyList_GET_ITEM(sequence, 1);
+ }
+ __Pyx_INCREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ #else
+ __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ #endif
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else {
+ Py_ssize_t index = -1;
+ __pyx_t_10 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_5 = Py_TYPE(__pyx_t_10)->tp_iternext;
+ index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_10); if (unlikely(!__pyx_t_2)) goto __pyx_L7_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_2);
+ index = 1; __pyx_t_4 = __pyx_t_5(__pyx_t_10); if (unlikely(!__pyx_t_4)) goto __pyx_L7_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_4);
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_10), 2) < 0) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __pyx_t_5 = NULL;
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ goto __pyx_L8_unpacking_done;
+ __pyx_L7_unpacking_failed:;
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ __pyx_t_5 = NULL;
+ if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+ __PYX_ERR(0, 3840, __pyx_L1_error)
+ __pyx_L8_unpacking_done:;
+ }
+ __pyx_t_6 = __Pyx_PyInt_As_int64_t(__pyx_t_2); if (unlikely((__pyx_t_6 == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_9pywrapfst__Fst))))) __PYX_ERR(0, 3840, __pyx_L1_error)
+ __pyx_v_label = __pyx_t_6;
+ __Pyx_DECREF_SET(__pyx_v_ifst, ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_4));
+ __pyx_t_4 = 0;
+
+ /* "pywrapfst.pyx":3841
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * for (label, ifst) in it:
+ * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get())) # <<<<<<<<<<<<<<
+ * cdef fst.ReplaceLabelType cal = _get_replace_label_type(
+ * tostring(call_arc_labeling), epsilon_on_replace)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3841, __pyx_L1_error)
+ }
+ try {
+ __pyx_t_7 = __pyx_t_3fst_LabelFstClassPair(__pyx_v_label, __pyx_v_ifst->_fst.get());
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 3841, __pyx_L1_error)
+ }
+ try {
+ __pyx_v__pairs.push_back(__pyx_t_7);
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 3841, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":3840
+ * _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get()))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * for (label, ifst) in it: # <<<<<<<<<<<<<<
+ * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get()))
+ * cdef fst.ReplaceLabelType cal = _get_replace_label_type(
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":3843
+ * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get()))
+ * cdef fst.ReplaceLabelType cal = _get_replace_label_type(
+ * tostring(call_arc_labeling), epsilon_on_replace) # <<<<<<<<<<<<<<
+ * cdef fst.ReplaceLabelType ral = _get_replace_label_type(
+ * tostring(return_arc_labeling), epsilon_on_replace)
+ */
+ __pyx_t_11 = __pyx_f_9pywrapfst_tostring(__pyx_v_call_arc_labeling, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3843, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3842
+ * for (label, ifst) in it:
+ * _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get()))
+ * cdef fst.ReplaceLabelType cal = _get_replace_label_type( # <<<<<<<<<<<<<<
+ * tostring(call_arc_labeling), epsilon_on_replace)
+ * cdef fst.ReplaceLabelType ral = _get_replace_label_type(
+ */
+ __pyx_t_12 = __pyx_f_9pywrapfst__get_replace_label_type(__pyx_t_11, __pyx_v_epsilon_on_replace); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3842, __pyx_L1_error)
+ __pyx_v_cal = __pyx_t_12;
+
+ /* "pywrapfst.pyx":3845
+ * tostring(call_arc_labeling), epsilon_on_replace)
+ * cdef fst.ReplaceLabelType ral = _get_replace_label_type(
+ * tostring(return_arc_labeling), epsilon_on_replace) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.ReplaceOptions] opts
+ * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label))
+ */
+ __pyx_t_11 = __pyx_f_9pywrapfst_tostring(__pyx_v_return_arc_labeling, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3845, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3844
+ * cdef fst.ReplaceLabelType cal = _get_replace_label_type(
+ * tostring(call_arc_labeling), epsilon_on_replace)
+ * cdef fst.ReplaceLabelType ral = _get_replace_label_type( # <<<<<<<<<<<<<<
+ * tostring(return_arc_labeling), epsilon_on_replace)
+ * cdef unique_ptr[fst.ReplaceOptions] opts
+ */
+ __pyx_t_12 = __pyx_f_9pywrapfst__get_replace_label_type(__pyx_t_11, __pyx_v_epsilon_on_replace); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3844, __pyx_L1_error)
+ __pyx_v_ral = __pyx_t_12;
+
+ /* "pywrapfst.pyx":3847
+ * tostring(return_arc_labeling), epsilon_on_replace)
+ * cdef unique_ptr[fst.ReplaceOptions] opts
+ * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label)) # <<<<<<<<<<<<<<
+ * fst.Replace(_pairs, tfst, deref(opts))
+ * return _init_MutableFst(tfst)
+ */
+ __pyx_v_opts.reset(new fst::script::ReplaceOptions(__pyx_v_root_label, __pyx_v_cal, __pyx_v_ral, __pyx_v_return_label));
+
+ /* "pywrapfst.pyx":3848
+ * cdef unique_ptr[fst.ReplaceOptions] opts
+ * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label))
+ * fst.Replace(_pairs, tfst, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ fst::script::Replace(__pyx_v__pairs, __pyx_v_tfst, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3849
+ * opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label))
+ * fst.Replace(_pairs, tfst, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3849, __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":3791
+ *
+ *
+ * cpdef _MutableFst replace(pairs, # <<<<<<<<<<<<<<
+ * call_arc_labeling=b"input",
+ * return_arc_labeling=b"neither",
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_10);
+ __Pyx_AddTraceback("pywrapfst.replace", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_ifst);
+ __Pyx_XDECREF(__pyx_v_it);
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_43replace(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_42replace[] = "\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_43replace(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_pairs = 0;
+ PyObject *__pyx_v_call_arc_labeling = 0;
+ PyObject *__pyx_v_return_arc_labeling = 0;
+ bool __pyx_v_epsilon_on_replace;
+ __pyx_t_10basictypes_int64 __pyx_v_return_label;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("replace (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pairs,&__pyx_n_s_call_arc_labeling,&__pyx_n_s_return_arc_labeling,&__pyx_n_s_epsilon_on_replace,&__pyx_n_s_return_label,0};
+ PyObject* values[5] = {0,0,0,0,0};
+ values[1] = ((PyObject *)__pyx_n_b_input);
+ values[2] = ((PyObject *)__pyx_n_b_neither);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pairs)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_call_arc_labeling);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_return_arc_labeling);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_epsilon_on_replace);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_return_label);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "replace") < 0)) __PYX_ERR(0, 3791, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3794, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3794
+ * call_arc_labeling=b"input",
+ * return_arc_labeling=b"neither",
+ * bool epsilon_on_replace=False, # <<<<<<<<<<<<<<
+ * int64 return_label=0):
+ * """
+ */
+ __pyx_v_epsilon_on_replace = ((bool)0);
+ }
+ if (values[4]) {
+ __pyx_v_return_label = __Pyx_PyInt_As_int64_t(values[4]); if (unlikely((__pyx_v_return_label == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3795, __pyx_L3_error)
+ } else {
+ __pyx_v_return_label = ((__pyx_t_10basictypes_int64)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("replace", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3791, __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_42replace(__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":3791
+ *
+ *
+ * cpdef _MutableFst replace(pairs, # <<<<<<<<<<<<<<
+ * call_arc_labeling=b"input",
+ * return_arc_labeling=b"neither",
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_42replace(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pairs, PyObject *__pyx_v_call_arc_labeling, PyObject *__pyx_v_return_arc_labeling, bool __pyx_v_epsilon_on_replace, __pyx_t_10basictypes_int64 __pyx_v_return_label) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_replace __pyx_t_2;
+ __Pyx_RefNannySetupContext("replace", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 4;
+ __pyx_t_2.call_arc_labeling = __pyx_v_call_arc_labeling;
+ __pyx_t_2.return_arc_labeling = __pyx_v_return_arc_labeling;
+ __pyx_t_2.epsilon_on_replace = __pyx_v_epsilon_on_replace;
+ __pyx_t_2.return_label = __pyx_v_return_label;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_replace(__pyx_v_pairs, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3791, __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":3852
+ *
+ *
+ * cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=True): # <<<<<<<<<<<<<<
+ * """
+ * reverse(ifst, require_superinitial=True)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_45reverse(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);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("reverse", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_require_superinitial = __pyx_optional_args->require_superinitial;
+ }
+ }
+
+ /* "pywrapfst.pyx":3871
+ * A reversed FST.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * fst.Reverse(deref(ifst._fst), tfst, require_superinitial)
+ * return _init_MutableFst(tfst)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3871, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3872
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.Reverse(deref(ifst._fst), tfst, require_superinitial) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3872, __pyx_L1_error)
+ }
+ fst::script::Reverse((*__pyx_v_ifst->_fst), __pyx_v_tfst, __pyx_v_require_superinitial);
+
+ /* "pywrapfst.pyx":3873
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.Reverse(deref(ifst._fst), tfst, require_superinitial)
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3873, __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":3852
+ *
+ *
+ * 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_45reverse(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_44reverse[] = "\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_45reverse(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ bool __pyx_v_require_superinitial;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("reverse (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_require_superinitial,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_require_superinitial);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "reverse") < 0)) __PYX_ERR(0, 3852, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3852, __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, 3852, __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, 3852, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_44reverse(__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_44reverse(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_require_superinitial) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_reverse __pyx_t_2;
+ __Pyx_RefNannySetupContext("reverse", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 1;
+ __pyx_t_2.require_superinitial = __pyx_v_require_superinitial;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_reverse(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3852, __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":3876
+ *
+ *
+ * cpdef _MutableFst rmepsilon(_Fst ifst, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_47rmepsilon(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static struct __pyx_obj_9pywrapfst__MutableFst *__pyx_f_9pywrapfst_rmepsilon(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, CYTHON_UNUSED int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_rmepsilon *__pyx_optional_args) {
+
+ /* "pywrapfst.pyx":3877
+ *
+ * cpdef _MutableFst rmepsilon(_Fst ifst,
+ * bool connect=True, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+ bool __pyx_v_connect = ((bool)1);
+ float __pyx_v_delta = __pyx_k__51;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__52;
+ PyObject *__pyx_v_qt = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3881
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ * bool reverse=False, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ bool __pyx_v_reverse = ((bool)0);
+
+ /* "pywrapfst.pyx":3882
+ * qt=b"auto",
+ * bool reverse=False,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * rmepsilon(ifst, connect=True, delta=0.0009765625, nstate=-1, qt="auto",
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ fst::script::WeightClass __pyx_v_wc;
+ std::unique_ptr<fst::script::RmEpsilonOptions> __pyx_v_opts;
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ fst::script::WeightClass __pyx_t_1;
+ std::string __pyx_t_2;
+ enum fst::QueueType __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("rmepsilon", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_connect = __pyx_optional_args->connect;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_nstate = __pyx_optional_args->nstate;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_qt = __pyx_optional_args->qt;
+ if (__pyx_optional_args->__pyx_n > 4) {
+ __pyx_v_reverse = __pyx_optional_args->reverse;
+ if (__pyx_optional_args->__pyx_n > 5) {
+ __pyx_v_weight = __pyx_optional_args->weight;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3906
+ * An equivalent FST with no epsilon transitions.
+ * """
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.RmEpsilonOptions] opts
+ * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(qt)), delta,
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 3906, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_f_9pywrapfst__get_WeightClass_or_Zero(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0), __pyx_v_weight); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3906, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_1;
+
+ /* "pywrapfst.pyx":3908
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ * cdef unique_ptr[fst.RmEpsilonOptions] opts
+ * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(qt)), delta, # <<<<<<<<<<<<<<
+ * connect, wc, nstate))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ */
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_qt, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3908, __pyx_L1_error)
+ __pyx_t_3 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3908, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3909
+ * cdef unique_ptr[fst.RmEpsilonOptions] opts
+ * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(qt)), delta,
+ * connect, wc, nstate)) # <<<<<<<<<<<<<<
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.RmEpsilon(deref(ifst._fst), tfst, reverse, deref(opts))
+ */
+ __pyx_v_opts.reset(new fst::script::RmEpsilonOptions(__pyx_t_3, __pyx_v_delta, __pyx_v_connect, __pyx_v_wc, __pyx_v_nstate));
+
+ /* "pywrapfst.pyx":3910
+ * opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(qt)), delta,
+ * connect, wc, nstate))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * fst.RmEpsilon(deref(ifst._fst), tfst, reverse, deref(opts))
+ * return _init_MutableFst(tfst)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 3910, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":3911
+ * connect, wc, nstate))
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.RmEpsilon(deref(ifst._fst), tfst, reverse, deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3911, __pyx_L1_error)
+ }
+ fst::script::RmEpsilon((*__pyx_v_ifst->_fst), __pyx_v_tfst, __pyx_v_reverse, (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":3912
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.RmEpsilon(deref(ifst._fst), tfst, reverse, deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_4 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3912, __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":3876
+ *
+ *
+ * cpdef _MutableFst rmepsilon(_Fst ifst, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst.rmepsilon", __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_47rmepsilon(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_46rmepsilon[] = "\n rmepsilon(ifst, connect=True, delta=0.0009765625, nstate=-1, qt=\"auto\",\n reverse=False, weight=None)\n\n Constructively removes epsilon transitions from an FST.\n\n This operation removes epsilon transitions (those where both input and output\n labels are epsilon) from an FST.\n\n Args:\n ifst: The input FST.\n connect: Should output be trimmed?\n delta: Comparison/quantization delta.\n nstate: State number threshold.\n qt: A string matching a known queue type; one of: \"auto\", \"fifo\", \"lifo\",\n \"shortest\", \"state\", \"top\".\n reverse: Should epsilon transitions be removed in reverse order?\n weight: A string indicating the desired weight threshold; paths with\n weights below this threshold will be pruned.\n\n Returns:\n An equivalent FST with no epsilon transitions.\n ";
+static PyObject *__pyx_pw_9pywrapfst_47rmepsilon(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ bool __pyx_v_connect;
+ float __pyx_v_delta;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ PyObject *__pyx_v_qt = 0;
+ bool __pyx_v_reverse;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("rmepsilon (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_connect,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_qt,&__pyx_n_s_reverse,&__pyx_n_s_weight,0};
+ PyObject* values[7] = {0,0,0,0,0,0,0};
+ values[4] = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3882
+ * qt=b"auto",
+ * bool reverse=False,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * rmepsilon(ifst, connect=True, delta=0.0009765625, nstate=-1, qt="auto",
+ */
+ 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);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_connect);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_qt);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_reverse);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "rmepsilon") < 0)) __PYX_ERR(0, 3876, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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_connect = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_connect == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3877, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3877
+ *
+ * cpdef _MutableFst rmepsilon(_Fst ifst,
+ * bool connect=True, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_v_connect = ((bool)1);
+ }
+ if (values[2]) {
+ __pyx_v_delta = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_delta == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3878, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__51;
+ }
+ if (values[3]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3879, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__52;
+ }
+ __pyx_v_qt = values[4];
+ if (values[5]) {
+ __pyx_v_reverse = __Pyx_PyObject_IsTrue(values[5]); if (unlikely((__pyx_v_reverse == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3881, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3881
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ * bool reverse=False, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ __pyx_v_reverse = ((bool)0);
+ }
+ __pyx_v_weight = values[6];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("rmepsilon", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3876, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.rmepsilon", __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, 3876, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_46rmepsilon(__pyx_self, __pyx_v_ifst, __pyx_v_connect, __pyx_v_delta, __pyx_v_nstate, __pyx_v_qt, __pyx_v_reverse, __pyx_v_weight);
+
+ /* "pywrapfst.pyx":3876
+ *
+ *
+ * cpdef _MutableFst rmepsilon(_Fst ifst, # <<<<<<<<<<<<<<
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_46rmepsilon(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, bool __pyx_v_connect, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_qt, bool __pyx_v_reverse, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_rmepsilon __pyx_t_2;
+ __Pyx_RefNannySetupContext("rmepsilon", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 6;
+ __pyx_t_2.connect = __pyx_v_connect;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.nstate = __pyx_v_nstate;
+ __pyx_t_2.qt = __pyx_v_qt;
+ __pyx_t_2.reverse = __pyx_v_reverse;
+ __pyx_t_2.weight = __pyx_v_weight;
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_rmepsilon(__pyx_v_ifst, 0, &__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3876, __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.rmepsilon", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3918
+ *
+ *
+ * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta, int64 nstate=fst.kNoStateId, qt=b"auto",
+ * bool reverse=False) except *:
+ */
+
+static std::vector<fst::script::WeightClass> *__pyx_f_9pywrapfst__shortestdistance(struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, struct __pyx_opt_args_9pywrapfst__shortestdistance *__pyx_optional_args) {
+ float __pyx_v_delta = __pyx_k__53;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__54;
+ PyObject *__pyx_v_qt = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3920
+ * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst,
+ * float delta=fst.kDelta, int64 nstate=fst.kNoStateId, qt=b"auto",
+ * bool reverse=False) except *: # <<<<<<<<<<<<<<
+ * cdef vector[fst.WeightClass] *distance = new vector[fst.WeightClass]()
+ * # For scoping reasons, these have to be declared here even though they may
+ */
+ bool __pyx_v_reverse = ((bool)0);
+ std::vector<fst::script::WeightClass> *__pyx_v_distance;
+ std::unique_ptr<fst::script::ShortestDistanceOptions> __pyx_v_opts;
+ std::vector<fst::script::WeightClass> *__pyx_r;
+ __Pyx_RefNannyDeclarations
+ std::vector<fst::script::WeightClass> *__pyx_t_1;
+ int __pyx_t_2;
+ std::string __pyx_t_3;
+ enum fst::QueueType __pyx_t_4;
+ __Pyx_RefNannySetupContext("_shortestdistance", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_nstate = __pyx_optional_args->nstate;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_qt = __pyx_optional_args->qt;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_reverse = __pyx_optional_args->reverse;
+ }
+ }
+ }
+ }
+ }
+
+ /* "pywrapfst.pyx":3921
+ * float delta=fst.kDelta, int64 nstate=fst.kNoStateId, qt=b"auto",
+ * bool reverse=False) except *:
+ * cdef vector[fst.WeightClass] *distance = new vector[fst.WeightClass]() # <<<<<<<<<<<<<<
+ * # For scoping reasons, these have to be declared here even though they may
+ * # not be used in all cases.
+ */
+ try {
+ __pyx_t_1 = new std::vector<fst::script::WeightClass> ();
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 3921, __pyx_L1_error)
+ }
+ __pyx_v_distance = __pyx_t_1;
+
+ /* "pywrapfst.pyx":3925
+ * # not be used in all cases.
+ * cdef unique_ptr[fst.ShortestDistanceOptions] opts
+ * if reverse: # <<<<<<<<<<<<<<
+ * # Only the simpler signature supports shortest distance to final states;
+ * # `nstate` and `qt` arguments are ignored.
+ */
+ __pyx_t_2 = (__pyx_v_reverse != 0);
+ if (__pyx_t_2) {
+
+ /* "pywrapfst.pyx":3928
+ * # Only the simpler signature supports shortest distance to final states;
+ * # `nstate` and `qt` arguments are ignored.
+ * fst.ShortestDistance(deref(ifst._fst), distance, True, delta) # <<<<<<<<<<<<<<
+ * else:
+ * opts.reset(new fst.ShortestDistanceOptions(
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3928, __pyx_L1_error)
+ }
+ fst::script::ShortestDistance((*__pyx_v_ifst->_fst), __pyx_v_distance, 1, __pyx_v_delta);
+
+ /* "pywrapfst.pyx":3925
+ * # not be used in all cases.
+ * cdef unique_ptr[fst.ShortestDistanceOptions] opts
+ * if reverse: # <<<<<<<<<<<<<<
+ * # Only the simpler signature supports shortest distance to final states;
+ * # `nstate` and `qt` arguments are ignored.
+ */
+ goto __pyx_L3;
+ }
+
+ /* "pywrapfst.pyx":3930
+ * fst.ShortestDistance(deref(ifst._fst), distance, True, delta)
+ * else:
+ * opts.reset(new fst.ShortestDistanceOptions( # <<<<<<<<<<<<<<
+ * _get_queue_type(tostring(qt)), fst.ANY_ARC_FILTER, nstate, delta))
+ * fst.ShortestDistance(deref(ifst._fst), distance, deref(opts))
+ */
+ /*else*/ {
+
+ /* "pywrapfst.pyx":3931
+ * else:
+ * opts.reset(new fst.ShortestDistanceOptions(
+ * _get_queue_type(tostring(qt)), fst.ANY_ARC_FILTER, nstate, delta)) # <<<<<<<<<<<<<<
+ * fst.ShortestDistance(deref(ifst._fst), distance, deref(opts))
+ * return distance
+ */
+ __pyx_t_3 = __pyx_f_9pywrapfst_tostring(__pyx_v_qt, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3931, __pyx_L1_error)
+ __pyx_t_4 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3931, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":3930
+ * fst.ShortestDistance(deref(ifst._fst), distance, True, delta)
+ * else:
+ * opts.reset(new fst.ShortestDistanceOptions( # <<<<<<<<<<<<<<
+ * _get_queue_type(tostring(qt)), fst.ANY_ARC_FILTER, nstate, delta))
+ * fst.ShortestDistance(deref(ifst._fst), distance, deref(opts))
+ */
+ __pyx_v_opts.reset(new fst::script::ShortestDistanceOptions(__pyx_t_4, fst::script::ANY_ARC_FILTER, __pyx_v_nstate, __pyx_v_delta));
+
+ /* "pywrapfst.pyx":3932
+ * opts.reset(new fst.ShortestDistanceOptions(
+ * _get_queue_type(tostring(qt)), fst.ANY_ARC_FILTER, nstate, delta))
+ * fst.ShortestDistance(deref(ifst._fst), distance, deref(opts)) # <<<<<<<<<<<<<<
+ * return distance
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 3932, __pyx_L1_error)
+ }
+ fst::script::ShortestDistance((*__pyx_v_ifst->_fst), __pyx_v_distance, (*__pyx_v_opts));
+ }
+ __pyx_L3:;
+
+ /* "pywrapfst.pyx":3933
+ * _get_queue_type(tostring(qt)), fst.ANY_ARC_FILTER, nstate, delta))
+ * fst.ShortestDistance(deref(ifst._fst), distance, deref(opts))
+ * return distance # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_distance;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3918
+ *
+ *
+ * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta, int64 nstate=fst.kNoStateId, qt=b"auto",
+ * bool reverse=False) except *:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_AddTraceback("pywrapfst._shortestdistance", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":3936
+ *
+ *
+ * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_49shortestdistance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_48shortestdistance[] = "\n shortestdistance(ifst, delta=0.0009765625, nstate=-1, qt=\"auto\",\n 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 (this is ignored if `reverse` is True).\n qt: A string matching a known queue type; one of: \"auto\", \"fifo\", \"lifo\",\n \"shortest\", \"state\", \"top\" (this is 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_49shortestdistance = {"shortestdistance", (PyCFunction)__pyx_pw_9pywrapfst_49shortestdistance, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_48shortestdistance};
+static PyObject *__pyx_pw_9pywrapfst_49shortestdistance(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ float __pyx_v_delta;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ PyObject *__pyx_v_qt = 0;
+ bool __pyx_v_reverse;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("shortestdistance (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nstate,&__pyx_n_s_qt,&__pyx_n_s_reverse,0};
+ PyObject* values[5] = {0,0,0,0,0};
+ values[3] = ((PyObject *)__pyx_n_b_auto);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_qt);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_reverse);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "shortestdistance") < 0)) __PYX_ERR(0, 3936, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3937, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__55;
+ }
+ if (values[2]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[2]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3938, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__56;
+ }
+ __pyx_v_qt = 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, 3940, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3940
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ * bool reverse=False): # <<<<<<<<<<<<<<
+ * """
+ * shortestdistance(ifst, delta=0.0009765625, nstate=-1, qt="auto",
+ */
+ __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, 3936, __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, 3936, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_48shortestdistance(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nstate, __pyx_v_qt, __pyx_v_reverse);
+
+ /* "pywrapfst.pyx":3936
+ *
+ *
+ * def shortestdistance(_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_48shortestdistance(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_qt, bool __pyx_v_reverse) {
+ std::unique_ptr<std::vector<fst::script::WeightClass> > __pyx_v_distance;
+ std::string __pyx_v_weight_type;
+ PyObject *__pyx_v_result = NULL;
+ std::vector<fst::script::WeightClass> ::iterator __pyx_v_it;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::vector<fst::script::WeightClass> *__pyx_t_1;
+ struct __pyx_opt_args_9pywrapfst__shortestdistance __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_t_4;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ int __pyx_t_7;
+ __Pyx_RefNannySetupContext("shortestdistance", 0);
+
+ /* "pywrapfst.pyx":3968
+ * """
+ * cdef unique_ptr[vector[fst.WeightClass]] distance
+ * distance.reset(_shortestdistance(ifst, delta, nstate, qt, reverse)) # <<<<<<<<<<<<<<
+ * # Packs the distances, as strings, into a Python list.
+ * cdef string weight_type = ifst.weight_type()
+ */
+ __pyx_t_2.__pyx_n = 4;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.nstate = __pyx_v_nstate;
+ __pyx_t_2.qt = __pyx_v_qt;
+ __pyx_t_2.reverse = __pyx_v_reverse;
+ __pyx_t_1 = __pyx_f_9pywrapfst__shortestdistance(__pyx_v_ifst, &__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L1_error)
+ __pyx_v_distance.reset(__pyx_t_1);
+
+ /* "pywrapfst.pyx":3970
+ * distance.reset(_shortestdistance(ifst, delta, nstate, qt, reverse))
+ * # Packs the distances, as strings, into a Python list.
+ * cdef string weight_type = ifst.weight_type() # <<<<<<<<<<<<<<
+ * result = []
+ * # This is just the Cython version of the normal vector iteration idiom.
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 3970, __pyx_L1_error)
+ }
+ __pyx_v_weight_type = ((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->weight_type(__pyx_v_ifst, 0);
+
+ /* "pywrapfst.pyx":3971
+ * # Packs the distances, as strings, into a Python list.
+ * cdef string weight_type = ifst.weight_type()
+ * result = [] # <<<<<<<<<<<<<<
+ * # This is just the Cython version of the normal vector iteration idiom.
+ * cdef vector[fst.WeightClass].iterator it = distance.get().begin()
+ */
+ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_v_result = ((PyObject*)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "pywrapfst.pyx":3973
+ * result = []
+ * # This is just the Cython version of the normal vector iteration idiom.
+ * cdef vector[fst.WeightClass].iterator it = distance.get().begin() # <<<<<<<<<<<<<<
+ * while it != distance.get().end():
+ * result.append(Weight(weight_type, deref(it).ToString()))
+ */
+ __pyx_v_it = __pyx_v_distance.get()->begin();
+
+ /* "pywrapfst.pyx":3974
+ * # This is just the Cython version of the normal vector iteration idiom.
+ * cdef vector[fst.WeightClass].iterator it = distance.get().begin()
+ * while it != distance.get().end(): # <<<<<<<<<<<<<<
+ * result.append(Weight(weight_type, deref(it).ToString()))
+ * inc(it)
+ */
+ while (1) {
+ __pyx_t_4 = ((__pyx_v_it != __pyx_v_distance.get()->end()) != 0);
+ if (!__pyx_t_4) break;
+
+ /* "pywrapfst.pyx":3975
+ * cdef vector[fst.WeightClass].iterator it = distance.get().begin()
+ * while it != distance.get().end():
+ * result.append(Weight(weight_type, deref(it).ToString())) # <<<<<<<<<<<<<<
+ * inc(it)
+ * return result
+ */
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_weight_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3975, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string((*__pyx_v_it).ToString()); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3975, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3975, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pywrapfst_Weight), __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3975, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_5); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 3975, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+ /* "pywrapfst.pyx":3976
+ * while it != distance.get().end():
+ * result.append(Weight(weight_type, deref(it).ToString()))
+ * inc(it) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ (++__pyx_v_it);
+ }
+
+ /* "pywrapfst.pyx":3977
+ * result.append(Weight(weight_type, deref(it).ToString()))
+ * inc(it)
+ * return result # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_result);
+ __pyx_r = __pyx_v_result;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3936
+ *
+ *
+ * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_AddTraceback("pywrapfst.shortestdistance", __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":3980
+ *
+ *
+ * cpdef _MutableFst shortestpath(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int32 nshortest=1,
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_51shortestpath(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__57;
+ __pyx_t_10basictypes_int32 __pyx_v_nshortest = ((__pyx_t_10basictypes_int32)1);
+ __pyx_t_10basictypes_int64 __pyx_v_nstate = __pyx_k__58;
+ PyObject *__pyx_v_qt = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3985
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ * bool unique=False, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ bool __pyx_v_unique = ((bool)0);
+
+ /* "pywrapfst.pyx":3986
+ * qt=b"auto",
+ * bool unique=False,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * shortestpath(ifst, delta=0.0009765625, nshortest=1, nstate=-1, qt="auto",
+ */
+ PyObject *__pyx_v_weight = ((PyObject *)Py_None);
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ std::unique_ptr<std::vector<fst::script::WeightClass> > __pyx_v_distance;
+ fst::script::WeightClass __pyx_v_wc;
+ std::unique_ptr<fst::script::ShortestPathOptions> __pyx_v_opts;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::vector<fst::script::WeightClass> *__pyx_t_1;
+ fst::script::WeightClass __pyx_t_2;
+ std::string __pyx_t_3;
+ enum fst::QueueType __pyx_t_4;
+ PyObject *__pyx_t_5 = NULL;
+ __Pyx_RefNannySetupContext("shortestpath", 0);
+ if (__pyx_optional_args) {
+ if (__pyx_optional_args->__pyx_n > 0) {
+ __pyx_v_delta = __pyx_optional_args->delta;
+ if (__pyx_optional_args->__pyx_n > 1) {
+ __pyx_v_nshortest = __pyx_optional_args->nshortest;
+ if (__pyx_optional_args->__pyx_n > 2) {
+ __pyx_v_nstate = __pyx_optional_args->nstate;
+ if (__pyx_optional_args->__pyx_n > 3) {
+ __pyx_v_qt = __pyx_optional_args->qt;
+ 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":4017
+ * An FST containing the n-shortest paths.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[vector[fst.WeightClass]] distance
+ * distance.reset(new vector[fst.WeightClass]())
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 4017, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":4019
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * cdef unique_ptr[vector[fst.WeightClass]] distance
+ * distance.reset(new vector[fst.WeightClass]()) # <<<<<<<<<<<<<<
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ */
+ try {
+ __pyx_t_1 = new std::vector<fst::script::WeightClass> ();
+ } catch(...) {
+ __Pyx_CppExn2PyErr();
+ __PYX_ERR(0, 4019, __pyx_L1_error)
+ }
+ __pyx_v_distance.reset(__pyx_t_1);
+
+ /* "pywrapfst.pyx":4021
+ * distance.reset(new vector[fst.WeightClass]())
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight) # <<<<<<<<<<<<<<
+ * cdef unique_ptr[fst.ShortestPathOptions] opts
+ * opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(qt)),
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "weight_type");
+ __PYX_ERR(0, 4021, __pyx_L1_error)
+ }
+ __pyx_t_2 = __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, 4021, __pyx_L1_error)
+ __pyx_v_wc = __pyx_t_2;
+
+ /* "pywrapfst.pyx":4023
+ * cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ * cdef unique_ptr[fst.ShortestPathOptions] opts
+ * opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(qt)), # <<<<<<<<<<<<<<
+ * nshortest, unique, False, delta,
+ * False, wc, nstate))
+ */
+ __pyx_t_3 = __pyx_f_9pywrapfst_tostring(__pyx_v_qt, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4023, __pyx_L1_error)
+ __pyx_t_4 = __pyx_f_9pywrapfst__get_queue_type(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4023, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4025
+ * opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(qt)),
+ * nshortest, unique, False, delta,
+ * False, wc, nstate)) # <<<<<<<<<<<<<<
+ * fst.ShortestPath(deref(ifst._fst), tfst, distance.get(), deref(opts))
+ * return _init_MutableFst(tfst)
+ */
+ __pyx_v_opts.reset(new fst::script::ShortestPathOptions(__pyx_t_4, __pyx_v_nshortest, __pyx_v_unique, 0, __pyx_v_delta, 0, __pyx_v_wc, __pyx_v_nstate));
+
+ /* "pywrapfst.pyx":4026
+ * nshortest, unique, False, delta,
+ * False, wc, nstate))
+ * fst.ShortestPath(deref(ifst._fst), tfst, distance.get(), deref(opts)) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 4026, __pyx_L1_error)
+ }
+ fst::script::ShortestPath((*__pyx_v_ifst->_fst), __pyx_v_tfst, __pyx_v_distance.get(), (*__pyx_v_opts));
+
+ /* "pywrapfst.pyx":4027
+ * False, wc, nstate))
+ * fst.ShortestPath(deref(ifst._fst), tfst, distance.get(), deref(opts))
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_5 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4027, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_5);
+ __pyx_t_5 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":3980
+ *
+ *
+ * cpdef _MutableFst shortestpath(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int32 nshortest=1,
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_5);
+ __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_51shortestpath(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_50shortestpath[] = "\n shortestpath(ifst, delta=0.0009765625, nshortest=1, nstate=-1, qt=\"auto\",\n 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 qt: A string matching a known queue type; one of: \"auto\", \"fifo\", \"lifo\",\n \"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_51shortestpath(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ float __pyx_v_delta;
+ __pyx_t_10basictypes_int32 __pyx_v_nshortest;
+ __pyx_t_10basictypes_int64 __pyx_v_nstate;
+ PyObject *__pyx_v_qt = 0;
+ bool __pyx_v_unique;
+ PyObject *__pyx_v_weight = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("shortestpath (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_delta,&__pyx_n_s_nshortest,&__pyx_n_s_nstate,&__pyx_n_s_qt,&__pyx_n_s_unique,&__pyx_n_s_weight,0};
+ PyObject* values[7] = {0,0,0,0,0,0,0};
+ values[4] = ((PyObject *)__pyx_n_b_auto);
+
+ /* "pywrapfst.pyx":3986
+ * qt=b"auto",
+ * bool unique=False,
+ * weight=None): # <<<<<<<<<<<<<<
+ * """
+ * shortestpath(ifst, delta=0.0009765625, nshortest=1, nstate=-1, qt="auto",
+ */
+ 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);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nshortest);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nstate);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_qt);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_unique);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_weight);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "shortestpath") < 0)) __PYX_ERR(0, 3980, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ 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, 3981, __pyx_L3_error)
+ } else {
+ __pyx_v_delta = __pyx_k__57;
+ }
+ if (values[2]) {
+ __pyx_v_nshortest = __Pyx_PyInt_As_int32_t(values[2]); if (unlikely((__pyx_v_nshortest == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3982, __pyx_L3_error)
+ } else {
+ __pyx_v_nshortest = ((__pyx_t_10basictypes_int32)1);
+ }
+ if (values[3]) {
+ __pyx_v_nstate = __Pyx_PyInt_As_int64_t(values[3]); if (unlikely((__pyx_v_nstate == ((int64_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L3_error)
+ } else {
+ __pyx_v_nstate = __pyx_k__58;
+ }
+ __pyx_v_qt = 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, 3985, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":3985
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ * bool unique=False, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ __pyx_v_unique = ((bool)0);
+ }
+ __pyx_v_weight = values[6];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("shortestpath", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3980, __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, 3980, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_50shortestpath(__pyx_self, __pyx_v_ifst, __pyx_v_delta, __pyx_v_nshortest, __pyx_v_nstate, __pyx_v_qt, __pyx_v_unique, __pyx_v_weight);
+
+ /* "pywrapfst.pyx":3980
+ *
+ *
+ * cpdef _MutableFst shortestpath(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * 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_50shortestpath(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, float __pyx_v_delta, __pyx_t_10basictypes_int32 __pyx_v_nshortest, __pyx_t_10basictypes_int64 __pyx_v_nstate, PyObject *__pyx_v_qt, bool __pyx_v_unique, PyObject *__pyx_v_weight) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst_shortestpath __pyx_t_2;
+ __Pyx_RefNannySetupContext("shortestpath", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2.__pyx_n = 6;
+ __pyx_t_2.delta = __pyx_v_delta;
+ __pyx_t_2.nshortest = __pyx_v_nshortest;
+ __pyx_t_2.nstate = __pyx_v_nstate;
+ __pyx_t_2.qt = __pyx_v_qt;
+ __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, 3980, __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":4030
+ *
+ *
+ * cpdef _Fst statemap(_Fst ifst, mt): # <<<<<<<<<<<<<<
+ * """
+ * state_map(ifst, map_type)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_53statemap(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_mt, CYTHON_UNUSED int __pyx_skip_dispatch) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ struct __pyx_opt_args_9pywrapfst__map __pyx_t_2;
+ __Pyx_RefNannySetupContext("statemap", 0);
+
+ /* "pywrapfst.pyx":4053
+ * See also: `arcmap`.
+ * """
+ * return _map(ifst, fst.kDelta, mt, None) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_2.__pyx_n = 3;
+ __pyx_t_2.delta = fst::kDelta;
+ __pyx_t_2.mt = __pyx_v_mt;
+ __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, 4053, __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":4030
+ *
+ *
+ * cpdef _Fst statemap(_Fst ifst, mt): # <<<<<<<<<<<<<<
+ * """
+ * 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_53statemap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_52statemap[] = "\n state_map(ifst, map_type)\n\n Constructively applies a transform to all states.\n\n This operation transforms each state according to the requested map type.\n Note that currently, only one state-mapping operation is supported.\n\n Args:\n ifst: The input FST.\n mt: A string matching a known mapping operation; one of: \"arc_sum\" (sum\n weights of identically-labeled multi-arcs), \"arc_unique\" (deletes\n non-unique identically-labeled multi-arcs).\n\n Returns:\n An FST with states remapped.\n\n Raises:\n FstArgError: Unknown map type.\n\n See also: `arcmap`.\n ";
+static PyObject *__pyx_pw_9pywrapfst_53statemap(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ PyObject *__pyx_v_mt = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("statemap (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ifst,&__pyx_n_s_mt,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);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mt)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("statemap", 1, 2, 2, 1); __PYX_ERR(0, 4030, __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, 4030, __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_mt = 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, 4030, __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, 4030, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_52statemap(__pyx_self, __pyx_v_ifst, __pyx_v_mt);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_52statemap(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, PyObject *__pyx_v_mt) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("statemap", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_statemap(__pyx_v_ifst, __pyx_v_mt, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4030, __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":4056
+ *
+ *
+ * cpdef _MutableFst synchronize(_Fst ifst): # <<<<<<<<<<<<<<
+ * """
+ * synchronize(ifst)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_55synchronize(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) {
+ __pyx_t_9pywrapfst_VectorFstClass_ptr __pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("synchronize", 0);
+
+ /* "pywrapfst.pyx":4075
+ * An equivalent synchronized FST.
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type()) # <<<<<<<<<<<<<<
+ * fst.Synchronize(deref(ifst._fst), tfst)
+ * return _init_MutableFst(tfst)
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "arc_type");
+ __PYX_ERR(0, 4075, __pyx_L1_error)
+ }
+ __pyx_v_tfst = new fst::script::VectorFstClass(((struct __pyx_vtabstruct_9pywrapfst__Fst *)__pyx_v_ifst->__pyx_vtab)->arc_type(__pyx_v_ifst, 0));
+
+ /* "pywrapfst.pyx":4076
+ * """
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.Synchronize(deref(ifst._fst), tfst) # <<<<<<<<<<<<<<
+ * return _init_MutableFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 4076, __pyx_L1_error)
+ }
+ fst::script::Synchronize((*__pyx_v_ifst->_fst), __pyx_v_tfst);
+
+ /* "pywrapfst.pyx":4077
+ * cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ * fst.Synchronize(deref(ifst._fst), tfst)
+ * return _init_MutableFst(tfst) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_MutableFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4077, __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":4056
+ *
+ *
+ * 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_55synchronize(PyObject *__pyx_self, PyObject *__pyx_v_ifst); /*proto*/
+static char __pyx_doc_9pywrapfst_54synchronize[] = "\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_55synchronize(PyObject *__pyx_self, PyObject *__pyx_v_ifst) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("synchronize (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ifst), __pyx_ptype_9pywrapfst__Fst, 1, "ifst", 0))) __PYX_ERR(0, 4056, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_54synchronize(__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_54synchronize(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("synchronize", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_synchronize(__pyx_v_ifst, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4056, __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":4134
+ * """
+ *
+ * def __cinit__(self, # <<<<<<<<<<<<<<
+ * string fst_type=b"vector",
+ * string arc_type=b"standard",
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_8Compiler_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_8Compiler_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ std::string __pyx_v_fst_type;
+ std::string __pyx_v_arc_type;
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_isymbols = 0;
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_osymbols = 0;
+ struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols = 0;
+ bool __pyx_v_acceptor;
+ bool __pyx_v_keep_isymbols;
+ bool __pyx_v_keep_osymbols;
+ bool __pyx_v_keep_state_numbering;
+ bool __pyx_v_allow_negative_labels;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fst_type,&__pyx_n_s_arc_type,&__pyx_n_s_isymbols,&__pyx_n_s_osymbols,&__pyx_n_s_ssymbols,&__pyx_n_s_acceptor,&__pyx_n_s_keep_isymbols,&__pyx_n_s_keep_osymbols,&__pyx_n_s_keep_state_numbering,&__pyx_n_s_allow_negative_labels,0};
+ PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
+
+ /* "pywrapfst.pyx":4137
+ * string fst_type=b"vector",
+ * string arc_type=b"standard",
+ * SymbolTable isymbols=None, # <<<<<<<<<<<<<<
+ * SymbolTable osymbols=None,
+ * SymbolTable ssymbols=None,
+ */
+ values[2] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":4138
+ * string arc_type=b"standard",
+ * SymbolTable isymbols=None,
+ * SymbolTable osymbols=None, # <<<<<<<<<<<<<<
+ * SymbolTable ssymbols=None,
+ * bool acceptor=False,
+ */
+ values[3] = (PyObject *)((struct __pyx_obj_9pywrapfst_SymbolTable *)Py_None);
+
+ /* "pywrapfst.pyx":4139
+ * 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);
+ case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+ case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fst_type);
+ if (value) { values[0] = value; kw_args--; }
+ }
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_isymbols);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osymbols);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ssymbols);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acceptor);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ case 6:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_keep_isymbols);
+ if (value) { values[6] = value; kw_args--; }
+ }
+ case 7:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_keep_osymbols);
+ if (value) { values[7] = value; kw_args--; }
+ }
+ case 8:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_keep_state_numbering);
+ if (value) { values[8] = value; kw_args--; }
+ }
+ case 9:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_allow_negative_labels);
+ if (value) { values[9] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(0, 4134, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
+ case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
+ case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+ case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ if (values[0]) {
+ __pyx_v_fst_type = __pyx_convert_string_from_py_std__in_string(values[0]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4135, __pyx_L3_error)
+ } else {
+ __pyx_v_fst_type = __pyx_k__59;
+ }
+ if (values[1]) {
+ __pyx_v_arc_type = __pyx_convert_string_from_py_std__in_string(values[1]); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4136, __pyx_L3_error)
+ } else {
+ __pyx_v_arc_type = __pyx_k__60;
+ }
+ __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, 4140, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":4140
+ * 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, 4141, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":4141
+ * 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, 4142, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":4142
+ * 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, 4143, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":4143
+ * 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, 4144, __pyx_L3_error)
+ } else {
+
+ /* "pywrapfst.pyx":4144
+ * 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, 4134, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.Compiler.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return -1;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_isymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "isymbols", 0))) __PYX_ERR(0, 4137, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_osymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "osymbols", 0))) __PYX_ERR(0, 4138, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_ssymbols), __pyx_ptype_9pywrapfst_SymbolTable, 1, "ssymbols", 0))) __PYX_ERR(0, 4139, __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":4134
+ * """
+ *
+ * def __cinit__(self, # <<<<<<<<<<<<<<
+ * string fst_type=b"vector",
+ * string arc_type=b"standard",
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_8Compiler___cinit__(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, std::string __pyx_v_fst_type, std::string __pyx_v_arc_type, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_isymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_osymbols, struct __pyx_obj_9pywrapfst_SymbolTable *__pyx_v_ssymbols, bool __pyx_v_acceptor, bool __pyx_v_keep_isymbols, bool __pyx_v_keep_osymbols, bool __pyx_v_keep_state_numbering, bool __pyx_v_allow_negative_labels) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ std::string __pyx_t_2;
+ int __pyx_t_3;
+ int __pyx_t_4;
+ fst::SymbolTable *__pyx_t_5;
+ __Pyx_RefNannySetupContext("__cinit__", 0);
+
+ /* "pywrapfst.pyx":4145
+ * 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 '%s'", "_sstrm");
+ __PYX_ERR(0, 4145, __pyx_L1_error)
+ }
+ __pyx_v_self->_sstrm.reset(new std::stringstream());
+
+ /* "pywrapfst.pyx":4146
+ * bool allow_negative_labels=False):
+ * self._sstrm.reset(new stringstream())
+ * self._fst_type = tostring(fst_type) # <<<<<<<<<<<<<<
+ * self._arc_type = tostring(arc_type)
+ * self._isymbols = NULL
+ */
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_fst_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4146, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_t_1, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4146, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst_type");
+ __PYX_ERR(0, 4146, __pyx_L1_error)
+ }
+ __pyx_v_self->_fst_type = __pyx_t_2;
+
+ /* "pywrapfst.pyx":4147
+ * self._sstrm.reset(new stringstream())
+ * self._fst_type = tostring(fst_type)
+ * self._arc_type = tostring(arc_type) # <<<<<<<<<<<<<<
+ * self._isymbols = NULL
+ * if isymbols is not None:
+ */
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_t_1, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4147, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc_type");
+ __PYX_ERR(0, 4147, __pyx_L1_error)
+ }
+ __pyx_v_self->_arc_type = __pyx_t_2;
+
+ /* "pywrapfst.pyx":4148
+ * self._fst_type = tostring(fst_type)
+ * self._arc_type = tostring(arc_type)
+ * self._isymbols = NULL # <<<<<<<<<<<<<<
+ * if isymbols is not None:
+ * self._isymbols = isymbols._table
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_isymbols");
+ __PYX_ERR(0, 4148, __pyx_L1_error)
+ }
+ __pyx_v_self->_isymbols = NULL;
+
+ /* "pywrapfst.pyx":4149
+ * self._arc_type = tostring(arc_type)
+ * self._isymbols = NULL
+ * if isymbols is not None: # <<<<<<<<<<<<<<
+ * self._isymbols = isymbols._table
+ * self._osymbols = NULL
+ */
+ __pyx_t_3 = (((PyObject *)__pyx_v_isymbols) != Py_None);
+ __pyx_t_4 = (__pyx_t_3 != 0);
+ if (__pyx_t_4) {
+
+ /* "pywrapfst.pyx":4150
+ * self._isymbols = NULL
+ * if isymbols is not None:
+ * self._isymbols = isymbols._table # <<<<<<<<<<<<<<
+ * self._osymbols = NULL
+ * if osymbols is not None:
+ */
+ if (unlikely(((PyObject *)__pyx_v_isymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 4150, __pyx_L1_error)
+ }
+ __pyx_t_5 = __pyx_v_isymbols->__pyx_base.__pyx_base._table;
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_isymbols");
+ __PYX_ERR(0, 4150, __pyx_L1_error)
+ }
+ __pyx_v_self->_isymbols = __pyx_t_5;
+
+ /* "pywrapfst.pyx":4149
+ * self._arc_type = tostring(arc_type)
+ * self._isymbols = NULL
+ * if isymbols is not None: # <<<<<<<<<<<<<<
+ * self._isymbols = isymbols._table
+ * self._osymbols = NULL
+ */
+ }
+
+ /* "pywrapfst.pyx":4151
+ * if isymbols is not None:
+ * self._isymbols = isymbols._table
+ * self._osymbols = NULL # <<<<<<<<<<<<<<
+ * if osymbols is not None:
+ * self._osymbols = osymbols._table
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_osymbols");
+ __PYX_ERR(0, 4151, __pyx_L1_error)
+ }
+ __pyx_v_self->_osymbols = NULL;
+
+ /* "pywrapfst.pyx":4152
+ * self._isymbols = isymbols._table
+ * self._osymbols = NULL
+ * if osymbols is not None: # <<<<<<<<<<<<<<
+ * self._osymbols = osymbols._table
+ * self._ssymbols = NULL
+ */
+ __pyx_t_4 = (((PyObject *)__pyx_v_osymbols) != Py_None);
+ __pyx_t_3 = (__pyx_t_4 != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":4153
+ * self._osymbols = NULL
+ * if osymbols is not None:
+ * self._osymbols = osymbols._table # <<<<<<<<<<<<<<
+ * self._ssymbols = NULL
+ * if ssymbols is not None:
+ */
+ if (unlikely(((PyObject *)__pyx_v_osymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 4153, __pyx_L1_error)
+ }
+ __pyx_t_5 = __pyx_v_osymbols->__pyx_base.__pyx_base._table;
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_osymbols");
+ __PYX_ERR(0, 4153, __pyx_L1_error)
+ }
+ __pyx_v_self->_osymbols = __pyx_t_5;
+
+ /* "pywrapfst.pyx":4152
+ * self._isymbols = isymbols._table
+ * self._osymbols = NULL
+ * if osymbols is not None: # <<<<<<<<<<<<<<
+ * self._osymbols = osymbols._table
+ * self._ssymbols = NULL
+ */
+ }
+
+ /* "pywrapfst.pyx":4154
+ * if osymbols is not None:
+ * self._osymbols = osymbols._table
+ * self._ssymbols = NULL # <<<<<<<<<<<<<<
+ * if ssymbols is not None:
+ * self._ssymbols = ssymbols._table
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_ssymbols");
+ __PYX_ERR(0, 4154, __pyx_L1_error)
+ }
+ __pyx_v_self->_ssymbols = NULL;
+
+ /* "pywrapfst.pyx":4155
+ * self._osymbols = osymbols._table
+ * self._ssymbols = NULL
+ * if ssymbols is not None: # <<<<<<<<<<<<<<
+ * self._ssymbols = ssymbols._table
+ * self._acceptor = acceptor
+ */
+ __pyx_t_3 = (((PyObject *)__pyx_v_ssymbols) != Py_None);
+ __pyx_t_4 = (__pyx_t_3 != 0);
+ if (__pyx_t_4) {
+
+ /* "pywrapfst.pyx":4156
+ * self._ssymbols = NULL
+ * if ssymbols is not None:
+ * self._ssymbols = ssymbols._table # <<<<<<<<<<<<<<
+ * self._acceptor = acceptor
+ * self._keep_isymbols = keep_isymbols
+ */
+ if (unlikely(((PyObject *)__pyx_v_ssymbols) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_table");
+ __PYX_ERR(0, 4156, __pyx_L1_error)
+ }
+ __pyx_t_5 = __pyx_v_ssymbols->__pyx_base.__pyx_base._table;
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_ssymbols");
+ __PYX_ERR(0, 4156, __pyx_L1_error)
+ }
+ __pyx_v_self->_ssymbols = __pyx_t_5;
+
+ /* "pywrapfst.pyx":4155
+ * self._osymbols = osymbols._table
+ * self._ssymbols = NULL
+ * if ssymbols is not None: # <<<<<<<<<<<<<<
+ * self._ssymbols = ssymbols._table
+ * self._acceptor = acceptor
+ */
+ }
+
+ /* "pywrapfst.pyx":4157
+ * if ssymbols is not None:
+ * self._ssymbols = ssymbols._table
+ * self._acceptor = acceptor # <<<<<<<<<<<<<<
+ * self._keep_isymbols = keep_isymbols
+ * self._keep_osymbols = keep_osymbols
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_acceptor");
+ __PYX_ERR(0, 4157, __pyx_L1_error)
+ }
+ __pyx_v_self->_acceptor = __pyx_v_acceptor;
+
+ /* "pywrapfst.pyx":4158
+ * self._ssymbols = ssymbols._table
+ * self._acceptor = acceptor
+ * self._keep_isymbols = keep_isymbols # <<<<<<<<<<<<<<
+ * self._keep_osymbols = keep_osymbols
+ * self._keep_state_numbering = keep_state_numbering
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_keep_isymbols");
+ __PYX_ERR(0, 4158, __pyx_L1_error)
+ }
+ __pyx_v_self->_keep_isymbols = __pyx_v_keep_isymbols;
+
+ /* "pywrapfst.pyx":4159
+ * 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 '%s'", "_keep_osymbols");
+ __PYX_ERR(0, 4159, __pyx_L1_error)
+ }
+ __pyx_v_self->_keep_osymbols = __pyx_v_keep_osymbols;
+
+ /* "pywrapfst.pyx":4160
+ * 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 '%s'", "_keep_state_numbering");
+ __PYX_ERR(0, 4160, __pyx_L1_error)
+ }
+ __pyx_v_self->_keep_state_numbering = __pyx_v_keep_state_numbering;
+
+ /* "pywrapfst.pyx":4161
+ * 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 '%s'", "_allow_negative_labels");
+ __PYX_ERR(0, 4161, __pyx_L1_error)
+ }
+ __pyx_v_self->_allow_negative_labels = __pyx_v_allow_negative_labels;
+
+ /* "pywrapfst.pyx":4134
+ * """
+ *
+ * def __cinit__(self, # <<<<<<<<<<<<<<
+ * string fst_type=b"vector",
+ * string arc_type=b"standard",
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst.Compiler.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4163
+ * 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) {
+ fst::script::FstClass *__pyx_v_tfst;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ int __pyx_t_6;
+ __Pyx_RefNannySetupContext("compile", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_compile); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4163, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_3compile)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4163, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4163, __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, 4163, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4177
+ * FstOpError: Compilation failed.
+ * """
+ * cdef fst.FstClass *tfst = fst.CompileFstInternal(deref(self._sstrm), # <<<<<<<<<<<<<<
+ * "<pywrapfst>", self._fst_type, self._arc_type, self._isymbols,
+ * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols,
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_sstrm");
+ __PYX_ERR(0, 4177, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":4178
+ * """
+ * cdef fst.FstClass *tfst = fst.CompileFstInternal(deref(self._sstrm),
+ * "<pywrapfst>", self._fst_type, self._arc_type, self._isymbols, # <<<<<<<<<<<<<<
+ * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols,
+ * self._keep_osymbols, self._keep_state_numbering,
+ */
+ __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_kp_b_pywrapfst); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4178, __pyx_L1_error)
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst_type");
+ __PYX_ERR(0, 4178, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_arc_type");
+ __PYX_ERR(0, 4178, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_isymbols");
+ __PYX_ERR(0, 4178, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":4179
+ * cdef fst.FstClass *tfst = fst.CompileFstInternal(deref(self._sstrm),
+ * "<pywrapfst>", self._fst_type, self._arc_type, self._isymbols,
+ * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols, # <<<<<<<<<<<<<<
+ * self._keep_osymbols, self._keep_state_numbering,
+ * self._allow_negative_labels)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_osymbols");
+ __PYX_ERR(0, 4179, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_ssymbols");
+ __PYX_ERR(0, 4179, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_acceptor");
+ __PYX_ERR(0, 4179, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_keep_isymbols");
+ __PYX_ERR(0, 4179, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":4180
+ * "<pywrapfst>", self._fst_type, self._arc_type, self._isymbols,
+ * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols,
+ * self._keep_osymbols, self._keep_state_numbering, # <<<<<<<<<<<<<<
+ * self._allow_negative_labels)
+ * self._sstrm.reset(new stringstream())
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_keep_osymbols");
+ __PYX_ERR(0, 4180, __pyx_L1_error)
+ }
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_keep_state_numbering");
+ __PYX_ERR(0, 4180, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":4181
+ * 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 == NULL:
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_allow_negative_labels");
+ __PYX_ERR(0, 4181, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":4177
+ * FstOpError: Compilation failed.
+ * """
+ * cdef fst.FstClass *tfst = fst.CompileFstInternal(deref(self._sstrm), # <<<<<<<<<<<<<<
+ * "<pywrapfst>", self._fst_type, self._arc_type, self._isymbols,
+ * self._osymbols, self._ssymbols, self._acceptor, self._keep_isymbols,
+ */
+ __pyx_v_tfst = fst::script::CompileFstInternal((*__pyx_v_self->_sstrm), __pyx_t_5, __pyx_v_self->_fst_type, __pyx_v_self->_arc_type, __pyx_v_self->_isymbols, __pyx_v_self->_osymbols, __pyx_v_self->_ssymbols, __pyx_v_self->_acceptor, __pyx_v_self->_keep_isymbols, __pyx_v_self->_keep_osymbols, __pyx_v_self->_keep_state_numbering, __pyx_v_self->_allow_negative_labels);
+
+ /* "pywrapfst.pyx":4182
+ * self._keep_osymbols, self._keep_state_numbering,
+ * self._allow_negative_labels)
+ * self._sstrm.reset(new stringstream()) # <<<<<<<<<<<<<<
+ * if tfst == NULL:
+ * raise FstOpError("Compilation failed")
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_sstrm");
+ __PYX_ERR(0, 4182, __pyx_L1_error)
+ }
+ __pyx_v_self->_sstrm.reset(new std::stringstream());
+
+ /* "pywrapfst.pyx":4183
+ * self._allow_negative_labels)
+ * self._sstrm.reset(new stringstream())
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Compilation failed")
+ * return _init_XFst(tfst)
+ */
+ __pyx_t_6 = ((__pyx_v_tfst == NULL) != 0);
+ if (__pyx_t_6) {
+
+ /* "pywrapfst.pyx":4184
+ * self._sstrm.reset(new stringstream())
+ * if tfst == NULL:
+ * raise FstOpError("Compilation failed") # <<<<<<<<<<<<<<
+ * return _init_XFst(tfst)
+ *
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 4184, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4183
+ * self._allow_negative_labels)
+ * self._sstrm.reset(new stringstream())
+ * if tfst == NULL: # <<<<<<<<<<<<<<
+ * raise FstOpError("Compilation failed")
+ * return _init_XFst(tfst)
+ */
+ }
+
+ /* "pywrapfst.pyx":4185
+ * if tfst == NULL:
+ * raise FstOpError("Compilation failed")
+ * return _init_XFst(tfst) # <<<<<<<<<<<<<<
+ *
+ * cpdef void write(self, expression):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_2 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4185, __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":4163
+ * self._allow_negative_labels = allow_negative_labels
+ *
+ * cpdef _Fst compile(self): # <<<<<<<<<<<<<<
+ * """
+ * compile()
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("pywrapfst.Compiler.compile", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF((PyObject *)__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_8Compiler_3compile(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_8Compiler_2compile[] = "\n compile()\n\n Compiles the FST in the compiler string buffer.\n\n This method compiles the FST and returns the resulting machine.\n\n Returns:\n The FST described by the compiler string buffer.\n\n Raises:\n FstOpError: Compilation failed.\n ";
+static PyObject *__pyx_pw_9pywrapfst_8Compiler_3compile(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("compile (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_8Compiler_2compile(((struct __pyx_obj_9pywrapfst_Compiler *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_8Compiler_2compile(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("compile", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_8Compiler_compile(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4163, __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":4187
+ * return _init_XFst(tfst)
+ *
+ * cpdef void write(self, expression): # <<<<<<<<<<<<<<
+ * """
+ * write(expression)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_8Compiler_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_expression); /*proto*/
+static void __pyx_f_9pywrapfst_8Compiler_write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ std::string __pyx_t_6;
+ __Pyx_RefNannySetupContext("write", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_write); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4187, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_8Compiler_5write)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_expression); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4187, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_expression};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4187, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_expression};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4187, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4187, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_expression);
+ __Pyx_GIVEREF(__pyx_v_expression);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_expression);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4187, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4203
+ * expression: A string expression to add to compiler string buffer.
+ * """
+ * deref(self._sstrm) << tostring(expression) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_sstrm");
+ __PYX_ERR(0, 4203, __pyx_L1_error)
+ }
+ __pyx_t_6 = __pyx_f_9pywrapfst_tostring(__pyx_v_expression, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4203, __pyx_L1_error)
+ ((*__pyx_v_self->_sstrm) << __pyx_t_6);
+
+ /* "pywrapfst.pyx":4187
+ * return _init_XFst(tfst)
+ *
+ * cpdef void write(self, expression): # <<<<<<<<<<<<<<
+ * """
+ * write(expression)
+ */
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_WriteUnraisable("pywrapfst.Compiler.write", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_8Compiler_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_expression); /*proto*/
+static char __pyx_doc_9pywrapfst_8Compiler_4write[] = "\n write(expression)\n\n Writes a string into the compiler string buffer.\n\n This method adds a line to the compiler string buffer. It is normally\n invoked using the right shift operator, like so:\n\n compiler = fst.Compiler()\n print >> compiler, \"0 0 49 49\"\n print >> compiler, \"0\"\n\n Args:\n expression: A string expression to add to compiler string buffer.\n ";
+static PyObject *__pyx_pw_9pywrapfst_8Compiler_5write(PyObject *__pyx_v_self, PyObject *__pyx_v_expression) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("write (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_8Compiler_4write(((struct __pyx_obj_9pywrapfst_Compiler *)__pyx_v_self), ((PyObject *)__pyx_v_expression));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_8Compiler_4write(struct __pyx_obj_9pywrapfst_Compiler *__pyx_v_self, PyObject *__pyx_v_expression) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("write", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_8Compiler_write(__pyx_v_self, __pyx_v_expression, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4187, __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;
+}
+
+/* "pywrapfst.pyx":4228
+ * """
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_9FarReader_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_9FarReader_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+ if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1;
+ __pyx_r = __pyx_pf_9pywrapfst_9FarReader___init__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_9FarReader___init__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":4229
+ *
+ * def __init__(self):
+ * raise FstDeletedConstructorError( # <<<<<<<<<<<<<<
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4229, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":4230
+ * def __init__(self):
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<<
+ *
+ * def __repr__(self):
+ */
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4230, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4229, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4229, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4229, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4229, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4229, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 4229, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4228
+ * """
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst.FarReader.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4232
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_3__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_9FarReader_2__repr__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_2__repr__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":4233
+ *
+ * def __repr__(self):
+ * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self)) # <<<<<<<<<<<<<<
+ *
+ * @classmethod
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_FarReader_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4233, __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 '%s'", "far_type");
+ __PYX_ERR(0, 4233, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->far_type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4233, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4233, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4233, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4233, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4233, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4233, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_4) {
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4233, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4232
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst.FarReader.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4236
+ *
+ * @classmethod
+ * def open(cls, *filenames): # <<<<<<<<<<<<<<
+ * """
+ * FarReader.open(*filenames)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_5open(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_4open[] = "\n FarReader.open(*filenames)\n\n Creates a FarReader object.\n\n This class method creates a FarReader given the string location of one or\n more FAR files on disk.\n\n Args:\n *filenames: The string location of one or more input FAR files.\n\n Returns:\n A new FarReader instance.\n\n Raises:\n FstIOError: Read failed.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_5open(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_filenames = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("open (wrapper)", 0);
+ if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "open", 0))) return NULL;
+ __Pyx_INCREF(__pyx_args);
+ __pyx_v_filenames = __pyx_args;
+ __pyx_r = __pyx_pf_9pywrapfst_9FarReader_4open(((PyTypeObject*)__pyx_v_cls), __pyx_v_filenames);
+
+ /* function exit code */
+ __Pyx_XDECREF(__pyx_v_filenames);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_4open(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filenames) {
+ fst::script::FarReaderClass *__pyx_v_tfar;
+ struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_result = 0;
+ PyObject *__pyx_v_filename = NULL;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ std::vector<std::string> __pyx_t_6;
+ int __pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ PyObject *__pyx_t_10 = NULL;
+ __Pyx_RefNannySetupContext("open", 0);
+ __Pyx_INCREF(__pyx_v_filenames);
+
+ /* "pywrapfst.pyx":4254
+ * FstIOError: Read failed.
+ * """
+ * filenames = [tostring(filename) for filename in filenames] # <<<<<<<<<<<<<<
+ * cdef fst.FarReaderClass *tfar = fst.FarReaderClass.Open(filenames)
+ * if tfar == NULL:
+ */
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4254, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __pyx_v_filenames; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+ for (;;) {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 4254, __pyx_L1_error)
+ #else
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4254, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ #endif
+ __Pyx_XDECREF_SET(__pyx_v_filename, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_5 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4254, __pyx_L1_error)
+ __pyx_t_4 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4254, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 4254, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF_SET(__pyx_v_filenames, __pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":4255
+ * """
+ * filenames = [tostring(filename) for filename in filenames]
+ * cdef fst.FarReaderClass *tfar = fst.FarReaderClass.Open(filenames) # <<<<<<<<<<<<<<
+ * if tfar == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filenames))
+ */
+ __pyx_t_6 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_v_filenames); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4255, __pyx_L1_error)
+ __pyx_v_tfar = fst::script::FarReaderClass::Open(__pyx_t_6);
+
+ /* "pywrapfst.pyx":4256
+ * filenames = [tostring(filename) for filename in filenames]
+ * cdef fst.FarReaderClass *tfar = fst.FarReaderClass.Open(filenames)
+ * if tfar == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filenames))
+ * cdef FarReader result = FarReader.__new__(FarReader)
+ */
+ __pyx_t_7 = ((__pyx_v_tfar == NULL) != 0);
+ if (__pyx_t_7) {
+
+ /* "pywrapfst.pyx":4257
+ * cdef fst.FarReaderClass *tfar = fst.FarReaderClass.Open(filenames)
+ * if tfar == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filenames)) # <<<<<<<<<<<<<<
+ * cdef FarReader result = FarReader.__new__(FarReader)
+ * result._reader.reset(tfar)
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Read_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_9 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+ __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
+ if (likely(__pyx_t_9)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+ __Pyx_INCREF(__pyx_t_9);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_8, function);
+ }
+ }
+ if (!__pyx_t_9) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_filenames); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_8)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_filenames};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_filenames};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else
+ #endif
+ {
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL;
+ __Pyx_INCREF(__pyx_v_filenames);
+ __Pyx_GIVEREF(__pyx_v_filenames);
+ PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_filenames);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_t_8 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_8)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_8) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_4};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_10);
+ __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4257, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 4257, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4256
+ * filenames = [tostring(filename) for filename in filenames]
+ * cdef fst.FarReaderClass *tfar = fst.FarReaderClass.Open(filenames)
+ * if tfar == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Read failed: {!r}".format(filenames))
+ * cdef FarReader result = FarReader.__new__(FarReader)
+ */
+ }
+
+ /* "pywrapfst.pyx":4258
+ * if tfar == NULL:
+ * raise FstIOError("Read failed: {!r}".format(filenames))
+ * cdef FarReader result = FarReader.__new__(FarReader) # <<<<<<<<<<<<<<
+ * result._reader.reset(tfar)
+ * return result
+ */
+ __pyx_t_1 = __pyx_tp_new_9pywrapfst_FarReader(((PyTypeObject *)__pyx_ptype_9pywrapfst_FarReader), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4258, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pywrapfst_FarReader)))) __PYX_ERR(0, 4258, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":4259
+ * raise FstIOError("Read failed: {!r}".format(filenames))
+ * cdef FarReader result = FarReader.__new__(FarReader)
+ * result._reader.reset(tfar) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_reader");
+ __PYX_ERR(0, 4259, __pyx_L1_error)
+ }
+ __pyx_v_result->_reader.reset(__pyx_v_tfar);
+
+ /* "pywrapfst.pyx":4260
+ * cdef FarReader result = FarReader.__new__(FarReader)
+ * result._reader.reset(tfar)
+ * return result # <<<<<<<<<<<<<<
+ *
+ * # This just registers this class as a possible iterator.
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4236
+ *
+ * @classmethod
+ * def open(cls, *filenames): # <<<<<<<<<<<<<<
+ * """
+ * FarReader.open(*filenames)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_XDECREF(__pyx_t_10);
+ __Pyx_AddTraceback("pywrapfst.FarReader.open", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_filenames);
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XDECREF(__pyx_v_filename);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4263
+ *
+ * # This just registers this class as a possible iterator.
+ * def __iter__(self): # <<<<<<<<<<<<<<
+ * return self
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_7__iter__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_7__iter__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_9FarReader_6__iter__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_6__iter__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__iter__", 0);
+
+ /* "pywrapfst.pyx":4264
+ * # 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":4263
+ *
+ * # 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":4267
+ *
+ * # 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_9FarReader_9__next__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_9__next__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__next__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_9FarReader_8__next__(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_8__next__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ std::string __pyx_v_k;
+ struct __pyx_obj_9pywrapfst__MutableFst *__pyx_v_f = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("__next__", 0);
+
+ /* "pywrapfst.pyx":4268
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self):
+ * if self.done(): # <<<<<<<<<<<<<<
+ * raise StopIteration
+ * cdef string k = self.get_key()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "done");
+ __PYX_ERR(0, 4268, __pyx_L1_error)
+ }
+ __pyx_t_1 = (((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->done(__pyx_v_self, 0) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":4269
+ * def __next__(self):
+ * if self.done():
+ * raise StopIteration # <<<<<<<<<<<<<<
+ * cdef string k = self.get_key()
+ * cdef _MutableFst f = self.get_fst()
+ */
+ __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0);
+ __PYX_ERR(0, 4269, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4268
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self):
+ * if self.done(): # <<<<<<<<<<<<<<
+ * raise StopIteration
+ * cdef string k = self.get_key()
+ */
+ }
+
+ /* "pywrapfst.pyx":4270
+ * if self.done():
+ * raise StopIteration
+ * cdef string k = self.get_key() # <<<<<<<<<<<<<<
+ * cdef _MutableFst f = self.get_fst()
+ * self.next()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "get_key");
+ __PYX_ERR(0, 4270, __pyx_L1_error)
+ }
+ __pyx_v_k = ((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->get_key(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":4271
+ * raise StopIteration
+ * cdef string k = self.get_key()
+ * cdef _MutableFst f = self.get_fst() # <<<<<<<<<<<<<<
+ * self.next()
+ * return (k, f)
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "get_fst");
+ __PYX_ERR(0, 4271, __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, 4271, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pywrapfst__MutableFst))))) __PYX_ERR(0, 4271, __pyx_L1_error)
+ __pyx_v_f = ((struct __pyx_obj_9pywrapfst__MutableFst *)__pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":4272
+ * cdef string k = self.get_key()
+ * cdef _MutableFst f = self.get_fst()
+ * self.next() # <<<<<<<<<<<<<<
+ * return (k, f)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "next");
+ __PYX_ERR(0, 4272, __pyx_L1_error)
+ }
+ ((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->next(__pyx_v_self, 0);
+
+ /* "pywrapfst.pyx":4273
+ * cdef _MutableFst f = self.get_fst()
+ * self.next()
+ * return (k, f) # <<<<<<<<<<<<<<
+ *
+ * cpdef string arc_type(self):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4273, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4273, __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_f));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_f));
+ PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_f));
+ __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4267
+ *
+ * # Magic method used to get a Pythonic API out of the C++ API.
+ * def __next__(self): # <<<<<<<<<<<<<<
+ * if self.done():
+ * raise StopIteration
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_AddTraceback("pywrapfst.FarReader.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_f);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4275
+ * return (k, f)
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._reader.get().ArcType()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_11arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_9FarReader_arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4275, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_11arc_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4275, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4275, __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, 4275, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4276
+ *
+ * cpdef string arc_type(self):
+ * 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 '%s'", "_reader");
+ __PYX_ERR(0, 4276, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_reader.get()->ArcType();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4275
+ * return (k, f)
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._reader.get().ArcType()
+ *
+ */
+
+ /* 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_11arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_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_9FarReader_10arc_type(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_10arc_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4275, __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":4278
+ * return self._reader.get().ArcType()
+ *
+ * cpdef bool done(self): # <<<<<<<<<<<<<<
+ * """
+ * done(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_13done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_9FarReader_done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("done", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_done); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4278, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_13done)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4278, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4278, __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, 4278, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4290
+ * 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 '%s'", "_reader");
+ __PYX_ERR(0, 4290, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_reader.get()->Done();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4278
+ * 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_13done(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_12done[] = "\n done(self)\n\n Indicates whether the iterator is exhausted or not.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n True if the iterator is exhausted, False otherwise.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_13done(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_12done(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_12done(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("done", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_9FarReader_done(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4278, __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":4292
+ * return self._reader.get().Done()
+ *
+ * cpdef bool error(self): # <<<<<<<<<<<<<<
+ * """
+ * error(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_15error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_9FarReader_error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("error", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4292, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_15error)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4292, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4292, __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, 4292, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4301
+ * 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 '%s'", "_reader");
+ __PYX_ERR(0, 4301, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_reader.get()->Error();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4292
+ * 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_15error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_14error[] = "\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_15error(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_14error(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_14error(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("error", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_9FarReader_error(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4292, __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":4303
+ * return self._reader.get().Error()
+ *
+ * cpdef string far_type(self): # <<<<<<<<<<<<<<
+ * return fst.GetFarTypeString(self._reader.get().Type())
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_17far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_9FarReader_far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("far_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_far_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4303, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_17far_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4303, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4303, __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, 4303, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4304
+ *
+ * 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 '%s'", "_reader");
+ __PYX_ERR(0, 4304, __pyx_L1_error)
+ }
+ __pyx_r = fst::GetFarTypeString(__pyx_v_self->_reader.get()->Type());
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4303
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_17far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_17far_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_16far_type(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_16far_type(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("far_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_far_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4303, __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":4306
+ * return fst.GetFarTypeString(self._reader.get().Type())
+ *
+ * cpdef bool find(self, key): # <<<<<<<<<<<<<<
+ * """
+ * find(self, key)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_19find(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static bool __pyx_f_9pywrapfst_9FarReader_find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ bool __pyx_t_6;
+ std::string __pyx_t_7;
+ __Pyx_RefNannySetupContext("find", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_find); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4306, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_19find)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4306, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4306, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_key};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4306, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4306, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_INCREF(__pyx_v_key);
+ __Pyx_GIVEREF(__pyx_v_key);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_key);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4306, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4306, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_6;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4322
+ * 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 '%s'", "_reader");
+ __PYX_ERR(0, 4322, __pyx_L1_error)
+ }
+ __pyx_t_7 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4322, __pyx_L1_error)
+ __pyx_r = __pyx_v_self->_reader.get()->Find(__pyx_t_7);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4306
+ * 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_XDECREF(__pyx_t_5);
+ __Pyx_WriteUnraisable("pywrapfst.FarReader.find", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_19find(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_18find[] = "\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 This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\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_19find(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_18find(((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_18find(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __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, 4306, __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":4324
+ * return self._reader.get().Find(tostring(key))
+ *
+ * cpdef _Fst get_fst(self): # <<<<<<<<<<<<<<
+ * """
+ * get_fst(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_21get_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) {
+ fst::script::FstClass *__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;
+ __Pyx_RefNannySetupContext("get_fst", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_fst); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4324, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_21get_fst)) {
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4324, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4324, __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, 4324, __pyx_L1_error)
+ __pyx_r = ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_t_2);
+ __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4337
+ * """
+ * cdef fst.FstClass *tfst = new fst.FstClass(
+ * deref(self._reader.get().GetFstClass())) # <<<<<<<<<<<<<<
+ * return _init_XFst(tfst)
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_reader");
+ __PYX_ERR(0, 4337, __pyx_L1_error)
+ }
+
+ /* "pywrapfst.pyx":4336
+ * A copy of the FST at the current position.
+ * """
+ * cdef fst.FstClass *tfst = new fst.FstClass( # <<<<<<<<<<<<<<
+ * deref(self._reader.get().GetFstClass()))
+ * return _init_XFst(tfst)
+ */
+ __pyx_v_tfst = new fst::script::FstClass((*__pyx_v_self->_reader.get()->GetFstClass()));
+
+ /* "pywrapfst.pyx":4338
+ * cdef fst.FstClass *tfst = new fst.FstClass(
+ * deref(self._reader.get().GetFstClass()))
+ * return _init_XFst(tfst) # <<<<<<<<<<<<<<
+ *
+ * cpdef string get_key(self):
+ */
+ __Pyx_XDECREF(((PyObject *)__pyx_r));
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst__init_XFst(__pyx_v_tfst)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4338, __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":4324
+ * 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_21get_fst(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_20get_fst[] = "\n get_fst(self)\n\n Returns the FST at the current position.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n A copy of the FST at the current position.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_21get_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_20get_fst(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_20get_fst(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("get_fst", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = ((PyObject *)__pyx_f_9pywrapfst_9FarReader_get_fst(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4324, __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":4340
+ * return _init_XFst(tfst)
+ *
+ * cpdef string get_key(self): # <<<<<<<<<<<<<<
+ * """
+ * get_key(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_23get_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_9FarReader_get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("get_key", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4340, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_23get_key)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4340, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4340, __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, 4340, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4352
+ * 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 '%s'", "_reader");
+ __PYX_ERR(0, 4352, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_reader.get()->GetKey();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4340
+ * return _init_XFst(tfst)
+ *
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_23get_key(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_22get_key[] = "\n get_key(self)\n\n Returns the string key at the current position.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Returns:\n The string key at the current position.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_23get_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_22get_key(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_22get_key(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("get_key", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarReader_get_key(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4340, __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":4354
+ * return self._reader.get().GetKey()
+ *
+ * cpdef void next(self): # <<<<<<<<<<<<<<
+ * """
+ * next(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_25next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_9FarReader_next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_next); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4354, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_25next)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4354, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4354, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4363
+ * should use the Pythonic API.
+ * """
+ * 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 '%s'", "_reader");
+ __PYX_ERR(0, 4363, __pyx_L1_error)
+ }
+ __pyx_v_self->_reader.get()->Next();
+
+ /* "pywrapfst.pyx":4354
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_25next(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_24next[] = "\n next(self)\n\n Advances the iterator.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_25next(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_24next(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_24next(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("next", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_9FarReader_next(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4354, __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":4365
+ * self._reader.get().Next()
+ *
+ * cpdef void reset(self): # <<<<<<<<<<<<<<
+ * """
+ * reset(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_27reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static void __pyx_f_9pywrapfst_9FarReader_reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4365, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_27reset)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4365, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4365, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4374
+ * should use the Pythonic API.
+ * """
+ * self._reader.get().Reset() # <<<<<<<<<<<<<<
+ *
+ * # Dictionary-like access by combining `find` and `get_fst`.
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_reader");
+ __PYX_ERR(0, 4374, __pyx_L1_error)
+ }
+ __pyx_v_self->_reader.get()->Reset();
+
+ /* "pywrapfst.pyx":4365
+ * 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_27reset(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarReader_26reset[] = "\n reset(self)\n\n Resets the iterator to the initial position.\n\n This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_27reset(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_26reset(((struct __pyx_obj_9pywrapfst_FarReader *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarReader_26reset(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("reset", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_void_to_None(__pyx_f_9pywrapfst_9FarReader_reset(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4365, __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":4377
+ *
+ * # Dictionary-like access by combining `find` and `get_fst`.
+ * def __getitem__(self, key): # <<<<<<<<<<<<<<
+ * if not self.find(key):
+ * raise KeyError(key)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_29__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_9FarReader_29__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_28__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_28__getitem__(struct __pyx_obj_9pywrapfst_FarReader *__pyx_v_self, PyObject *__pyx_v_key) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ __Pyx_RefNannySetupContext("__getitem__", 0);
+
+ /* "pywrapfst.pyx":4378
+ * # Dictionary-like access by combining `find` and `get_fst`.
+ * def __getitem__(self, key):
+ * if not self.find(key): # <<<<<<<<<<<<<<
+ * raise KeyError(key)
+ * return self.get_fst()
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "find");
+ __PYX_ERR(0, 4378, __pyx_L1_error)
+ }
+ __pyx_t_1 = ((!(((struct __pyx_vtabstruct_9pywrapfst_FarReader *)__pyx_v_self->__pyx_vtab)->find(__pyx_v_self, __pyx_v_key, 0) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "pywrapfst.pyx":4379
+ * def __getitem__(self, key):
+ * if not self.find(key):
+ * raise KeyError(key) # <<<<<<<<<<<<<<
+ * return self.get_fst()
+ *
+ */
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4379, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_key);
+ __Pyx_GIVEREF(__pyx_v_key);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_key);
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4379, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(0, 4379, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4378
+ * # Dictionary-like access by combining `find` and `get_fst`.
+ * def __getitem__(self, key):
+ * if not self.find(key): # <<<<<<<<<<<<<<
+ * raise KeyError(key)
+ * return self.get_fst()
+ */
+ }
+
+ /* "pywrapfst.pyx":4380
+ * if not self.find(key):
+ * raise KeyError(key)
+ * return self.get_fst() # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "get_fst");
+ __PYX_ERR(0, 4380, __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, 4380, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_r = __pyx_t_3;
+ __pyx_t_3 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4377
+ *
+ * # Dictionary-like access by combining `find` and `get_fst`.
+ * def __getitem__(self, key): # <<<<<<<<<<<<<<
+ * if not self.find(key):
+ * raise KeyError(key)
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_2);
+ __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":4403
+ * """
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_9FarWriter_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_9pywrapfst_9FarWriter_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
+ if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+ if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1;
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter___init__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_9FarWriter___init__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__init__", 0);
+
+ /* "pywrapfst.pyx":4404
+ *
+ * def __init__(self):
+ * raise FstDeletedConstructorError( # <<<<<<<<<<<<<<
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstDeletedConstructorError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4404, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":4405
+ * def __init__(self):
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__)) # <<<<<<<<<<<<<<
+ *
+ * def __repr__(self):
+ */
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Cannot_construct, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_4, function);
+ }
+ }
+ if (!__pyx_t_5) {
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_6};
+ __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4405, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4404, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4404, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4404, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4404, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_3);
+ __pyx_t_3 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4404, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_1, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __PYX_ERR(0, 4404, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4403
+ * """
+ *
+ * def __init__(self): # <<<<<<<<<<<<<<
+ * raise FstDeletedConstructorError(
+ * "Cannot construct {}".format(self.__class__.__name__))
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst.FarWriter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4407
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self))
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_3__repr__(PyObject *__pyx_v_self) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_2__repr__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_2__repr__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ int __pyx_t_6;
+ PyObject *__pyx_t_7 = NULL;
+ __Pyx_RefNannySetupContext("__repr__", 0);
+
+ /* "pywrapfst.pyx":4408
+ *
+ * def __repr__(self):
+ * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self)) # <<<<<<<<<<<<<<
+ *
+ * @classmethod
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_FarWriter_at_0x_x, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4408, __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 '%s'", "far_type");
+ __PYX_ERR(0, 4408, __pyx_L1_error)
+ }
+ __pyx_t_3 = __pyx_convert_PyBytes_string_to_py_std__in_string(((struct __pyx_vtabstruct_9pywrapfst_FarWriter *)__pyx_v_self->__pyx_vtab)->far_type(__pyx_v_self, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4408, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4408, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_self));
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_id, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4408, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4408, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_5};
+ __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4408, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4408, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_4) {
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ }
+ __Pyx_GIVEREF(__pyx_t_3);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
+ __pyx_t_3 = 0;
+ __pyx_t_5 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4408, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4407
+ * "Cannot construct {}".format(self.__class__.__name__))
+ *
+ * def __repr__(self): # <<<<<<<<<<<<<<
+ * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self))
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_AddTraceback("pywrapfst.FarWriter.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4411
+ *
+ * @classmethod
+ * def create(cls, filename, arc_type=b"standard", far_type=b"default"): # <<<<<<<<<<<<<<
+ * """
+ * FarWriter.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_5create(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarWriter_4create[] = "\n FarWriter.\n\n Creates a FarWriter object.\n\n This class method creates a FarWriter given the desired output location,\n arc type, and FAR type.\n\n Args:\n filename: The string location for the output FAR files.\n arc_type: A string indicating the arc type.\n far_type: A string indicating the FAR type; one of: \"fst\", \"stlist\",\n \"sttable\", \"sstable\", \"default\".\n\n Returns:\n A new FarWriter instance.\n\n Raises:\n FstIOError: Read failed.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_5create(PyObject *__pyx_v_cls, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_filename = 0;
+ PyObject *__pyx_v_arc_type = 0;
+ PyObject *__pyx_v_far_type = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("create (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_arc_type,&__pyx_n_s_far_type,0};
+ PyObject* values[3] = {0,0,0};
+ values[1] = ((PyObject *)__pyx_n_b_standard);
+ values[2] = ((PyObject *)__pyx_n_b_default);
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arc_type);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_far_type);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create") < 0)) __PYX_ERR(0, 4411, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_filename = values[0];
+ __pyx_v_arc_type = values[1];
+ __pyx_v_far_type = values[2];
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("create", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4411, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("pywrapfst.FarWriter.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_4create(((PyTypeObject*)__pyx_v_cls), __pyx_v_filename, __pyx_v_arc_type, __pyx_v_far_type);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_4create(CYTHON_UNUSED PyTypeObject *__pyx_v_cls, PyObject *__pyx_v_filename, PyObject *__pyx_v_arc_type, PyObject *__pyx_v_far_type) {
+ enum fst::FarType __pyx_v_ft;
+ fst::script::FarWriterClass *__pyx_v_tfar;
+ struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_result = 0;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ std::string __pyx_t_1;
+ std::string __pyx_t_2;
+ int __pyx_t_3;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ PyObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyObject *__pyx_t_9 = NULL;
+ __Pyx_RefNannySetupContext("create", 0);
+
+ /* "pywrapfst.pyx":4432
+ * FstIOError: Read failed.
+ * """
+ * cdef fst.FarType ft = fst.GetFarType(tostring(far_type)) # <<<<<<<<<<<<<<
+ * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create(
+ * tostring(filename), tostring(arc_type), ft)
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_far_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4432, __pyx_L1_error)
+ __pyx_v_ft = fst::script::GetFarType(__pyx_t_1);
+
+ /* "pywrapfst.pyx":4434
+ * cdef fst.FarType ft = fst.GetFarType(tostring(far_type))
+ * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create(
+ * tostring(filename), tostring(arc_type), ft) # <<<<<<<<<<<<<<
+ * if tfar == NULL:
+ * raise FstIOError("Open failed: {!r}".format(filename))
+ */
+ __pyx_t_1 = __pyx_f_9pywrapfst_tostring(__pyx_v_filename, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4434, __pyx_L1_error)
+ __pyx_t_2 = __pyx_f_9pywrapfst_tostring(__pyx_v_arc_type, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4434, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4433
+ * """
+ * cdef fst.FarType ft = fst.GetFarType(tostring(far_type))
+ * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create( # <<<<<<<<<<<<<<
+ * tostring(filename), tostring(arc_type), ft)
+ * if tfar == NULL:
+ */
+ __pyx_v_tfar = fst::script::FarWriterClass::Create(__pyx_t_1, __pyx_t_2, __pyx_v_ft);
+
+ /* "pywrapfst.pyx":4435
+ * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create(
+ * tostring(filename), tostring(arc_type), ft)
+ * if tfar == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Open failed: {!r}".format(filename))
+ * cdef FarWriter result = FarWriter.__new__(FarWriter)
+ */
+ __pyx_t_3 = ((__pyx_v_tfar == NULL) != 0);
+ if (__pyx_t_3) {
+
+ /* "pywrapfst.pyx":4436
+ * tostring(filename), tostring(arc_type), ft)
+ * if tfar == NULL:
+ * raise FstIOError("Open failed: {!r}".format(filename)) # <<<<<<<<<<<<<<
+ * cdef FarWriter result = FarWriter.__new__(FarWriter)
+ * result._writer.reset(tfar)
+ */
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstIOError); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Open_failed_r, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_8 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
+ if (likely(__pyx_t_8)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_8);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
+ }
+ }
+ if (!__pyx_t_8) {
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_filename); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_filename};
+ __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_filename};
+ __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_GOTREF(__pyx_t_6);
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
+ __Pyx_INCREF(__pyx_v_filename);
+ __Pyx_GIVEREF(__pyx_v_filename);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_filename);
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ if (!__pyx_t_7) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_6};
+ __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_9);
+ __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6);
+ PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6);
+ __pyx_t_6 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4436, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(0, 4436, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4435
+ * cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create(
+ * tostring(filename), tostring(arc_type), ft)
+ * if tfar == NULL: # <<<<<<<<<<<<<<
+ * raise FstIOError("Open failed: {!r}".format(filename))
+ * cdef FarWriter result = FarWriter.__new__(FarWriter)
+ */
+ }
+
+ /* "pywrapfst.pyx":4437
+ * if tfar == NULL:
+ * raise FstIOError("Open failed: {!r}".format(filename))
+ * cdef FarWriter result = FarWriter.__new__(FarWriter) # <<<<<<<<<<<<<<
+ * result._writer.reset(tfar)
+ * return result
+ */
+ __pyx_t_4 = __pyx_tp_new_9pywrapfst_FarWriter(((PyTypeObject *)__pyx_ptype_9pywrapfst_FarWriter), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4437, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (!(likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_9pywrapfst_FarWriter)))) __PYX_ERR(0, 4437, __pyx_L1_error)
+ __pyx_v_result = ((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_t_4);
+ __pyx_t_4 = 0;
+
+ /* "pywrapfst.pyx":4438
+ * raise FstIOError("Open failed: {!r}".format(filename))
+ * cdef FarWriter result = FarWriter.__new__(FarWriter)
+ * result._writer.reset(tfar) # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_result) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_writer");
+ __PYX_ERR(0, 4438, __pyx_L1_error)
+ }
+ __pyx_v_result->_writer.reset(__pyx_v_tfar);
+
+ /* "pywrapfst.pyx":4439
+ * cdef FarWriter result = FarWriter.__new__(FarWriter)
+ * result._writer.reset(tfar)
+ * return result # <<<<<<<<<<<<<<
+ *
+ * # NB: Invoking this method is DANGEROUS: calling any other method on the
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject *)__pyx_v_result));
+ __pyx_r = ((PyObject *)__pyx_v_result);
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4411
+ *
+ * @classmethod
+ * def create(cls, filename, arc_type=b"standard", far_type=b"default"): # <<<<<<<<<<<<<<
+ * """
+ * FarWriter.
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_6);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_9);
+ __Pyx_AddTraceback("pywrapfst.FarWriter.create", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_result);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "pywrapfst.pyx":4443
+ * # NB: Invoking this method is DANGEROUS: calling any other method on the
+ * # instance after this is invoked may result in a null dereference.
+ * cdef void _close(self): # <<<<<<<<<<<<<<
+ * self._writer.reset()
+ *
+ */
+
+static void __pyx_f_9pywrapfst_9FarWriter__close(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_close", 0);
+
+ /* "pywrapfst.pyx":4444
+ * # 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 '%s'", "_writer");
+ __PYX_ERR(0, 4444, __pyx_L1_error)
+ }
+ __pyx_v_self->_writer.reset();
+
+ /* "pywrapfst.pyx":4443
+ * # NB: Invoking this method is 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, 0, 0);
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "pywrapfst.pyx":4446
+ * self._writer.reset()
+ *
+ * cpdef void add(self, key, _Fst ifst) except *: # <<<<<<<<<<<<<<
+ * """
+ * add(self, key, ifst)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_7add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static void __pyx_f_9pywrapfst_9FarWriter_add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst, int __pyx_skip_dispatch) {
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_t_5;
+ PyObject *__pyx_t_6 = NULL;
+ std::string __pyx_t_7;
+ int __pyx_t_8;
+ __Pyx_RefNannySetupContext("add", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4446, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_7add)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ __pyx_t_5 = 0;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ __pyx_t_5 = 1;
+ }
+ }
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_key, ((PyObject *)__pyx_v_ifst)};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4446, __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, 4446, __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, 4446, __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, 4446, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4468
+ * # Failure here results from passing an FST with a different arc type than
+ * # used by the FAR was initialized to use.
+ * if not self._writer.get().Add(tostring(key), deref(ifst._fst)): # <<<<<<<<<<<<<<
+ * raise FstOpError("Incompatible or invalid arc type")
+ * # An error here usually indicates a key out of order.
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_writer");
+ __PYX_ERR(0, 4468, __pyx_L1_error)
+ }
+ __pyx_t_7 = __pyx_f_9pywrapfst_tostring(__pyx_v_key, NULL); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4468, __pyx_L1_error)
+ if (unlikely(((PyObject *)__pyx_v_ifst) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_fst");
+ __PYX_ERR(0, 4468, __pyx_L1_error)
+ }
+ __pyx_t_8 = ((!(__pyx_v_self->_writer.get()->Add(__pyx_t_7, (*__pyx_v_ifst->_fst)) != 0)) != 0);
+ if (__pyx_t_8) {
+
+ /* "pywrapfst.pyx":4469
+ * # used by the FAR was initialized to use.
+ * if not self._writer.get().Add(tostring(key), deref(ifst._fst)):
+ * raise FstOpError("Incompatible or invalid arc type") # <<<<<<<<<<<<<<
+ * # An error here usually indicates a key out of order.
+ * if self._writer.get().Error():
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstOpError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4469, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4469, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __PYX_ERR(0, 4469, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4468
+ * # Failure here results from passing an FST with a different arc type than
+ * # used by the FAR was initialized to use.
+ * if not self._writer.get().Add(tostring(key), deref(ifst._fst)): # <<<<<<<<<<<<<<
+ * raise FstOpError("Incompatible or invalid arc type")
+ * # An error here usually indicates a key out of order.
+ */
+ }
+
+ /* "pywrapfst.pyx":4471
+ * raise FstOpError("Incompatible or invalid arc type")
+ * # An error here usually indicates a key out of order.
+ * if self._writer.get().Error(): # <<<<<<<<<<<<<<
+ * raise FstArgError("Key out of order")
+ *
+ */
+ if (unlikely(((PyObject *)__pyx_v_self) == Py_None)) {
+ PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "_writer");
+ __PYX_ERR(0, 4471, __pyx_L1_error)
+ }
+ __pyx_t_8 = (__pyx_v_self->_writer.get()->Error() != 0);
+ if (__pyx_t_8) {
+
+ /* "pywrapfst.pyx":4472
+ * # An error here usually indicates a key out of order.
+ * if self._writer.get().Error():
+ * raise FstArgError("Key out of order") # <<<<<<<<<<<<<<
+ *
+ * cpdef string arc_type(self):
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstArgError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4472, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4472, __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, 4472, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4471
+ * raise FstOpError("Incompatible or invalid arc type")
+ * # An error here usually indicates a key out of order.
+ * if self._writer.get().Error(): # <<<<<<<<<<<<<<
+ * raise FstArgError("Key out of order")
+ *
+ */
+ }
+
+ /* "pywrapfst.pyx":4446
+ * 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 This method is provided for compatibility with the C++ API only; most users\n should use the Pythonic API.\n\n Args:\n key: The string used to key the input FST.\n ifst: The FST to write to the FAR.\n\n Raises:\n FstArgError: Key out of order.\n FstOpError: Incompatible or invalid arc type.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_7add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyObject *__pyx_v_key = 0;
+ struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("add (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_key,&__pyx_n_s_ifst,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_key)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ case 1:
+ if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ifst)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, 1); __PYX_ERR(0, 4446, __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, 4446, __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, 4446, __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, 4446, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_6add(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self), __pyx_v_key, __pyx_v_ifst);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_6add(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_ifst) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("add", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_f_9pywrapfst_9FarWriter_add(__pyx_v_self, __pyx_v_key, __pyx_v_ifst, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4446, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_void_to_None(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4446, __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":4474
+ * raise FstArgError("Key out of order")
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._writer.get().ArcType()
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_9FarWriter_arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_arc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4474, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_9arc_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4474, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4474, __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, 4474, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4475
+ *
+ * cpdef string arc_type(self):
+ * 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 '%s'", "_writer");
+ __PYX_ERR(0, 4475, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_writer.get()->ArcType();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4474
+ * raise FstArgError("Key out of order")
+ *
+ * cpdef string arc_type(self): # <<<<<<<<<<<<<<
+ * return self._writer.get().ArcType()
+ *
+ */
+
+ /* 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, 0, 0);
+ __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 PyObject *__pyx_pw_9pywrapfst_9FarWriter_9arc_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("arc_type (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_8arc_type(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_8arc_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("arc_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarWriter_arc_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4474, __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":4477
+ * return self._writer.get().ArcType()
+ *
+ * cpdef bool error(self): # <<<<<<<<<<<<<<
+ * """
+ * error(self)
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static bool __pyx_f_9pywrapfst_9FarWriter_error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch) {
+ bool __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ bool __pyx_t_5;
+ __Pyx_RefNannySetupContext("error", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4477, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_11error)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4477, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4477, __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, 4477, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4486
+ * 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 '%s'", "_writer");
+ __PYX_ERR(0, 4486, __pyx_L1_error)
+ }
+ __pyx_r = __pyx_v_self->_writer.get()->Error();
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4477
+ * 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, 0, 0);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_9pywrapfst_9FarWriter_10error[] = "\n error(self)\n\n Indicates whether the FarWriter has encountered an error.\n\n Returns:\n True if the FarWriter is in an errorful state, False otherwise.\n ";
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_11error(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("error (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_10error(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_10error(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("error", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_9pywrapfst_9FarWriter_error(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4477, __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":4488
+ * return self._writer.get().Error()
+ *
+ * cpdef string far_type(self): # <<<<<<<<<<<<<<
+ * return fst.GetFarTypeString(self._writer.get().Type())
+ *
+ */
+
+static PyObject *__pyx_pw_9pywrapfst_9FarWriter_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static std::string __pyx_f_9pywrapfst_9FarWriter_far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, int __pyx_skip_dispatch) {
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("far_type", 0);
+ /* Check if called by wrapper */
+ if (unlikely(__pyx_skip_dispatch)) ;
+ /* Check if overridden in Python */
+ else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) {
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_far_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4488, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_13far_type)) {
+ __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4488, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4488, __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, 4488, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_r = __pyx_t_5;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ goto __pyx_L0;
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ }
+
+ /* "pywrapfst.pyx":4489
+ *
+ * cpdef string far_type(self):
+ * 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 '%s'", "_writer");
+ __PYX_ERR(0, 4489, __pyx_L1_error)
+ }
+ __pyx_r = fst::GetFarTypeString(__pyx_v_self->_writer.get()->Type());
+ goto __pyx_L0;
+
+ /* "pywrapfst.pyx":4488
+ * return self._writer.get().Error()
+ *
+ * cpdef string far_type(self): # <<<<<<<<<<<<<<
+ * return fst.GetFarTypeString(self._writer.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.FarWriter.far_type", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+ __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 PyObject *__pyx_pw_9pywrapfst_9FarWriter_13far_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("far_type (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_12far_type(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_9FarWriter_12far_type(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("far_type", 0);
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_f_9pywrapfst_9FarWriter_far_type(__pyx_v_self, 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4488, __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":4492
+ *
+ * # Dictionary-like assignment.
+ * def __setitem__(self, key, _Fst fst): # <<<<<<<<<<<<<<
+ * self.add(key, fst)
+ *
+ */
+
+/* Python wrapper */
+static int __pyx_pw_9pywrapfst_9FarWriter_15__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_fst); /*proto*/
+static int __pyx_pw_9pywrapfst_9FarWriter_15__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_fst) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0);
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_fst), __pyx_ptype_9pywrapfst__Fst, 1, "fst", 0))) __PYX_ERR(0, 4492, __pyx_L1_error)
+ __pyx_r = __pyx_pf_9pywrapfst_9FarWriter_14__setitem__(((struct __pyx_obj_9pywrapfst_FarWriter *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((struct __pyx_obj_9pywrapfst__Fst *)__pyx_v_fst));
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = -1;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_9pywrapfst_9FarWriter_14__setitem__(struct __pyx_obj_9pywrapfst_FarWriter *__pyx_v_self, PyObject *__pyx_v_key, struct __pyx_obj_9pywrapfst__Fst *__pyx_v_fst) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__setitem__", 0);
+
+ /* "pywrapfst.pyx":4493
+ * # 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 '%s'", "add");
+ __PYX_ERR(0, 4493, __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, 4493, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4492
+ *
+ * # 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;
+}
+
+/* "pywrapfst.pyx":4508
+ *
+ * @atexit.register
+ * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<<
+ * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old
+ *
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_9pywrapfst_57_reset_fst_error_fatal(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static PyMethodDef __pyx_mdef_9pywrapfst_57_reset_fst_error_fatal = {"_reset_fst_error_fatal", (PyCFunction)__pyx_pw_9pywrapfst_57_reset_fst_error_fatal, METH_NOARGS, 0};
+static PyObject *__pyx_pw_9pywrapfst_57_reset_fst_error_fatal(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) {
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("_reset_fst_error_fatal (wrapper)", 0);
+ __pyx_r = __pyx_pf_9pywrapfst_56_reset_fst_error_fatal(__pyx_self);
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_9pywrapfst_56_reset_fst_error_fatal(CYTHON_UNUSED PyObject *__pyx_self) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ bool __pyx_t_2;
+ __Pyx_RefNannySetupContext("_reset_fst_error_fatal", 0);
+
+ /* "pywrapfst.pyx":4509
+ * @atexit.register
+ * def _reset_fst_error_fatal():
+ * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old # <<<<<<<<<<<<<<
+ *
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_fst_error_fatal_old); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4509, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4509, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ FLAGS_fst_error_fatal = __pyx_t_2;
+
+ /* "pywrapfst.pyx":4508
+ *
+ * @atexit.register
+ * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<<
+ * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old
+ *
+ */
+
+ /* function exit code */
+ __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("pywrapfst._reset_fst_error_fatal", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "string.from_py":13
+ *
+ * @cname("__pyx_convert_string_from_py_std__in_string")
+ * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t length
+ * cdef 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 *__pyx_v_data;
+ std::string __pyx_r;
+ __Pyx_RefNannyDeclarations
+ char *__pyx_t_1;
+ __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0);
+
+ /* "string.from_py":15
+ * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *:
+ * cdef Py_ssize_t length
+ * cdef 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 == NULL)) __PYX_ERR(1, 15, __pyx_L1_error)
+ __pyx_v_data = __pyx_t_1;
+
+ /* "string.from_py":16
+ * cdef Py_ssize_t length
+ * cdef char* data = __Pyx_PyObject_AsStringAndSize(o, &length)
+ * return string(data, length) # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = std::string(__pyx_v_data, __pyx_v_length);
+ goto __pyx_L0;
+
+ /* "string.from_py":13
+ *
+ * @cname("__pyx_convert_string_from_py_std__in_string")
+ * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<<
+ * cdef Py_ssize_t length
+ * cdef 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_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "string.to_py":31
+ *
+ * @cname("__pyx_convert_PyObject_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &__pyx_v_s) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__pyx_convert_PyObject_string_to_py_std__in_string", 0);
+
+ /* "string.to_py":32
+ * @cname("__pyx_convert_PyObject_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s):
+ * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<<
+ * cdef extern from *:
+ * cdef object __Pyx_PyUnicode_FromStringAndSize(char*, size_t)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyObject_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 32, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "string.to_py":31
+ *
+ * @cname("__pyx_convert_PyObject_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("string.to_py.__pyx_convert_PyObject_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "string.to_py":37
+ *
+ * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &__pyx_v_s) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__pyx_convert_PyUnicode_string_to_py_std__in_string", 0);
+
+ /* "string.to_py":38
+ * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s):
+ * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<<
+ * cdef extern from *:
+ * cdef object __Pyx_PyStr_FromStringAndSize(char*, size_t)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyUnicode_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "string.to_py":37
+ *
+ * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("string.to_py.__pyx_convert_PyUnicode_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "string.to_py":43
+ *
+ * @cname("__pyx_convert_PyStr_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &__pyx_v_s) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__pyx_convert_PyStr_string_to_py_std__in_string", 0);
+
+ /* "string.to_py":44
+ * @cname("__pyx_convert_PyStr_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s):
+ * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<<
+ * cdef extern from *:
+ * cdef object __Pyx_PyBytes_FromStringAndSize(char*, size_t)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyStr_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 44, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "string.to_py":43
+ *
+ * @cname("__pyx_convert_PyStr_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("string.to_py.__pyx_convert_PyStr_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "string.to_py":49
+ *
+ * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &__pyx_v_s) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__pyx_convert_PyBytes_string_to_py_std__in_string", 0);
+
+ /* "string.to_py":50
+ * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s):
+ * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<<
+ * cdef extern from *:
+ * cdef object __Pyx_PyByteArray_FromStringAndSize(char*, size_t)
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 50, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "string.to_py":49
+ *
+ * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size())
+ * cdef extern from *:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("string.to_py.__pyx_convert_PyBytes_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "string.to_py":55
+ *
+ * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size())
+ *
+ */
+
+static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &__pyx_v_s) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("__pyx_convert_PyByteArray_string_to_py_std__in_string", 0);
+
+ /* "string.to_py":56
+ * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s):
+ * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<<
+ *
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = __Pyx_PyByteArray_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 56, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "string.to_py":55
+ *
+ * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string")
+ * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<<
+ * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size())
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("string.to_py.__pyx_convert_PyByteArray_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "vector.from_py":49
+ *
+ * @cname("__pyx_convert_vector_from_py___pyx_t_10basictypes_int64")
+ * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *: # <<<<<<<<<<<<<<
+ * cdef vector[X] v
+ * for item in o:
+ */
+
+static std::vector<__pyx_t_10basictypes_int64> __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(PyObject *__pyx_v_o) {
+ std::vector<__pyx_t_10basictypes_int64> __pyx_v_v;
+ PyObject *__pyx_v_item = NULL;
+ std::vector<__pyx_t_10basictypes_int64> __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ Py_ssize_t __pyx_t_2;
+ PyObject *(*__pyx_t_3)(PyObject *);
+ PyObject *__pyx_t_4 = NULL;
+ __pyx_t_10basictypes_int64 __pyx_t_5;
+ __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py___pyx_t_10basictypes_int64", 0);
+
+ /* "vector.from_py":51
+ * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *:
+ * cdef vector[X] v
+ * for item in o: # <<<<<<<<<<<<<<
+ * v.push_back(X_from_py(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, 51, __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, 51, __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, 51, __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, 51, __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, 51, __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, 51, __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(1, 51, __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":52
+ * cdef vector[X] v
+ * for item in o:
+ * v.push_back(X_from_py(item)) # <<<<<<<<<<<<<<
+ * return v
+ *
+ */
+ __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_v_item); if (unlikely(__pyx_t_5 == -1LL && PyErr_Occurred())) __PYX_ERR(1, 52, __pyx_L1_error)
+ __pyx_v_v.push_back(__pyx_t_5);
+
+ /* "vector.from_py":51
+ * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *:
+ * cdef vector[X] v
+ * for item in o: # <<<<<<<<<<<<<<
+ * v.push_back(X_from_py(item))
+ * return v
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "vector.from_py":53
+ * for item in o:
+ * v.push_back(X_from_py(item))
+ * return v # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_v;
+ goto __pyx_L0;
+
+ /* "vector.from_py":49
+ *
+ * @cname("__pyx_convert_vector_from_py___pyx_t_10basictypes_int64")
+ * cdef vector[X] __pyx_convert_vector_from_py___pyx_t_10basictypes_int64(object o) except *: # <<<<<<<<<<<<<<
+ * cdef vector[X] v
+ * for item in o:
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py___pyx_t_10basictypes_int64", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_L0:;
+ __Pyx_XDECREF(__pyx_v_item);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "vector.from_py":50
+ *
+ * @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:
+ */
+
+static std::vector<std::string> __pyx_convert_vector_from_py_std_3a__3a_string(PyObject *__pyx_v_o) {
+ std::vector<std::string> __pyx_v_v;
+ PyObject *__pyx_v_item = NULL;
+ std::vector<std::string> __pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ Py_ssize_t __pyx_t_2;
+ PyObject *(*__pyx_t_3)(PyObject *);
+ PyObject *__pyx_t_4 = NULL;
+ std::string __pyx_t_5;
+ __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_std_3a__3a_string", 0);
+
+ /* "vector.from_py":52
+ * 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(X_from_py(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, 52, __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, 52, __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, 52, __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, 52, __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, 52, __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, 52, __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(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(1, 52, __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":53
+ * cdef vector[X] v
+ * for item in o:
+ * v.push_back(X_from_py(item)) # <<<<<<<<<<<<<<
+ * return v
+ *
+ */
+ __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_v_item); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 53, __pyx_L1_error)
+ __pyx_v_v.push_back(__pyx_t_5);
+
+ /* "vector.from_py":52
+ * 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(X_from_py(item))
+ * return v
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "vector.from_py":54
+ * for item in o:
+ * v.push_back(X_from_py(item))
+ * return v # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_v;
+ goto __pyx_L0;
+
+ /* "vector.from_py":50
+ *
+ * @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_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<fst::script::WeightClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_Weight(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_Weight *p = (struct __pyx_obj_9pywrapfst_Weight *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(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 PyMethodDef __pyx_methods_9pywrapfst_Weight[] = {
+ {"copy", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_9copy, METH_NOARGS, __pyx_doc_9pywrapfst_6Weight_8copy},
+ {"Zero", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_11Zero, METH_O, __pyx_doc_9pywrapfst_6Weight_10Zero},
+ {"One", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_13One, METH_O, __pyx_doc_9pywrapfst_6Weight_12One},
+ {"NoWeight", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_15NoWeight, METH_O, __pyx_doc_9pywrapfst_6Weight_14NoWeight},
+ {"to_string", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_19to_string, METH_NOARGS, 0},
+ {"type", (PyCFunction)__pyx_pw_9pywrapfst_6Weight_21type, METH_NOARGS, 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
+ 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
+ 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
+ 0, /*nb_oct*/
+ #endif
+ #if PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY
+ 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
+ 0, /*nb_inplace_divide*/
+ #endif
+ 0, /*nb_inplace_remainder*/
+ 0, /*nb_inplace_power*/
+ 0, /*nb_inplace_lshift*/
+ 0, /*nb_inplace_rshift*/
+ 0, /*nb_inplace_and*/
+ 0, /*nb_inplace_xor*/
+ 0, /*nb_inplace_or*/
+ 0, /*nb_floor_divide*/
+ 0, /*nb_true_divide*/
+ 0, /*nb_inplace_floor_divide*/
+ 0, /*nb_inplace_true_divide*/
+ 0, /*nb_index*/
+ #if PY_VERSION_HEX >= 0x03050000
+ 0, /*nb_matrix_multiply*/
+ #endif
+ #if PY_VERSION_HEX >= 0x03050000
+ 0, /*nb_inplace_matrix_multiply*/
+ #endif
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_Weight = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.Weight", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_Weight), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_Weight, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_6Weight_1__repr__, /*tp_repr*/
+ &__pyx_tp_as_number_Weight, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ __pyx_pw_9pywrapfst_6Weight_3__str__, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n Weight(weight_type, weight_string)\n\n FST weight class.\n\n This class represents an FST weight. When passed as an argument to an FST\n operation, it should have the weight type of the input FST(s) to said\n operation.\n\n Args:\n weight_type: A string indicating the weight type.\n weight_string: A string indicating the underlying weight.\n\n Raises:\n FstBadWeightError: invalid weight.\n FstUnknownWeightTypeError: weight type not found.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ __pyx_pw_9pywrapfst_6Weight_17__richcmp__, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_Weight, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_6Weight_7__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_Weight, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst__SymbolTable __pyx_vtable_9pywrapfst__SymbolTable;
+
+static PyObject *__pyx_tp_new_9pywrapfst__SymbolTable(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst__SymbolTable *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst__SymbolTable *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst__SymbolTable;
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst__SymbolTable(PyObject *o) {
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst__SymbolTable[] = {
+ {"available_key", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_5available_key, METH_NOARGS, 0},
+ {"checksum", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_7checksum, METH_NOARGS, 0},
+ {"copy", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_9copy, METH_NOARGS, __pyx_doc_9pywrapfst_12_SymbolTable_8copy},
+ {"find", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_11find, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_10find},
+ {"member", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_13member, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_12member},
+ {"get_nth_key", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_17get_nth_key, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_16get_nth_key},
+ {"labeled_checksum", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_19labeled_checksum, METH_NOARGS, 0},
+ {"name", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_21name, METH_NOARGS, 0},
+ {"num_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_23num_symbols, METH_NOARGS, 0},
+ {"write", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_25write, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_24write},
+ {"write_text", (PyCFunction)__pyx_pw_9pywrapfst_12_SymbolTable_27write_text, METH_O, __pyx_doc_9pywrapfst_12_SymbolTable_26write_text},
+ {0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence__SymbolTable = {
+ 0, /*sq_length*/
+ 0, /*sq_concat*/
+ 0, /*sq_repeat*/
+ 0, /*sq_item*/
+ 0, /*sq_slice*/
+ 0, /*sq_ass_item*/
+ 0, /*sq_ass_slice*/
+ __pyx_pw_9pywrapfst_12_SymbolTable_15__contains__, /*sq_contains*/
+ 0, /*sq_inplace_concat*/
+ 0, /*sq_inplace_repeat*/
+};
+
+static PyTypeObject __pyx_type_9pywrapfst__SymbolTable = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst._SymbolTable", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst__SymbolTable), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst__SymbolTable, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ &__pyx_tp_as_sequence__SymbolTable, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n Base class for the symbol table hierarchy.\n\n This class is the base class for SymbolTable. It has a \"deleted\" constructor\n and implementations for the const methods of the wrapped SymbolTable.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst__SymbolTable, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst__SymbolTable, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst__EncodeMapperSymbolTable __pyx_vtable_9pywrapfst__EncodeMapperSymbolTable;
+
+static PyObject *__pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) {
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *p;
+ PyObject *o = __pyx_tp_new_9pywrapfst__SymbolTable(t, a, k);
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)o);
+ p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable;
+ new((void*)&(p->_encoder)) std::shared_ptr<fst::script::EncodeMapperClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst__EncodeMapperSymbolTable(PyObject *o) {
+ struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *p = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_encoder);
+ __pyx_tp_dealloc_9pywrapfst__SymbolTable(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst__EncodeMapperSymbolTable[] = {
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst__EncodeMapperSymbolTable = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst._EncodeMapperSymbolTable", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst__EncodeMapperSymbolTable, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_24_EncodeMapperSymbolTable_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n Immutable SymbolTable class for tables stored in an EncodeMapper.\n\n This class wraps a library const SymbolTable and exposes const methods of the\n wrapped object. It is only to be returned by method, never constructed\n directly.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/
+ #else
+ 0, /*tp_iter*/
+ #endif
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst__EncodeMapperSymbolTable, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/
+ #else
+ 0, /*tp_init*/
+ #endif
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst__EncodeMapperSymbolTable, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst__FstSymbolTable __pyx_vtable_9pywrapfst__FstSymbolTable;
+
+static PyObject *__pyx_tp_new_9pywrapfst__FstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) {
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *p;
+ PyObject *o = __pyx_tp_new_9pywrapfst__SymbolTable(t, a, k);
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst__FstSymbolTable *)o);
+ p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__FstSymbolTable;
+ new((void*)&(p->_fst)) std::shared_ptr<fst::script::FstClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst__FstSymbolTable(PyObject *o) {
+ struct __pyx_obj_9pywrapfst__FstSymbolTable *p = (struct __pyx_obj_9pywrapfst__FstSymbolTable *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_fst);
+ __pyx_tp_dealloc_9pywrapfst__SymbolTable(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst__FstSymbolTable[] = {
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst__FstSymbolTable = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst._FstSymbolTable", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst__FstSymbolTable), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst__FstSymbolTable, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_15_FstSymbolTable_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n Mutable SymbolTable class for tables stored in a mutable FST.\n\n This class wraps a library SymbolTable and exposes methods of the wrapped\n object. It is only to be returned by method, never constructed directly.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/
+ #else
+ 0, /*tp_iter*/
+ #endif
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst__FstSymbolTable, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/
+ #else
+ 0, /*tp_init*/
+ #endif
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst__FstSymbolTable, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst__MutableSymbolTable __pyx_vtable_9pywrapfst__MutableSymbolTable;
+
+static PyObject *__pyx_tp_new_9pywrapfst__MutableSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) {
+ struct __pyx_obj_9pywrapfst__MutableSymbolTable *p;
+ PyObject *o = __pyx_tp_new_9pywrapfst__SymbolTable(t, a, k);
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst__MutableSymbolTable *)o);
+ p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__MutableSymbolTable;
+ return o;
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst__MutableSymbolTable[] = {
+ {"add_symbol", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_1add_symbol, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_19_MutableSymbolTable_add_symbol},
+ {"add_table", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_3add_table, METH_O, __pyx_doc_9pywrapfst_19_MutableSymbolTable_2add_table},
+ {"set_name", (PyCFunction)__pyx_pw_9pywrapfst_19_MutableSymbolTable_5set_name, METH_O, 0},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst__MutableSymbolTable = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst._MutableSymbolTable", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst__MutableSymbolTable), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst__SymbolTable, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n Base class for mutable symbol tables.\n\n This class is the base class for a mutable SymbolTable. It has a \"deleted\"\n constructor and implementations of all methods of the wrapped SymbolTable.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/
+ #else
+ 0, /*tp_iter*/
+ #endif
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst__MutableSymbolTable, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/
+ #else
+ 0, /*tp_init*/
+ #endif
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst__MutableSymbolTable, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst__MutableFstSymbolTable __pyx_vtable_9pywrapfst__MutableFstSymbolTable;
+
+static PyObject *__pyx_tp_new_9pywrapfst__MutableFstSymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) {
+ struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *p;
+ PyObject *o = __pyx_tp_new_9pywrapfst__MutableSymbolTable(t, a, k);
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)o);
+ p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst__MutableFstSymbolTable;
+ new((void*)&(p->_mfst)) std::shared_ptr<fst::script::MutableFstClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst__MutableFstSymbolTable(PyObject *o) {
+ struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *p = (struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_mfst);
+ __pyx_tp_dealloc_9pywrapfst__SymbolTable(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst__MutableFstSymbolTable[] = {
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst__MutableFstSymbolTable = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst._MutableFstSymbolTable", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst__MutableFstSymbolTable), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst__MutableFstSymbolTable, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_22_MutableFstSymbolTable_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n Mutable SymbolTable assigned to an FST.\n\n Attributes:\n available_key: An integer indicating the next available key index in the\n table.\n checksum: A string indicating the label-agnostic MD5 checksum for the table.\n labeled_checksum: A string indicating the label-dependent MD5 checksum for\n the table.\n name: A string indicating the table's name.\n num_symbols: An integer indicating the number of symbols in the table.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/
+ #else
+ 0, /*tp_iter*/
+ #endif
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst__MutableFstSymbolTable, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_1__init__, /*tp_init*/
+ #else
+ 0, /*tp_init*/
+ #endif
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst__MutableFstSymbolTable, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_SymbolTable __pyx_vtable_9pywrapfst_SymbolTable;
+
+static PyObject *__pyx_tp_new_9pywrapfst_SymbolTable(PyTypeObject *t, PyObject *a, PyObject *k) {
+ struct __pyx_obj_9pywrapfst_SymbolTable *p;
+ PyObject *o = __pyx_tp_new_9pywrapfst__MutableSymbolTable(t, a, k);
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_SymbolTable *)o);
+ p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__SymbolTable*)__pyx_vtabptr_9pywrapfst_SymbolTable;
+ new((void*)&(p->_smart_table)) std::unique_ptr<fst::SymbolTable> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_SymbolTable(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_SymbolTable *p = (struct __pyx_obj_9pywrapfst_SymbolTable *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_smart_table);
+ __pyx_tp_dealloc_9pywrapfst__SymbolTable(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst_SymbolTable[] = {
+ {"read", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_5read, METH_O, __pyx_doc_9pywrapfst_11SymbolTable_4read},
+ {"read_text", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_7read_text, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11SymbolTable_6read_text},
+ {"read_fst", (PyCFunction)__pyx_pw_9pywrapfst_11SymbolTable_9read_fst, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11SymbolTable_8read_fst},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_SymbolTable = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.SymbolTable", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_SymbolTable), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_SymbolTable, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_11SymbolTable_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n SymbolTable(name=\"<unspecified>\")\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. Unlike\n other classes in the hierarchy, it has a working constructor and can be used\n to programmatically construct a SymbolTable in memory.\n\n Args:\n name: A string indicating the table's name\n\n Attributes:\n available_key: An integer indicating the next available key index in the\n table.\n checksum: A string indicating the label-agnostic MD5 checksum for the table.\n labeled_checksum: A string indicating the label-dependent MD5 checksum for\n the table.\n name: A string indicating the table's name.\n num_symbols: An integer indicating the number of symbols in the table.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_12_SymbolTable_3__iter__, /*tp_iter*/
+ #else
+ 0, /*tp_iter*/
+ #endif
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_SymbolTable, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_11SymbolTable_3__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_SymbolTable, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_SymbolTableIterator __pyx_vtable_9pywrapfst_SymbolTableIterator;
+
+static PyObject *__pyx_tp_new_9pywrapfst_SymbolTableIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst_SymbolTableIterator *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_SymbolTableIterator *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_SymbolTableIterator;
+ new((void*)&(p->_table)) std::shared_ptr<fst::SymbolTable> ();
+ new((void*)&(p->_siter)) std::unique_ptr<fst::SymbolTableIterator> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_SymbolTableIterator(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_SymbolTableIterator *p = (struct __pyx_obj_9pywrapfst_SymbolTableIterator *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_table);
+ __Pyx_call_destructor(p->_siter);
+ (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst_SymbolTableIterator[] = {
+ {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__, METH_NOARGS|METH_COEXIST, 0},
+ {"done", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_9done, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_8done},
+ {"next", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_11next, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_10next},
+ {"reset", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_13reset, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_12reset},
+ {"symbol", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_15symbol, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_14symbol},
+ {"value", (PyCFunction)__pyx_pw_9pywrapfst_19SymbolTableIterator_17value, METH_NOARGS, __pyx_doc_9pywrapfst_19SymbolTableIterator_16value},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_SymbolTableIterator = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.SymbolTableIterator", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_SymbolTableIterator), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_SymbolTableIterator, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_19SymbolTableIterator_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n SymbolTableIterator(syms)\n\n This class is used for iterating over a symbol table using a Pythonic API. It\n also supports the C++ API methods, but most users should simply place a\n SymbolTable in an iteration context and take advantage of the Pythonic API\n that provides.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ __pyx_pw_9pywrapfst_19SymbolTableIterator_5__iter__, /*tp_iter*/
+ __pyx_pw_9pywrapfst_19SymbolTableIterator_7__next__, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_SymbolTableIterator, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_19SymbolTableIterator_3__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_SymbolTableIterator, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_EncodeMapper __pyx_vtable_9pywrapfst_EncodeMapper;
+
+static PyObject *__pyx_tp_new_9pywrapfst_EncodeMapper(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst_EncodeMapper *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_EncodeMapper *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_EncodeMapper;
+ new((void*)&(p->_encoder)) std::shared_ptr<fst::script::EncodeMapperClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_EncodeMapper(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_EncodeMapper *p = (struct __pyx_obj_9pywrapfst_EncodeMapper *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_encoder);
+ (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst_EncodeMapper[] = {
+ {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_5arc_type, METH_NOARGS, 0},
+ {"flags", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_9flags, METH_NOARGS, 0},
+ {"input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_11input_symbols, METH_NOARGS, 0},
+ {"output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_13output_symbols, METH_NOARGS, 0},
+ {"properties", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_15properties, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_14properties},
+ {"set_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_17set_input_symbols, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_16set_input_symbols},
+ {"set_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_19set_output_symbols, METH_O, __pyx_doc_9pywrapfst_12EncodeMapper_18set_output_symbols},
+ {"weight_type", (PyCFunction)__pyx_pw_9pywrapfst_12EncodeMapper_21weight_type, METH_NOARGS, 0},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_EncodeMapper = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.EncodeMapper", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_EncodeMapper), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_EncodeMapper, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_12EncodeMapper_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ __pyx_pw_9pywrapfst_12EncodeMapper_7__call__, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n EncodeMapper(arc_type=\"standard\", encode_labels=False, encode_weights=False)\n\n Arc encoder class, wrapping EncodeMapperClass.\n\n This class provides an object which can be used to encode or decode FST arcs.\n This is most useful to convert an FST to an unweighted acceptor, on which\n some FST operations are more efficient, and then decoding the FST afterwards.\n\n To use an instance of this class to encode or decode a mutable FST, pass it\n as the first argument to the FST instance methods `encode` and `decode`.\n\n For implementational reasons, it is not currently possible to use an encoder\n on disk to construct this class.\n\n Args:\n arc_type: A string indicating the arc type.\n encode_labels: Should labels be encoded?\n encode_weights: Should weights be encoded?\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_EncodeMapper, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_12EncodeMapper_3__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_EncodeMapper, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst__Fst __pyx_vtable_9pywrapfst__Fst;
+
+static PyObject *__pyx_tp_new_9pywrapfst__Fst(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst__Fst *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst__Fst *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst__Fst;
+ new((void*)&(p->_fst)) std::shared_ptr<fst::script::FstClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst__Fst(PyObject *o) {
+ struct __pyx_obj_9pywrapfst__Fst *p = (struct __pyx_obj_9pywrapfst__Fst *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_fst);
+ (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst__Fst[] = {
+ {"_repr_svg_", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_1_repr_svg_, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst__repr_svg_},
+ {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_9arc_type, METH_NOARGS, 0},
+ {"arcs", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_11arcs, METH_O, __pyx_doc_9pywrapfst_4_Fst_10arcs},
+ {"copy", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_13copy, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_12copy},
+ {"draw", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_15draw, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4_Fst_14draw},
+ {"final", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_17final, METH_O, __pyx_doc_9pywrapfst_4_Fst_16final},
+ {"fst_type", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_19fst_type, METH_NOARGS, 0},
+ {"input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_21input_symbols, METH_NOARGS, 0},
+ {"num_arcs", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_23num_arcs, METH_O, __pyx_doc_9pywrapfst_4_Fst_22num_arcs},
+ {"num_input_epsilons", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_25num_input_epsilons, METH_O, __pyx_doc_9pywrapfst_4_Fst_24num_input_epsilons},
+ {"num_output_epsilons", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_27num_output_epsilons, METH_O, __pyx_doc_9pywrapfst_4_Fst_26num_output_epsilons},
+ {"output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_29output_symbols, METH_NOARGS, 0},
+ {"properties", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_31properties, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4_Fst_30properties},
+ {"start", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_33start, METH_NOARGS, 0},
+ {"states", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_35states, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_34states},
+ {"text", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_37text, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_4_Fst_36text},
+ {"verify", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_39verify, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_38verify},
+ {"weight_type", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_41weight_type, METH_NOARGS, __pyx_doc_9pywrapfst_4_Fst_40weight_type},
+ {"write", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_43write, METH_O, __pyx_doc_9pywrapfst_4_Fst_42write},
+ {"WriteToString", (PyCFunction)__pyx_pw_9pywrapfst_4_Fst_45WriteToString, METH_NOARGS, 0},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst__Fst = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst._Fst", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst__Fst), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst__Fst, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_4_Fst_3__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ __pyx_pw_9pywrapfst_4_Fst_7__str__, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n Immutable FST class, wrapping FstClass.\n\n This class is the basic user-facing FST object. It does not itself support any\n mutation operations.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst__Fst, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_4_Fst_5__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst__Fst, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst__MutableFst __pyx_vtable_9pywrapfst__MutableFst;
+
+static PyObject *__pyx_tp_new_9pywrapfst__MutableFst(PyTypeObject *t, PyObject *a, PyObject *k) {
+ struct __pyx_obj_9pywrapfst__MutableFst *p;
+ PyObject *o = __pyx_tp_new_9pywrapfst__Fst(t, a, k);
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst__MutableFst *)o);
+ p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_9pywrapfst__Fst*)__pyx_vtabptr_9pywrapfst__MutableFst;
+ new((void*)&(p->_mfst)) std::shared_ptr<fst::script::MutableFstClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst__MutableFst(PyObject *o) {
+ struct __pyx_obj_9pywrapfst__MutableFst *p = (struct __pyx_obj_9pywrapfst__MutableFst *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_mfst);
+ __pyx_tp_dealloc_9pywrapfst__Fst(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst__MutableFst[] = {
+ {"add_arc", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_1add_arc, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_add_arc},
+ {"add_state", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_3add_state, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_2add_state},
+ {"arcsort", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_5arcsort, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_4arcsort},
+ {"closure", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_7closure, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_6closure},
+ {"concat", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_9concat, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_8concat},
+ {"connect", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_11connect, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_10connect},
+ {"decode", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_13decode, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_12decode},
+ {"delete_arcs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_15delete_arcs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_14delete_arcs},
+ {"delete_states", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_17delete_states, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_16delete_states},
+ {"encode", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_19encode, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_18encode},
+ {"invert", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_21invert, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_20invert},
+ {"minimize", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_23minimize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_22minimize},
+ {"mutable_arcs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_25mutable_arcs, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_24mutable_arcs},
+ {"mutable_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_27mutable_input_symbols, METH_NOARGS, 0},
+ {"mutable_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_29mutable_output_symbols, METH_NOARGS, 0},
+ {"num_states", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_31num_states, METH_NOARGS, 0},
+ {"project", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_33project, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_32project},
+ {"prune", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_35prune, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_34prune},
+ {"push", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_37push, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_36push},
+ {"relabel_pairs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_39relabel_pairs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_38relabel_pairs},
+ {"relabel_tables", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_41relabel_tables, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_40relabel_tables},
+ {"reserve_arcs", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_43reserve_arcs, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_42reserve_arcs},
+ {"reserve_states", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_45reserve_states, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_44reserve_states},
+ {"reweight", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_47reweight, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_46reweight},
+ {"rmepsilon", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_49rmepsilon, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_48rmepsilon},
+ {"set_final", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_51set_final, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_50set_final},
+ {"set_properties", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_53set_properties, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11_MutableFst_52set_properties},
+ {"set_start", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_55set_start, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_54set_start},
+ {"set_input_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_57set_input_symbols, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_56set_input_symbols},
+ {"set_output_symbols", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_59set_output_symbols, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_58set_output_symbols},
+ {"topsort", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_61topsort, METH_NOARGS, __pyx_doc_9pywrapfst_11_MutableFst_60topsort},
+ {"union", (PyCFunction)__pyx_pw_9pywrapfst_11_MutableFst_63union, METH_O, __pyx_doc_9pywrapfst_11_MutableFst_62union},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst__MutableFst = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst._MutableFst", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst__MutableFst), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst__MutableFst, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_4_Fst_3__repr__, /*tp_repr*/
+ #else
+ 0, /*tp_repr*/
+ #endif
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_4_Fst_7__str__, /*tp_str*/
+ #else
+ 0, /*tp_str*/
+ #endif
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n Mutable FST class, wrapping MutableFstClass.\n\n This class extends _Fst by adding mutation operations.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst__MutableFst, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ #if CYTHON_COMPILING_IN_PYPY
+ __pyx_pw_9pywrapfst_4_Fst_5__init__, /*tp_init*/
+ #else
+ 0, /*tp_init*/
+ #endif
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst__MutableFst, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_Arc __pyx_vtable_9pywrapfst_Arc;
+
+static PyObject *__pyx_tp_new_9pywrapfst_Arc(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst_Arc *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_Arc *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_Arc;
+ new((void*)&(p->_arc)) std::unique_ptr<fst::script::ArcClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_Arc(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_Arc *p = (struct __pyx_obj_9pywrapfst_Arc *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(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},
+ {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_9pywrapfst_Arc[] = {
+ {(char *)"ilabel", __pyx_getprop_9pywrapfst_3Arc_ilabel, __pyx_setprop_9pywrapfst_3Arc_ilabel, (char *)0, 0},
+ {(char *)"olabel", __pyx_getprop_9pywrapfst_3Arc_olabel, __pyx_setprop_9pywrapfst_3Arc_olabel, (char *)0, 0},
+ {(char *)"weight", __pyx_getprop_9pywrapfst_3Arc_weight, __pyx_setprop_9pywrapfst_3Arc_weight, (char *)0, 0},
+ {(char *)"nextstate", __pyx_getprop_9pywrapfst_3Arc_nextstate, __pyx_setprop_9pywrapfst_3Arc_nextstate, (char *)0, 0},
+ {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_Arc = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.Arc", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_Arc), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_Arc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_3Arc_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n Arc(ilabel, olabel, weight, nextstate)\n\n This class represents an arc while remaining agnostic about the underlying arc\n type. Attributes of the arc can be accessed or mutated, and the arc can be\n copied.\n\n Attributes:\n ilabel: The input label.\n olabel: The output label.\n weight: The arc weight.\n nextstate: The destination state for the arc.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_Arc, /*tp_methods*/
+ 0, /*tp_members*/
+ __pyx_getsets_9pywrapfst_Arc, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_3Arc_3__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_Arc, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_ArcIterator __pyx_vtable_9pywrapfst_ArcIterator;
+
+static PyObject *__pyx_tp_new_9pywrapfst_ArcIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst_ArcIterator *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_ArcIterator *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_ArcIterator;
+ new((void*)&(p->_fst)) std::shared_ptr<fst::script::FstClass> ();
+ new((void*)&(p->_aiter)) std::unique_ptr<fst::script::ArcIteratorClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_ArcIterator(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_ArcIterator *p = (struct __pyx_obj_9pywrapfst_ArcIterator *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_fst);
+ __Pyx_call_destructor(p->_aiter);
+ (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst_ArcIterator[] = {
+ {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_7__next__, METH_NOARGS|METH_COEXIST, 0},
+ {"done", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_9done, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_8done},
+ {"flags", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_11flags, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_10flags},
+ {"next", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_13next, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_12next},
+ {"position", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_15position, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_14position},
+ {"reset", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_17reset, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_16reset},
+ {"seek", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_19seek, METH_O, __pyx_doc_9pywrapfst_11ArcIterator_18seek},
+ {"set_flags", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_21set_flags, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_11ArcIterator_20set_flags},
+ {"value", (PyCFunction)__pyx_pw_9pywrapfst_11ArcIterator_23value, METH_NOARGS, __pyx_doc_9pywrapfst_11ArcIterator_22value},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_ArcIterator = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.ArcIterator", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_ArcIterator), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_ArcIterator, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_11ArcIterator_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n ArcIterator(ifst, state)\n\n This class is used for iterating over the arcs leaving some state of an FST.\n It supports the full C++ API, but most users should just call the `arcs`\n method of an FST object and take advantage of the Pythonic API.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ __pyx_pw_9pywrapfst_11ArcIterator_5__iter__, /*tp_iter*/
+ __pyx_pw_9pywrapfst_11ArcIterator_7__next__, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_ArcIterator, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_11ArcIterator_3__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_ArcIterator, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_MutableArcIterator __pyx_vtable_9pywrapfst_MutableArcIterator;
+
+static PyObject *__pyx_tp_new_9pywrapfst_MutableArcIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst_MutableArcIterator *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_MutableArcIterator *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_MutableArcIterator;
+ new((void*)&(p->_mfst)) std::shared_ptr<fst::script::MutableFstClass> ();
+ new((void*)&(p->_aiter)) std::unique_ptr<fst::script::MutableArcIteratorClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_MutableArcIterator(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_MutableArcIterator *p = (struct __pyx_obj_9pywrapfst_MutableArcIterator *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(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[] = {
+ {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_7__next__, METH_NOARGS|METH_COEXIST, 0},
+ {"done", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_9done, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_8done},
+ {"flags", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_11flags, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_10flags},
+ {"next", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_13next, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_12next},
+ {"position", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_15position, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_14position},
+ {"reset", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_17reset, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_16reset},
+ {"seek", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_19seek, METH_O, __pyx_doc_9pywrapfst_18MutableArcIterator_18seek},
+ {"set_flags", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_21set_flags, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_18MutableArcIterator_20set_flags},
+ {"set_value", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_23set_value, METH_O, __pyx_doc_9pywrapfst_18MutableArcIterator_22set_value},
+ {"value", (PyCFunction)__pyx_pw_9pywrapfst_18MutableArcIterator_25value, METH_NOARGS, __pyx_doc_9pywrapfst_18MutableArcIterator_24value},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_MutableArcIterator = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.MutableArcIterator", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_MutableArcIterator), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_MutableArcIterator, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_18MutableArcIterator_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n MutableArcIterator(ifst, state)\n\n This class is used for iterating over the arcs leaving some state of an FST,\n also permitting mutation of the current arc. It supports the full C++ API,\n but most users should just call the `mutable_arcs` method of an FST object\n and take advantage of the Pythonic API.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ __pyx_pw_9pywrapfst_18MutableArcIterator_5__iter__, /*tp_iter*/
+ __pyx_pw_9pywrapfst_18MutableArcIterator_7__next__, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_MutableArcIterator, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_18MutableArcIterator_3__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_MutableArcIterator, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_StateIterator __pyx_vtable_9pywrapfst_StateIterator;
+
+static PyObject *__pyx_tp_new_9pywrapfst_StateIterator(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst_StateIterator *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_StateIterator *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_StateIterator;
+ new((void*)&(p->_fst)) std::shared_ptr<fst::script::FstClass> ();
+ new((void*)&(p->_siter)) std::unique_ptr<fst::script::StateIteratorClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_StateIterator(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_StateIterator *p = (struct __pyx_obj_9pywrapfst_StateIterator *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_fst);
+ __Pyx_call_destructor(p->_siter);
+ (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst_StateIterator[] = {
+ {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_7__next__, METH_NOARGS|METH_COEXIST, 0},
+ {"done", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_9done, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_8done},
+ {"next", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_11next, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_10next},
+ {"reset", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_13reset, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_12reset},
+ {"value", (PyCFunction)__pyx_pw_9pywrapfst_13StateIterator_15value, METH_NOARGS, __pyx_doc_9pywrapfst_13StateIterator_14value},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_StateIterator = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.StateIterator", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_StateIterator), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_StateIterator, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_13StateIterator_1__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n StateIterator(ifst)\n\n This class is used for iterating over the states in an FST. It supports the\n full C++ API, but most users should just place an FST argument in an\n iteration context and take advantage of the Pythonic API.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ __pyx_pw_9pywrapfst_13StateIterator_5__iter__, /*tp_iter*/
+ __pyx_pw_9pywrapfst_13StateIterator_7__next__, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_StateIterator, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_13StateIterator_3__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_StateIterator, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_Compiler __pyx_vtable_9pywrapfst_Compiler;
+
+static PyObject *__pyx_tp_new_9pywrapfst_Compiler(PyTypeObject *t, PyObject *a, PyObject *k) {
+ struct __pyx_obj_9pywrapfst_Compiler *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_Compiler *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_Compiler;
+ new((void*)&(p->_sstrm)) std::unique_ptr<std::stringstream> ();
+ 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 PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(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},
+ {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_Compiler = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.Compiler", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_Compiler), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_Compiler, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n Compiler(fst_type=\"vector\", arc_type=\"standard\", isymbols=None,\n osymbols=None, ssymbols=None, acceptor=False, keep_isymbols=False,\n keep_osymbols=False, keep_state_numbering=False,\n allow_negative_labels=False)\n\n Class used to compile FSTs from strings.\n\n This class is used to compile FSTs specified using the AT&T FSM library\n format described here:\n\n http://web.eecs.umich.edu/~radev/NLP-fall2015/resources/fsm_archive/fsm.5.html\n\n This is the same format used by the `fstcompile` executable.\n\n Compiler options (symbol tables, etc.) are set at construction time.\n\n compiler = fst.Compiler(isymbols=ascii_syms, osymbols=ascii_syms)\n\n Once constructed, Compiler instances behave like a file handle opened for\n writing:\n\n # /ba+/\n print >> compiler, \"0 1 50 50\"\n print >> compiler, \"1 2 49 49\"\n print >> compiler, \"2 2 49 49\"\n print >> compiler, \"2\"\n\n The `compile` method returns an actual FST instance:\n\n sheep_machine = compiler.compile()\n\n Compilation flushes the internal buffer, so the compiler instance can be\n reused to compile new machines with the same symbol tables (etc.)\n\n Args:\n fst_type: A string indicating the container type for the compiled FST.\n arc_type: A string indicating the arc type for the compiled FST.\n isymbols: An optional SymbolTable used to label input symbols.\n osymbols: An optional SymbolTable used to label output symbols.\n ssymbols: An optional SymbolTable used to label states.\n acceptor: Should the FST be rendered in acceptor format if possible?\n keep_isymbols: Should the input symbol table be stored in the FST?\n keep_osymbols: Should the output symbol table be stored in the FST?\n keep_state_numbering: Should the state numbering be preserved?\n allow_negative_labels: Should negative labels be allowed? (Not\n recommended; may cause conflicts).\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_Compiler, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ 0, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_Compiler, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+static struct __pyx_vtabstruct_9pywrapfst_FarReader __pyx_vtable_9pywrapfst_FarReader;
+
+static PyObject *__pyx_tp_new_9pywrapfst_FarReader(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+ struct __pyx_obj_9pywrapfst_FarReader *p;
+ PyObject *o;
+ if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+ o = (*t->tp_alloc)(t, 0);
+ } else {
+ o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+ }
+ if (unlikely(!o)) return 0;
+ p = ((struct __pyx_obj_9pywrapfst_FarReader *)o);
+ p->__pyx_vtab = __pyx_vtabptr_9pywrapfst_FarReader;
+ new((void*)&(p->_reader)) std::unique_ptr<fst::script::FarReaderClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_FarReader(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_FarReader *p = (struct __pyx_obj_9pywrapfst_FarReader *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_reader);
+ (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_9pywrapfst_FarReader(PyObject *o, Py_ssize_t i) {
+ PyObject *r;
+ PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+ r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+ Py_DECREF(x);
+ return r;
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst_FarReader[] = {
+ {"open", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_5open, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_9FarReader_4open},
+ {"__next__", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_9__next__, METH_NOARGS|METH_COEXIST, 0},
+ {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_11arc_type, METH_NOARGS, 0},
+ {"done", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_13done, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_12done},
+ {"error", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_15error, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_14error},
+ {"far_type", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_17far_type, METH_NOARGS, 0},
+ {"find", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_19find, METH_O, __pyx_doc_9pywrapfst_9FarReader_18find},
+ {"get_fst", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_21get_fst, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_20get_fst},
+ {"get_key", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_23get_key, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_22get_key},
+ {"next", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_25next, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_24next},
+ {"reset", (PyCFunction)__pyx_pw_9pywrapfst_9FarReader_27reset, METH_NOARGS, __pyx_doc_9pywrapfst_9FarReader_26reset},
+ {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_29__getitem__, /*mp_subscript*/
+ 0, /*mp_ass_subscript*/
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_FarReader = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.FarReader", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_FarReader), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_FarReader, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_9FarReader_3__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ &__pyx_tp_as_sequence_FarReader, /*tp_as_sequence*/
+ &__pyx_tp_as_mapping_FarReader, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n FAR (\"Fst ARchive\") reader object.\n\n This class is used to read a FAR from disk. FARs contain one or more FSTs (of\n the same arc type) indexed by a unique string key. To construct a FarReader\n object, use the `open` class method. FSTs can be accessed from a FAR using the\n familiar C++ API methods, but a user who wishes to access all FSTs in random\n order should simply place a FarReader in an iteration context and take\n advantage of the Pythonic API that provides.\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_7__iter__, /*tp_iter*/
+ __pyx_pw_9pywrapfst_9FarReader_9__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
+};
+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<fst::script::FarWriterClass> ();
+ return o;
+}
+
+static void __pyx_tp_dealloc_9pywrapfst_FarWriter(PyObject *o) {
+ struct __pyx_obj_9pywrapfst_FarWriter *p = (struct __pyx_obj_9pywrapfst_FarWriter *)o;
+ #if PY_VERSION_HEX >= 0x030400a1
+ if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+ if (PyObject_CallFinalizerFromDealloc(o)) return;
+ }
+ #endif
+ __Pyx_call_destructor(p->_writer);
+ (*Py_TYPE(o)->tp_free)(o);
+}
+
+static int __pyx_mp_ass_subscript_9pywrapfst_FarWriter(PyObject *o, PyObject *i, PyObject *v) {
+ if (v) {
+ return __pyx_pw_9pywrapfst_9FarWriter_15__setitem__(o, i, v);
+ }
+ else {
+ PyErr_Format(PyExc_NotImplementedError,
+ "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);
+ return -1;
+ }
+}
+
+static PyMethodDef __pyx_methods_9pywrapfst_FarWriter[] = {
+ {"create", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_5create, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_9FarWriter_4create},
+ {"add", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_7add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_9FarWriter_6add},
+ {"arc_type", (PyCFunction)__pyx_pw_9pywrapfst_9FarWriter_9arc_type, METH_NOARGS, 0},
+ {"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, 0},
+ {0, 0, 0, 0}
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_FarWriter = {
+ 0, /*mp_length*/
+ 0, /*mp_subscript*/
+ __pyx_mp_ass_subscript_9pywrapfst_FarWriter, /*mp_ass_subscript*/
+};
+
+static PyTypeObject __pyx_type_9pywrapfst_FarWriter = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "pywrapfst.FarWriter", /*tp_name*/
+ sizeof(struct __pyx_obj_9pywrapfst_FarWriter), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ __pyx_tp_dealloc_9pywrapfst_FarWriter, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ #if PY_MAJOR_VERSION < 3
+ 0, /*tp_compare*/
+ #endif
+ #if PY_MAJOR_VERSION >= 3
+ 0, /*tp_as_async*/
+ #endif
+ __pyx_pw_9pywrapfst_9FarWriter_3__repr__, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ &__pyx_tp_as_mapping_FarWriter, /*tp_as_mapping*/
+ 0, /*tp_hash*/
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+ "\n (No constructor.)\n\n FAR (\"Fst ARchive\") writer object.\n\n This class is used to write FSTs (of the same arc type) to a FAR on disk. To\n construct a FarWriter, use the `create` class method.\n\n Note that the data is not guaranteed to flush to disk until the FarWriter\n is garbage-collected. If a FarWriter has been assigned to only one variable,\n then calling `del` on that variable should decrement the object's reference\n count from 1 to 0, triggering a flush to disk on the next GC cycle.\n\n Attributes:\n arc_type: A string indicating the arc type.\n far_type: A string indicating the FAR type.\n ", /*tp_doc*/
+ 0, /*tp_traverse*/
+ 0, /*tp_clear*/
+ 0, /*tp_richcompare*/
+ 0, /*tp_weaklistoffset*/
+ 0, /*tp_iter*/
+ 0, /*tp_iternext*/
+ __pyx_methods_9pywrapfst_FarWriter, /*tp_methods*/
+ 0, /*tp_members*/
+ 0, /*tp_getset*/
+ 0, /*tp_base*/
+ 0, /*tp_dict*/
+ 0, /*tp_descr_get*/
+ 0, /*tp_descr_set*/
+ 0, /*tp_dictoffset*/
+ __pyx_pw_9pywrapfst_9FarWriter_1__init__, /*tp_init*/
+ 0, /*tp_alloc*/
+ __pyx_tp_new_9pywrapfst_FarWriter, /*tp_new*/
+ 0, /*tp_free*/
+ 0, /*tp_is_gc*/
+ 0, /*tp_bases*/
+ 0, /*tp_mro*/
+ 0, /*tp_cache*/
+ 0, /*tp_subclasses*/
+ 0, /*tp_weaklist*/
+ 0, /*tp_del*/
+ 0, /*tp_version_tag*/
+ #if PY_VERSION_HEX >= 0x030400a1
+ 0, /*tp_finalize*/
+ #endif
+};
+
+static PyMethodDef __pyx_methods[] = {
+ {"compact_symbol_table", (PyCFunction)__pyx_pw_9pywrapfst_9compact_symbol_table, METH_O, __pyx_doc_9pywrapfst_8compact_symbol_table},
+ {"merge_symbol_table", (PyCFunction)__pyx_pw_9pywrapfst_11merge_symbol_table, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_10merge_symbol_table},
+ {"arcmap", (PyCFunction)__pyx_pw_9pywrapfst_13arcmap, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_12arcmap},
+ {"compose", (PyCFunction)__pyx_pw_9pywrapfst_15compose, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_14compose},
+ {"convert", (PyCFunction)__pyx_pw_9pywrapfst_17convert, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_16convert},
+ {"determinize", (PyCFunction)__pyx_pw_9pywrapfst_19determinize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_18determinize},
+ {"difference", (PyCFunction)__pyx_pw_9pywrapfst_21difference, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_20difference},
+ {"disambiguate", (PyCFunction)__pyx_pw_9pywrapfst_23disambiguate, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_22disambiguate},
+ {"epsnormalize", (PyCFunction)__pyx_pw_9pywrapfst_25epsnormalize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_24epsnormalize},
+ {"equal", (PyCFunction)__pyx_pw_9pywrapfst_27equal, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_26equal},
+ {"equivalent", (PyCFunction)__pyx_pw_9pywrapfst_29equivalent, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_28equivalent},
+ {"intersect", (PyCFunction)__pyx_pw_9pywrapfst_31intersect, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_30intersect},
+ {"isomorphic", (PyCFunction)__pyx_pw_9pywrapfst_33isomorphic, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_32isomorphic},
+ {"prune", (PyCFunction)__pyx_pw_9pywrapfst_35prune, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_34prune},
+ {"push", (PyCFunction)__pyx_pw_9pywrapfst_37push, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_36push},
+ {"randequivalent", (PyCFunction)__pyx_pw_9pywrapfst_39randequivalent, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_38randequivalent},
+ {"randgen", (PyCFunction)__pyx_pw_9pywrapfst_41randgen, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_40randgen},
+ {"replace", (PyCFunction)__pyx_pw_9pywrapfst_43replace, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_42replace},
+ {"reverse", (PyCFunction)__pyx_pw_9pywrapfst_45reverse, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_44reverse},
+ {"rmepsilon", (PyCFunction)__pyx_pw_9pywrapfst_47rmepsilon, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_46rmepsilon},
+ {"shortestpath", (PyCFunction)__pyx_pw_9pywrapfst_51shortestpath, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_50shortestpath},
+ {"statemap", (PyCFunction)__pyx_pw_9pywrapfst_53statemap, METH_VARARGS|METH_KEYWORDS, __pyx_doc_9pywrapfst_52statemap},
+ {"synchronize", (PyCFunction)__pyx_pw_9pywrapfst_55synchronize, METH_O, __pyx_doc_9pywrapfst_54synchronize},
+ {0, 0, 0, 0}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef __pyx_moduledef = {
+ #if PY_VERSION_HEX < 0x03020000
+ { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
+ #else
+ PyModuleDef_HEAD_INIT,
+ #endif
+ "pywrapfst",
+ __pyx_k_Python_interface_to_the_FST_scri, /* m_doc */
+ -1, /* m_size */
+ __pyx_methods /* m_methods */,
+ NULL, /* m_reload */
+ NULL, /* m_traverse */
+ NULL, /* m_clear */
+ NULL /* m_free */
+};
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+ {&__pyx_kp_b_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 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_SORT_PROPERTIES, __pyx_k_ARC_SORT_PROPERTIES, sizeof(__pyx_k_ARC_SORT_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_kp_s_ArcIterator_at_0x_x, __pyx_k_ArcIterator_at_0x_x, sizeof(__pyx_k_ArcIterator_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_kp_s_Arc_at_0x_x, __pyx_k_Arc_at_0x_x, sizeof(__pyx_k_Arc_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_BINARY_PROPERTIES, __pyx_k_BINARY_PROPERTIES, sizeof(__pyx_k_BINARY_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_COACCESSIBLE, __pyx_k_COACCESSIBLE, sizeof(__pyx_k_COACCESSIBLE), 0, 0, 1, 1},
+ {&__pyx_n_s_COPY_PROPERTIES, __pyx_k_COPY_PROPERTIES, sizeof(__pyx_k_COPY_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_CYCLIC, __pyx_k_CYCLIC, sizeof(__pyx_k_CYCLIC), 0, 0, 1, 1},
+ {&__pyx_n_s_CalledProcessError, __pyx_k_CalledProcessError, sizeof(__pyx_k_CalledProcessError), 0, 0, 1, 1},
+ {&__pyx_kp_s_Cannot_construct, __pyx_k_Cannot_construct, sizeof(__pyx_k_Cannot_construct), 0, 0, 1, 0},
+ {&__pyx_kp_s_Cannot_encode_as_string_r, __pyx_k_Cannot_encode_as_string_r, sizeof(__pyx_k_Cannot_encode_as_string_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Cannot_topsort_cyclic_FST, __pyx_k_Cannot_topsort_cyclic_FST, sizeof(__pyx_k_Cannot_topsort_cyclic_FST), 0, 0, 1, 0},
+ {&__pyx_kp_s_Compilation_failed, __pyx_k_Compilation_failed, sizeof(__pyx_k_Compilation_failed), 0, 0, 1, 0},
+ {&__pyx_kp_s_Conversion_to_r_failed, __pyx_k_Conversion_to_r_failed, sizeof(__pyx_k_Conversion_to_r_failed), 0, 0, 1, 0},
+ {&__pyx_kp_s_Conversion_to_r_failed_2, __pyx_k_Conversion_to_r_failed_2, sizeof(__pyx_k_Conversion_to_r_failed_2), 0, 0, 1, 0},
+ {&__pyx_n_s_DELETE_ARC_PROPERTIES, __pyx_k_DELETE_ARC_PROPERTIES, sizeof(__pyx_k_DELETE_ARC_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_DELETE_STATE_PROPERTIES, __pyx_k_DELETE_STATE_PROPERTIES, sizeof(__pyx_k_DELETE_STATE_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_DOT_TSVG, __pyx_k_DOT_TSVG, sizeof(__pyx_k_DOT_TSVG), 0, 0, 1, 1},
+ {&__pyx_n_s_EPSILONS, __pyx_k_EPSILONS, sizeof(__pyx_k_EPSILONS), 0, 0, 1, 1},
+ {&__pyx_n_s_ERROR, __pyx_k_ERROR, sizeof(__pyx_k_ERROR), 0, 0, 1, 1},
+ {&__pyx_n_s_EXPANDED, __pyx_k_EXPANDED, sizeof(__pyx_k_EXPANDED), 0, 0, 1, 1},
+ {&__pyx_n_s_EXTRINSIC_PROPERTIES, __pyx_k_EXTRINSIC_PROPERTIES, sizeof(__pyx_k_EXTRINSIC_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_kp_s_EncodeMapper_at_0x_x, __pyx_k_EncodeMapper_at_0x_x, sizeof(__pyx_k_EncodeMapper_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_kp_s_Equivalence_test_encountered_err, __pyx_k_Equivalence_test_encountered_err, sizeof(__pyx_k_Equivalence_test_encountered_err), 0, 0, 1, 0},
+ {&__pyx_n_s_FST_PROPERTIES, __pyx_k_FST_PROPERTIES, sizeof(__pyx_k_FST_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_kp_s_FarReader_at_0x_x, __pyx_k_FarReader_at_0x_x, sizeof(__pyx_k_FarReader_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_kp_s_FarWriter_at_0x_x, __pyx_k_FarWriter_at_0x_x, sizeof(__pyx_k_FarWriter_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_Fst, __pyx_k_Fst, sizeof(__pyx_k_Fst), 0, 0, 1, 1},
+ {&__pyx_n_s_FstArgError, __pyx_k_FstArgError, sizeof(__pyx_k_FstArgError), 0, 0, 1, 1},
+ {&__pyx_n_s_FstBadWeightError, __pyx_k_FstBadWeightError, sizeof(__pyx_k_FstBadWeightError), 0, 0, 1, 1},
+ {&__pyx_n_s_FstDeletedConstructorError, __pyx_k_FstDeletedConstructorError, sizeof(__pyx_k_FstDeletedConstructorError), 0, 0, 1, 1},
+ {&__pyx_n_s_FstError, __pyx_k_FstError, sizeof(__pyx_k_FstError), 0, 0, 1, 1},
+ {&__pyx_n_s_FstIOError, __pyx_k_FstIOError, sizeof(__pyx_k_FstIOError), 0, 0, 1, 1},
+ {&__pyx_n_s_FstIndexError, __pyx_k_FstIndexError, sizeof(__pyx_k_FstIndexError), 0, 0, 1, 1},
+ {&__pyx_n_s_FstOpError, __pyx_k_FstOpError, sizeof(__pyx_k_FstOpError), 0, 0, 1, 1},
+ {&__pyx_n_s_FstUnknownWeightTypeError, __pyx_k_FstUnknownWeightTypeError, sizeof(__pyx_k_FstUnknownWeightTypeError), 0, 0, 1, 1},
+ {&__pyx_kp_s_Fst_SymbolTable_r_at_0x_x, __pyx_k_Fst_SymbolTable_r_at_0x_x, sizeof(__pyx_k_Fst_SymbolTable_r_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_Fst___new, __pyx_k_Fst___new, sizeof(__pyx_k_Fst___new), 0, 0, 1, 1},
+ {&__pyx_kp_s_Fst_arc_type_standard_Construct, __pyx_k_Fst_arc_type_standard_Construct, sizeof(__pyx_k_Fst_arc_type_standard_Construct), 0, 0, 1, 0},
+ {&__pyx_kp_s_Fst_at_0x_x, __pyx_k_Fst_at_0x_x, sizeof(__pyx_k_Fst_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_Fst_read, __pyx_k_Fst_read, sizeof(__pyx_k_Fst_read), 0, 0, 1, 1},
+ {&__pyx_n_s_Fst_read_from_string, __pyx_k_Fst_read_from_string, sizeof(__pyx_k_Fst_read_from_string), 0, 0, 1, 1},
+ {&__pyx_n_s_INITIAL_ACYCLIC, __pyx_k_INITIAL_ACYCLIC, sizeof(__pyx_k_INITIAL_ACYCLIC), 0, 0, 1, 1},
+ {&__pyx_n_s_INITIAL_CYCLIC, __pyx_k_INITIAL_CYCLIC, sizeof(__pyx_k_INITIAL_CYCLIC), 0, 0, 1, 1},
+ {&__pyx_n_s_INTRINSIC_PROPERTIES, __pyx_k_INTRINSIC_PROPERTIES, sizeof(__pyx_k_INTRINSIC_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_IOError, __pyx_k_IOError, sizeof(__pyx_k_IOError), 0, 0, 1, 1},
+ {&__pyx_n_s_I_DETERMINISTIC, __pyx_k_I_DETERMINISTIC, sizeof(__pyx_k_I_DETERMINISTIC), 0, 0, 1, 1},
+ {&__pyx_n_s_I_EPSILONS, __pyx_k_I_EPSILONS, sizeof(__pyx_k_I_EPSILONS), 0, 0, 1, 1},
+ {&__pyx_n_s_I_LABEL_INVARIANT_PROPERTIES, __pyx_k_I_LABEL_INVARIANT_PROPERTIES, sizeof(__pyx_k_I_LABEL_INVARIANT_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_I_LABEL_SORTED, __pyx_k_I_LABEL_SORTED, sizeof(__pyx_k_I_LABEL_SORTED), 0, 0, 1, 1},
+ {&__pyx_kp_s_Incompatible_or_invalid_arc_type, __pyx_k_Incompatible_or_invalid_arc_type, sizeof(__pyx_k_Incompatible_or_invalid_arc_type), 0, 0, 1, 0},
+ {&__pyx_kp_s_Incompatible_or_invalid_weight_t, __pyx_k_Incompatible_or_invalid_weight_t, sizeof(__pyx_k_Incompatible_or_invalid_weight_t), 0, 0, 1, 0},
+ {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1},
+ {&__pyx_kp_s_Invalid_operator_r, __pyx_k_Invalid_operator_r, sizeof(__pyx_k_Invalid_operator_r), 0, 0, 1, 0},
+ {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1},
+ {&__pyx_kp_s_Key_out_of_order, __pyx_k_Key_out_of_order, sizeof(__pyx_k_Key_out_of_order), 0, 0, 1, 0},
+ {&__pyx_n_s_MUTABLE, __pyx_k_MUTABLE, sizeof(__pyx_k_MUTABLE), 0, 0, 1, 1},
+ {&__pyx_kp_s_MutableArcIterator_at_0x_x, __pyx_k_MutableArcIterator_at_0x_x, sizeof(__pyx_k_MutableArcIterator_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_NEG_TRINARY_PROPERTIES, __pyx_k_NEG_TRINARY_PROPERTIES, sizeof(__pyx_k_NEG_TRINARY_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_NON_I_DETERMINISTIC, __pyx_k_NON_I_DETERMINISTIC, sizeof(__pyx_k_NON_I_DETERMINISTIC), 0, 0, 1, 1},
+ {&__pyx_n_s_NON_O_DETERMINISTIC, __pyx_k_NON_O_DETERMINISTIC, sizeof(__pyx_k_NON_O_DETERMINISTIC), 0, 0, 1, 1},
+ {&__pyx_n_s_NOT_ACCEPTOR, __pyx_k_NOT_ACCEPTOR, sizeof(__pyx_k_NOT_ACCEPTOR), 0, 0, 1, 1},
+ {&__pyx_n_s_NOT_ACCESSIBLE, __pyx_k_NOT_ACCESSIBLE, sizeof(__pyx_k_NOT_ACCESSIBLE), 0, 0, 1, 1},
+ {&__pyx_n_s_NOT_COACCESSIBLE, __pyx_k_NOT_COACCESSIBLE, sizeof(__pyx_k_NOT_COACCESSIBLE), 0, 0, 1, 1},
+ {&__pyx_n_s_NOT_I_LABEL_SORTED, __pyx_k_NOT_I_LABEL_SORTED, sizeof(__pyx_k_NOT_I_LABEL_SORTED), 0, 0, 1, 1},
+ {&__pyx_n_s_NOT_O_LABEL_SORTED, __pyx_k_NOT_O_LABEL_SORTED, sizeof(__pyx_k_NOT_O_LABEL_SORTED), 0, 0, 1, 1},
+ {&__pyx_n_s_NOT_STRING, __pyx_k_NOT_STRING, sizeof(__pyx_k_NOT_STRING), 0, 0, 1, 1},
+ {&__pyx_n_s_NOT_TOP_SORTED, __pyx_k_NOT_TOP_SORTED, sizeof(__pyx_k_NOT_TOP_SORTED), 0, 0, 1, 1},
+ {&__pyx_n_s_NO_EPSILONS, __pyx_k_NO_EPSILONS, sizeof(__pyx_k_NO_EPSILONS), 0, 0, 1, 1},
+ {&__pyx_n_s_NO_I_EPSILONS, __pyx_k_NO_I_EPSILONS, sizeof(__pyx_k_NO_I_EPSILONS), 0, 0, 1, 1},
+ {&__pyx_n_s_NO_O_EPSILONS, __pyx_k_NO_O_EPSILONS, sizeof(__pyx_k_NO_O_EPSILONS), 0, 0, 1, 1},
+ {&__pyx_n_s_NULL_PROPERTIES, __pyx_k_NULL_PROPERTIES, sizeof(__pyx_k_NULL_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_NoWeight, __pyx_k_NoWeight, sizeof(__pyx_k_NoWeight), 0, 0, 1, 1},
+ {&__pyx_kp_s_No_new_SymbolTables_specified, __pyx_k_No_new_SymbolTables_specified, sizeof(__pyx_k_No_new_SymbolTables_specified), 0, 0, 1, 0},
+ {&__pyx_kp_s_No_relabeling_pairs_specified, __pyx_k_No_relabeling_pairs_specified, sizeof(__pyx_k_No_relabeling_pairs_specified), 0, 0, 1, 0},
+ {&__pyx_n_s_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_n_s_One, __pyx_k_One, sizeof(__pyx_k_One), 0, 0, 1, 1},
+ {&__pyx_kp_s_Open_failed_r, __pyx_k_Open_failed_r, sizeof(__pyx_k_Open_failed_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Operation_failed, __pyx_k_Operation_failed, sizeof(__pyx_k_Operation_failed), 0, 0, 1, 0},
+ {&__pyx_n_s_PIPE, __pyx_k_PIPE, sizeof(__pyx_k_PIPE), 0, 0, 1, 1},
+ {&__pyx_n_s_POS_TRINARY_PROPERTIES, __pyx_k_POS_TRINARY_PROPERTIES, sizeof(__pyx_k_POS_TRINARY_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_Popen, __pyx_k_Popen, sizeof(__pyx_k_Popen), 0, 0, 1, 1},
+ {&__pyx_n_s_RM_SUPERFINAL_PROPERTIES, __pyx_k_RM_SUPERFINAL_PROPERTIES, sizeof(__pyx_k_RM_SUPERFINAL_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_kp_s_Random_equivalence_test_encounte, __pyx_k_Random_equivalence_test_encounte, sizeof(__pyx_k_Random_equivalence_test_encounte), 0, 0, 1, 0},
+ {&__pyx_kp_s_Read_failed_r, __pyx_k_Read_failed_r, sizeof(__pyx_k_Read_failed_r), 0, 0, 1, 0},
+ {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
+ {&__pyx_n_s_SET_ARC_PROPERTIES, __pyx_k_SET_ARC_PROPERTIES, sizeof(__pyx_k_SET_ARC_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_SET_FINAL_PROPERTIES, __pyx_k_SET_FINAL_PROPERTIES, sizeof(__pyx_k_SET_FINAL_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_SET_START_PROPERTIES, __pyx_k_SET_START_PROPERTIES, sizeof(__pyx_k_SET_START_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_STATE_SORT_PROPERTIES, __pyx_k_STATE_SORT_PROPERTIES, sizeof(__pyx_k_STATE_SORT_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_n_s_STRING, __pyx_k_STRING, sizeof(__pyx_k_STRING), 0, 0, 1, 1},
+ {&__pyx_kp_s_StateIterator_at_0x_x, __pyx_k_StateIterator_at_0x_x, sizeof(__pyx_k_StateIterator_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_kp_s_State_index_out_of_range, __pyx_k_State_index_out_of_range, sizeof(__pyx_k_State_index_out_of_range), 0, 0, 1, 0},
+ {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1},
+ {&__pyx_kp_s_SymbolTableIterator_at_0x_x, __pyx_k_SymbolTableIterator_at_0x_x, sizeof(__pyx_k_SymbolTableIterator_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_kp_s_SymbolTable_r_at_0x_x, __pyx_k_SymbolTable_r_at_0x_x, sizeof(__pyx_k_SymbolTable_r_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_TOP_SORTED, __pyx_k_TOP_SORTED, sizeof(__pyx_k_TOP_SORTED), 0, 0, 1, 1},
+ {&__pyx_n_s_TRINARY_PROPERTIES, __pyx_k_TRINARY_PROPERTIES, sizeof(__pyx_k_TRINARY_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_kp_s_Tsvg, __pyx_k_Tsvg, sizeof(__pyx_k_Tsvg), 0, 0, 1, 0},
+ {&__pyx_n_s_UNWEIGHTED, __pyx_k_UNWEIGHTED, sizeof(__pyx_k_UNWEIGHTED), 0, 0, 1, 1},
+ {&__pyx_n_s_UNWEIGHTED_CYCLES, __pyx_k_UNWEIGHTED_CYCLES, sizeof(__pyx_k_UNWEIGHTED_CYCLES), 0, 0, 1, 1},
+ {&__pyx_kp_s_Unknown_arc_type_r, __pyx_k_Unknown_arc_type_r, sizeof(__pyx_k_Unknown_arc_type_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Unknown_compose_filter_type_r, __pyx_k_Unknown_compose_filter_type_r, sizeof(__pyx_k_Unknown_compose_filter_type_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Unknown_determinization_type_r, __pyx_k_Unknown_determinization_type_r, sizeof(__pyx_k_Unknown_determinization_type_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Unknown_map_type_r, __pyx_k_Unknown_map_type_r, sizeof(__pyx_k_Unknown_map_type_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Unknown_queue_type_r, __pyx_k_Unknown_queue_type_r, sizeof(__pyx_k_Unknown_queue_type_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Unknown_random_arc_selection_typ, __pyx_k_Unknown_random_arc_selection_typ, sizeof(__pyx_k_Unknown_random_arc_selection_typ), 0, 0, 1, 0},
+ {&__pyx_kp_s_Unknown_replace_label_type_r, __pyx_k_Unknown_replace_label_type_r, sizeof(__pyx_k_Unknown_replace_label_type_r), 0, 0, 1, 0},
+ {&__pyx_kp_s_Unknown_sort_type_r, __pyx_k_Unknown_sort_type_r, sizeof(__pyx_k_Unknown_sort_type_r), 0, 0, 1, 0},
+ {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+ {&__pyx_n_s_WEIGHTED, __pyx_k_WEIGHTED, sizeof(__pyx_k_WEIGHTED), 0, 0, 1, 1},
+ {&__pyx_n_s_WEIGHTED_CYCLES, __pyx_k_WEIGHTED_CYCLES, sizeof(__pyx_k_WEIGHTED_CYCLES), 0, 0, 1, 1},
+ {&__pyx_n_s_WEIGHT_INVARIANT_PROPERTIES, __pyx_k_WEIGHT_INVARIANT_PROPERTIES, sizeof(__pyx_k_WEIGHT_INVARIANT_PROPERTIES), 0, 0, 1, 1},
+ {&__pyx_kp_s_Weight_at_0x_x, __pyx_k_Weight_at_0x_x, sizeof(__pyx_k_Weight_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_WriteToString, __pyx_k_WriteToString, sizeof(__pyx_k_WriteToString), 0, 0, 1, 1},
+ {&__pyx_kp_s_Write_failed_r, __pyx_k_Write_failed_r, sizeof(__pyx_k_Write_failed_r), 0, 0, 1, 0},
+ {&__pyx_n_s_Zero, __pyx_k_Zero, sizeof(__pyx_k_Zero), 0, 0, 1, 1},
+ {&__pyx_n_s_acceptor, __pyx_k_acceptor, sizeof(__pyx_k_acceptor), 0, 0, 1, 1},
+ {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1},
+ {&__pyx_n_s_add_state, __pyx_k_add_state, sizeof(__pyx_k_add_state), 0, 0, 1, 1},
+ {&__pyx_n_s_add_symbol, __pyx_k_add_symbol, sizeof(__pyx_k_add_symbol), 0, 0, 1, 1},
+ {&__pyx_n_s_add_table, __pyx_k_add_table, sizeof(__pyx_k_add_table), 0, 0, 1, 1},
+ {&__pyx_n_s_allow_negative_labels, __pyx_k_allow_negative_labels, sizeof(__pyx_k_allow_negative_labels), 0, 0, 1, 1},
+ {&__pyx_n_s_allow_nondet, __pyx_k_allow_nondet, sizeof(__pyx_k_allow_nondet), 0, 0, 1, 1},
+ {&__pyx_n_s_arc, __pyx_k_arc, sizeof(__pyx_k_arc), 0, 0, 1, 1},
+ {&__pyx_n_s_arc_type, __pyx_k_arc_type, sizeof(__pyx_k_arc_type), 0, 0, 1, 1},
+ {&__pyx_n_s_arcs, __pyx_k_arcs, sizeof(__pyx_k_arcs), 0, 0, 1, 1},
+ {&__pyx_n_s_atexit, __pyx_k_atexit, sizeof(__pyx_k_atexit), 0, 0, 1, 1},
+ {&__pyx_n_s_attach_new_isymbols, __pyx_k_attach_new_isymbols, sizeof(__pyx_k_attach_new_isymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_attach_new_osymbols, __pyx_k_attach_new_osymbols, sizeof(__pyx_k_attach_new_osymbols), 0, 0, 1, 1},
+ {&__pyx_n_b_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 0, 0, 1},
+ {&__pyx_n_s_available_key, __pyx_k_available_key, sizeof(__pyx_k_available_key), 0, 0, 1, 1},
+ {&__pyx_n_s_call_arc_labeling, __pyx_k_call_arc_labeling, sizeof(__pyx_k_call_arc_labeling), 0, 0, 1, 1},
+ {&__pyx_n_s_cf, __pyx_k_cf, sizeof(__pyx_k_cf), 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_closure_plus, __pyx_k_closure_plus, sizeof(__pyx_k_closure_plus), 0, 0, 1, 1},
+ {&__pyx_n_s_cls, __pyx_k_cls, sizeof(__pyx_k_cls), 0, 0, 1, 1},
+ {&__pyx_n_s_communicate, __pyx_k_communicate, sizeof(__pyx_k_communicate), 0, 0, 1, 1},
+ {&__pyx_n_s_compile, __pyx_k_compile, sizeof(__pyx_k_compile), 0, 0, 1, 1},
+ {&__pyx_n_s_connect, __pyx_k_connect, sizeof(__pyx_k_connect), 0, 0, 1, 1},
+ {&__pyx_kp_s_const_EncodeMapper_SymbolTable, __pyx_k_const_EncodeMapper_SymbolTable, sizeof(__pyx_k_const_EncodeMapper_SymbolTable), 0, 0, 1, 0},
+ {&__pyx_kp_s_const_Fst_SymbolTable_r_at_0x_x, __pyx_k_const_Fst_SymbolTable_r_at_0x_x, sizeof(__pyx_k_const_Fst_SymbolTable_r_at_0x_x), 0, 0, 1, 0},
+ {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1},
+ {&__pyx_n_s_create, __pyx_k_create, sizeof(__pyx_k_create), 0, 0, 1, 1},
+ {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1},
+ {&__pyx_n_b_default, __pyx_k_default, sizeof(__pyx_k_default), 0, 0, 0, 1},
+ {&__pyx_n_s_delta, __pyx_k_delta, sizeof(__pyx_k_delta), 0, 0, 1, 1},
+ {&__pyx_n_s_distance, __pyx_k_distance, sizeof(__pyx_k_distance), 0, 0, 1, 1},
+ {&__pyx_n_s_divide, __pyx_k_divide, sizeof(__pyx_k_divide), 0, 0, 1, 1},
+ {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1},
+ {&__pyx_n_s_done, __pyx_k_done, sizeof(__pyx_k_done), 0, 0, 1, 1},
+ {&__pyx_n_s_dot, __pyx_k_dot, sizeof(__pyx_k_dot), 0, 0, 1, 1},
+ {&__pyx_n_s_draw, __pyx_k_draw, sizeof(__pyx_k_draw), 0, 0, 1, 1},
+ {&__pyx_n_s_dt, __pyx_k_dt, sizeof(__pyx_k_dt), 0, 0, 1, 1},
+ {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
+ {&__pyx_n_s_encode_labels, __pyx_k_encode_labels, sizeof(__pyx_k_encode_labels), 0, 0, 1, 1},
+ {&__pyx_n_s_encode_weights, __pyx_k_encode_weights, sizeof(__pyx_k_encode_weights), 0, 0, 1, 1},
+ {&__pyx_n_s_eps_norm_output, __pyx_k_eps_norm_output, sizeof(__pyx_k_eps_norm_output), 0, 0, 1, 1},
+ {&__pyx_n_s_epsilon_on_replace, __pyx_k_epsilon_on_replace, sizeof(__pyx_k_epsilon_on_replace), 0, 0, 1, 1},
+ {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1},
+ {&__pyx_n_s_far_type, __pyx_k_far_type, sizeof(__pyx_k_far_type), 0, 0, 1, 1},
+ {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1},
+ {&__pyx_n_s_final, __pyx_k_final, sizeof(__pyx_k_final), 0, 0, 1, 1},
+ {&__pyx_n_s_find, __pyx_k_find, sizeof(__pyx_k_find), 0, 0, 1, 1},
+ {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1},
+ {&__pyx_n_s_fontsize, __pyx_k_fontsize, sizeof(__pyx_k_fontsize), 0, 0, 1, 1},
+ {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1},
+ {&__pyx_n_s_fst_error_fatal_old, __pyx_k_fst_error_fatal_old, sizeof(__pyx_k_fst_error_fatal_old), 0, 0, 1, 1},
+ {&__pyx_n_s_fst_string, __pyx_k_fst_string, sizeof(__pyx_k_fst_string), 0, 0, 1, 1},
+ {&__pyx_n_s_fst_type, __pyx_k_fst_type, sizeof(__pyx_k_fst_type), 0, 0, 1, 1},
+ {&__pyx_n_b_functional, __pyx_k_functional, sizeof(__pyx_k_functional), 0, 0, 0, 1},
+ {&__pyx_n_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_height, __pyx_k_height, sizeof(__pyx_k_height), 0, 0, 1, 1},
+ {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1},
+ {&__pyx_n_b_identity, __pyx_k_identity, sizeof(__pyx_k_identity), 0, 0, 0, 1},
+ {&__pyx_n_s_ifst, __pyx_k_ifst, sizeof(__pyx_k_ifst), 0, 0, 1, 1},
+ {&__pyx_n_s_ifst1, __pyx_k_ifst1, sizeof(__pyx_k_ifst1), 0, 0, 1, 1},
+ {&__pyx_n_s_ifst2, __pyx_k_ifst2, sizeof(__pyx_k_ifst2), 0, 0, 1, 1},
+ {&__pyx_n_b_ilabel, __pyx_k_ilabel, sizeof(__pyx_k_ilabel), 0, 0, 0, 1},
+ {&__pyx_n_s_ilabel, __pyx_k_ilabel, sizeof(__pyx_k_ilabel), 0, 0, 1, 1},
+ {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+ {&__pyx_kp_s_incompatible_or_invalid_weight, __pyx_k_incompatible_or_invalid_weight, sizeof(__pyx_k_incompatible_or_invalid_weight), 0, 0, 1, 0},
+ {&__pyx_n_s_increment_subsequential_label, __pyx_k_increment_subsequential_label, sizeof(__pyx_k_increment_subsequential_label), 0, 0, 1, 1},
+ {&__pyx_n_b_input, __pyx_k_input, sizeof(__pyx_k_input), 0, 0, 0, 1},
+ {&__pyx_n_s_input_symbols, __pyx_k_input_symbols, sizeof(__pyx_k_input_symbols), 0, 0, 1, 1},
+ {&__pyx_n_s_input_table, __pyx_k_input_table, sizeof(__pyx_k_input_table), 0, 0, 1, 1},
+ {&__pyx_n_s_ipairs, __pyx_k_ipairs, sizeof(__pyx_k_ipairs), 0, 0, 1, 1},
+ {&__pyx_n_s_isymbols, __pyx_k_isymbols, sizeof(__pyx_k_isymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_it, __pyx_k_it, sizeof(__pyx_k_it), 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_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1},
+ {&__pyx_n_s_max_length, __pyx_k_max_length, sizeof(__pyx_k_max_length), 0, 0, 1, 1},
+ {&__pyx_n_s_member, __pyx_k_member, sizeof(__pyx_k_member), 0, 0, 1, 1},
+ {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1},
+ {&__pyx_n_s_missing_sym, __pyx_k_missing_sym, sizeof(__pyx_k_missing_sym), 0, 0, 1, 1},
+ {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1},
+ {&__pyx_n_s_mt, __pyx_k_mt, sizeof(__pyx_k_mt), 0, 0, 1, 1},
+ {&__pyx_n_s_mutable_arcs, __pyx_k_mutable_arcs, sizeof(__pyx_k_mutable_arcs), 0, 0, 1, 1},
+ {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1},
+ {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
+ {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1},
+ {&__pyx_n_b_neither, __pyx_k_neither, sizeof(__pyx_k_neither), 0, 0, 0, 1},
+ {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1},
+ {&__pyx_n_s_new_isymbols, __pyx_k_new_isymbols, sizeof(__pyx_k_new_isymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_new_osymbols, __pyx_k_new_osymbols, sizeof(__pyx_k_new_osymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_next, __pyx_k_next, sizeof(__pyx_k_next), 0, 0, 1, 1},
+ {&__pyx_n_s_nextstate, __pyx_k_nextstate, sizeof(__pyx_k_nextstate), 0, 0, 1, 1},
+ {&__pyx_n_s_nodesep, __pyx_k_nodesep, sizeof(__pyx_k_nodesep), 0, 0, 1, 1},
+ {&__pyx_n_s_npath, __pyx_k_npath, sizeof(__pyx_k_npath), 0, 0, 1, 1},
+ {&__pyx_n_s_nshortest, __pyx_k_nshortest, sizeof(__pyx_k_nshortest), 0, 0, 1, 1},
+ {&__pyx_n_s_nstate, __pyx_k_nstate, sizeof(__pyx_k_nstate), 0, 0, 1, 1},
+ {&__pyx_n_s_num_arcs, __pyx_k_num_arcs, sizeof(__pyx_k_num_arcs), 0, 0, 1, 1},
+ {&__pyx_n_s_num_input_epsilons, __pyx_k_num_input_epsilons, sizeof(__pyx_k_num_input_epsilons), 0, 0, 1, 1},
+ {&__pyx_n_s_num_output_epsilons, __pyx_k_num_output_epsilons, sizeof(__pyx_k_num_output_epsilons), 0, 0, 1, 1},
+ {&__pyx_n_s_num_states, __pyx_k_num_states, sizeof(__pyx_k_num_states), 0, 0, 1, 1},
+ {&__pyx_n_s_num_symbols, __pyx_k_num_symbols, sizeof(__pyx_k_num_symbols), 0, 0, 1, 1},
+ {&__pyx_n_s_numbers, __pyx_k_numbers, sizeof(__pyx_k_numbers), 0, 0, 1, 1},
+ {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1},
+ {&__pyx_n_s_olabel, __pyx_k_olabel, sizeof(__pyx_k_olabel), 0, 0, 1, 1},
+ {&__pyx_n_s_old_isymbols, __pyx_k_old_isymbols, sizeof(__pyx_k_old_isymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_old_osymbols, __pyx_k_old_osymbols, sizeof(__pyx_k_old_osymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_opairs, __pyx_k_opairs, sizeof(__pyx_k_opairs), 0, 0, 1, 1},
+ {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1},
+ {&__pyx_n_s_osymbols, __pyx_k_osymbols, sizeof(__pyx_k_osymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_output_symbols, __pyx_k_output_symbols, sizeof(__pyx_k_output_symbols), 0, 0, 1, 1},
+ {&__pyx_n_s_pairs, __pyx_k_pairs, sizeof(__pyx_k_pairs), 0, 0, 1, 1},
+ {&__pyx_n_s_plus, __pyx_k_plus, sizeof(__pyx_k_plus), 0, 0, 1, 1},
+ {&__pyx_n_s_portrait, __pyx_k_portrait, sizeof(__pyx_k_portrait), 0, 0, 1, 1},
+ {&__pyx_n_s_position, __pyx_k_position, sizeof(__pyx_k_position), 0, 0, 1, 1},
+ {&__pyx_n_s_potentials, __pyx_k_potentials, sizeof(__pyx_k_potentials), 0, 0, 1, 1},
+ {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1},
+ {&__pyx_n_s_precision, __pyx_k_precision, sizeof(__pyx_k_precision), 0, 0, 1, 1},
+ {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},
+ {&__pyx_n_s_project_output, __pyx_k_project_output, sizeof(__pyx_k_project_output), 0, 0, 1, 1},
+ {&__pyx_n_s_properties, __pyx_k_properties, sizeof(__pyx_k_properties), 0, 0, 1, 1},
+ {&__pyx_n_s_props, __pyx_k_props, sizeof(__pyx_k_props), 0, 0, 1, 1},
+ {&__pyx_n_s_push_labels, __pyx_k_push_labels, sizeof(__pyx_k_push_labels), 0, 0, 1, 1},
+ {&__pyx_n_s_push_weights, __pyx_k_push_weights, sizeof(__pyx_k_push_weights), 0, 0, 1, 1},
+ {&__pyx_kp_b_pywrapfst, __pyx_k_pywrapfst, sizeof(__pyx_k_pywrapfst), 0, 0, 0, 0},
+ {&__pyx_n_s_pywrapfst_2, __pyx_k_pywrapfst_2, sizeof(__pyx_k_pywrapfst_2), 0, 0, 1, 1},
+ {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1},
+ {&__pyx_n_s_qt, __pyx_k_qt, sizeof(__pyx_k_qt), 0, 0, 1, 1},
+ {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1},
+ {&__pyx_n_s_ranksep, __pyx_k_ranksep, sizeof(__pyx_k_ranksep), 0, 0, 1, 1},
+ {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1},
+ {&__pyx_n_s_read_from_string, __pyx_k_read_from_string, sizeof(__pyx_k_read_from_string), 0, 0, 1, 1},
+ {&__pyx_n_s_read_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_register, __pyx_k_register, sizeof(__pyx_k_register), 0, 0, 1, 1},
+ {&__pyx_n_s_remove_common_affix, __pyx_k_remove_common_affix, sizeof(__pyx_k_remove_common_affix), 0, 0, 1, 1},
+ {&__pyx_n_s_remove_total_weight, __pyx_k_remove_total_weight, sizeof(__pyx_k_remove_total_weight), 0, 0, 1, 1},
+ {&__pyx_n_b_repr_svg, __pyx_k_repr_svg, sizeof(__pyx_k_repr_svg), 0, 0, 0, 1},
+ {&__pyx_n_s_require_superinitial, __pyx_k_require_superinitial, sizeof(__pyx_k_require_superinitial), 0, 0, 1, 1},
+ {&__pyx_n_s_reset, __pyx_k_reset, sizeof(__pyx_k_reset), 0, 0, 1, 1},
+ {&__pyx_n_s_reset_fst_error_fatal, __pyx_k_reset_fst_error_fatal, sizeof(__pyx_k_reset_fst_error_fatal), 0, 0, 1, 1},
+ {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1},
+ {&__pyx_n_s_return_arc_labeling, __pyx_k_return_arc_labeling, sizeof(__pyx_k_return_arc_labeling), 0, 0, 1, 1},
+ {&__pyx_n_s_return_label, __pyx_k_return_label, sizeof(__pyx_k_return_label), 0, 0, 1, 1},
+ {&__pyx_n_s_returncode, __pyx_k_returncode, sizeof(__pyx_k_returncode), 0, 0, 1, 1},
+ {&__pyx_n_s_reverse, __pyx_k_reverse, sizeof(__pyx_k_reverse), 0, 0, 1, 1},
+ {&__pyx_n_s_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 0, 1, 1},
+ {&__pyx_n_s_seed, __pyx_k_seed, sizeof(__pyx_k_seed), 0, 0, 1, 1},
+ {&__pyx_n_s_seek, __pyx_k_seek, sizeof(__pyx_k_seek), 0, 0, 1, 1},
+ {&__pyx_n_s_select, __pyx_k_select, sizeof(__pyx_k_select), 0, 0, 1, 1},
+ {&__pyx_n_s_set_flags, __pyx_k_set_flags, sizeof(__pyx_k_set_flags), 0, 0, 1, 1},
+ {&__pyx_n_s_set_input_symbols, __pyx_k_set_input_symbols, sizeof(__pyx_k_set_input_symbols), 0, 0, 1, 1},
+ {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1},
+ {&__pyx_n_s_set_output_symbols, __pyx_k_set_output_symbols, sizeof(__pyx_k_set_output_symbols), 0, 0, 1, 1},
+ {&__pyx_n_s_set_value, __pyx_k_set_value, sizeof(__pyx_k_set_value), 0, 0, 1, 1},
+ {&__pyx_n_s_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_ssymbols, __pyx_k_ssymbols, sizeof(__pyx_k_ssymbols), 0, 0, 1, 1},
+ {&__pyx_n_s_st, __pyx_k_st, sizeof(__pyx_k_st), 0, 0, 1, 1},
+ {&__pyx_n_b_standard, __pyx_k_standard, sizeof(__pyx_k_standard), 0, 0, 0, 1},
+ {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1},
+ {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1},
+ {&__pyx_n_s_states, __pyx_k_states, sizeof(__pyx_k_states), 0, 0, 1, 1},
+ {&__pyx_n_s_staticmethod, __pyx_k_staticmethod, sizeof(__pyx_k_staticmethod), 0, 0, 1, 1},
+ {&__pyx_n_s_stderr, __pyx_k_stderr, sizeof(__pyx_k_stderr), 0, 0, 1, 1},
+ {&__pyx_n_s_stdin, __pyx_k_stdin, sizeof(__pyx_k_stdin), 0, 0, 1, 1},
+ {&__pyx_n_s_stdout, __pyx_k_stdout, sizeof(__pyx_k_stdout), 0, 0, 1, 1},
+ {&__pyx_n_s_subprocess, __pyx_k_subprocess, sizeof(__pyx_k_subprocess), 0, 0, 1, 1},
+ {&__pyx_n_s_subsequential_label, __pyx_k_subsequential_label, sizeof(__pyx_k_subsequential_label), 0, 0, 1, 1},
+ {&__pyx_n_s_symbol, __pyx_k_symbol, sizeof(__pyx_k_symbol), 0, 0, 1, 1},
+ {&__pyx_n_s_syms, __pyx_k_syms, sizeof(__pyx_k_syms), 0, 0, 1, 1},
+ {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+ {&__pyx_n_s_test_2, __pyx_k_test_2, sizeof(__pyx_k_test_2), 0, 0, 1, 1},
+ {&__pyx_n_s_text, __pyx_k_text, sizeof(__pyx_k_text), 0, 0, 1, 1},
+ {&__pyx_n_s_times, __pyx_k_times, sizeof(__pyx_k_times), 0, 0, 1, 1},
+ {&__pyx_n_s_title, __pyx_k_title, sizeof(__pyx_k_title), 0, 0, 1, 1},
+ {&__pyx_n_s_to_final, __pyx_k_to_final, sizeof(__pyx_k_to_final), 0, 0, 1, 1},
+ {&__pyx_n_s_to_string, __pyx_k_to_string, sizeof(__pyx_k_to_string), 0, 0, 1, 1},
+ {&__pyx_n_b_tropical, __pyx_k_tropical, sizeof(__pyx_k_tropical), 0, 0, 0, 1},
+ {&__pyx_n_s_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 0, 1, 1},
+ {&__pyx_n_b_uniform, __pyx_k_uniform, sizeof(__pyx_k_uniform), 0, 0, 0, 1},
+ {&__pyx_n_s_unique, __pyx_k_unique, sizeof(__pyx_k_unique), 0, 0, 1, 1},
+ {&__pyx_kp_b_unspecified, __pyx_k_unspecified, sizeof(__pyx_k_unspecified), 0, 0, 0, 0},
+ {&__pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_k_usr_local_google_home_kbg_scrat, sizeof(__pyx_k_usr_local_google_home_kbg_scrat), 0, 0, 1, 0},
+ {&__pyx_n_s_utf8, __pyx_k_utf8, sizeof(__pyx_k_utf8), 0, 0, 1, 1},
+ {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
+ {&__pyx_n_b_vector, __pyx_k_vector, sizeof(__pyx_k_vector), 0, 0, 0, 1},
+ {&__pyx_n_s_verify, __pyx_k_verify, sizeof(__pyx_k_verify), 0, 0, 1, 1},
+ {&__pyx_n_s_vertical, __pyx_k_vertical, sizeof(__pyx_k_vertical), 0, 0, 1, 1},
+ {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1},
+ {&__pyx_n_s_warning, __pyx_k_warning, sizeof(__pyx_k_warning), 0, 0, 1, 1},
+ {&__pyx_n_s_weight, __pyx_k_weight, sizeof(__pyx_k_weight), 0, 0, 1, 1},
+ {&__pyx_n_s_weight_type, __pyx_k_weight_type, sizeof(__pyx_k_weight_type), 0, 0, 1, 1},
+ {&__pyx_n_s_weighted, __pyx_k_weighted, sizeof(__pyx_k_weighted), 0, 0, 1, 1},
+ {&__pyx_n_s_width, __pyx_k_width, sizeof(__pyx_k_width), 0, 0, 1, 1},
+ {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1},
+ {&__pyx_n_s_write_text, __pyx_k_write_text, sizeof(__pyx_k_write_text), 0, 0, 1, 1},
+ {0, 0, 0, 0, 0, 0, 0}
+};
+static int __Pyx_InitCachedBuiltins(void) {
+ __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 121, __pyx_L1_error)
+ __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 131, __pyx_L1_error)
+ __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(0, 136, __pyx_L1_error)
+ __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) __PYX_ERR(0, 141, __pyx_L1_error)
+ __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 2651, __pyx_L1_error)
+ __pyx_builtin_staticmethod = __Pyx_GetBuiltinName(__pyx_n_s_staticmethod); if (!__pyx_builtin_staticmethod) __PYX_ERR(0, 2671, __pyx_L1_error)
+ __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(0, 366, __pyx_L1_error)
+ __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 430, __pyx_L1_error)
+ __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 722, __pyx_L1_error)
+ __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) __PYX_ERR(0, 1141, __pyx_L1_error)
+ return 0;
+ __pyx_L1_error:;
+ return -1;
+}
+
+static int __Pyx_InitCachedConstants(void) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+ /* "pywrapfst.pyx":1386
+ * if proc.returncode != 0: # Just to be explicit.
+ * raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG)
+ * return sout.decode("utf8") # <<<<<<<<<<<<<<
+ *
+ * def __repr__(self):
+ */
+ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_utf8); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 1386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__2);
+ __Pyx_GIVEREF(__pyx_tuple__2);
+
+ /* "pywrapfst.pyx":1542
+ * cdef size_t result = self._fst.get().NumArcs(state)
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 1542, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__3);
+ __Pyx_GIVEREF(__pyx_tuple__3);
+
+ /* "pywrapfst.pyx":1564
+ * cdef size_t result = self._fst.get().NumInputEpsilons(state)
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 1564, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__4);
+ __Pyx_GIVEREF(__pyx_tuple__4);
+
+ /* "pywrapfst.pyx":1586
+ * cdef size_t result = self._fst.get().NumOutputEpsilons(state)
+ * if result == SIZE_MAX:
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 1586, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__5);
+ __Pyx_GIVEREF(__pyx_tuple__5);
+
+ /* "pywrapfst.pyx":1727
+ * """
+ * if self._fst.get().Properties(fst.kError, True) == fst.kError:
+ * raise FstOpError("Operation failed") # <<<<<<<<<<<<<<
+ *
+ * cdef void _add_arc(self, int64 state, Arc arc) except *:
+ */
+ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Operation_failed); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 1727, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__6);
+ __Pyx_GIVEREF(__pyx_tuple__6);
+
+ /* "pywrapfst.pyx":1731
+ * cdef void _add_arc(self, int64 state, Arc arc) except *:
+ * if not self._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * if not self._mfst.get().AddArc(state, deref(arc._arc)):
+ * raise FstOpError("Incompatible or invalid weight type")
+ */
+ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 1731, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__7);
+ __Pyx_GIVEREF(__pyx_tuple__7);
+
+ /* "pywrapfst.pyx":1733
+ * raise FstIndexError("State index out of range")
+ * if not self._mfst.get().AddArc(state, deref(arc._arc)):
+ * raise FstOpError("Incompatible or invalid weight type") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Incompatible_or_invalid_weight_t); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 1733, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__8);
+ __Pyx_GIVEREF(__pyx_tuple__8);
+
+ /* "pywrapfst.pyx":1898
+ * if not (self._mfst.get().DeleteArcs(state, n) if n else
+ * self._mfst.get().DeleteArcs(state)):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 1898, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__9);
+ __Pyx_GIVEREF(__pyx_tuple__9);
+
+ /* "pywrapfst.pyx":1928
+ * if states:
+ * if not self._mfst.get().DeleteStates(<const vector[int64]> states):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * else:
+ * self._mfst.get().DeleteStates()
+ */
+ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 1928, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__10);
+ __Pyx_GIVEREF(__pyx_tuple__10);
+
+ /* "pywrapfst.pyx":2183
+ * _opairs.get().push_back(fst.LabelPair(before, after))
+ * if _ipairs.get().empty() and _opairs.get().empty():
+ * raise FstArgError("No relabeling pairs specified.") # <<<<<<<<<<<<<<
+ * fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs))
+ * self._check_mutating_imethod()
+ */
+ __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_No_relabeling_pairs_specified); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 2183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__19);
+ __Pyx_GIVEREF(__pyx_tuple__19);
+
+ /* "pywrapfst.pyx":2220
+ * bool attach_new_osymbols=True) except *:
+ * if new_isymbols is None and new_osymbols is None:
+ * raise FstArgError("No new SymbolTables specified") # <<<<<<<<<<<<<<
+ * cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ * if new_isymbols is not None:
+ */
+ __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_No_new_SymbolTables_specified); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 2220, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__20);
+ __Pyx_GIVEREF(__pyx_tuple__20);
+
+ /* "pywrapfst.pyx":2277
+ * cdef void _reserve_arcs(self, int64 state, size_t n) except *:
+ * if not self._mfst.get().ReserveArcs(state, n):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 2277, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__21);
+ __Pyx_GIVEREF(__pyx_tuple__21);
+
+ /* "pywrapfst.pyx":2400
+ * cdef void _set_final(self, int64 state, weight=None) except *:
+ * if not self._mfst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ * weight)
+ */
+ __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 2400, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__26);
+ __Pyx_GIVEREF(__pyx_tuple__26);
+
+ /* "pywrapfst.pyx":2404
+ * weight)
+ * if not self._mfst.get().SetFinal(state, wc):
+ * raise FstOpError("incompatible or invalid weight") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_incompatible_or_invalid_weight); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 2404, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__27);
+ __Pyx_GIVEREF(__pyx_tuple__27);
+
+ /* "pywrapfst.pyx":2449
+ * cdef void _set_start(self, int64 state) except *:
+ * if not self._mfst.get().SetStart(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 2449, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__28);
+ __Pyx_GIVEREF(__pyx_tuple__28);
+
+ /* "pywrapfst.pyx":2527
+ * # TopSort returns False if the FST is cyclic, and thus can't be TopSorted.
+ * if not fst.TopSort(self._mfst.get()):
+ * logging.warning("Cannot topsort cyclic FST.") # <<<<<<<<<<<<<<
+ * self._check_mutating_imethod()
+ *
+ */
+ __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_Cannot_topsort_cyclic_FST); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 2527, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__29);
+ __Pyx_GIVEREF(__pyx_tuple__29);
+
+ /* "pywrapfst.pyx":2596
+ * cdef _Fst _init_Fst(FstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed") # <<<<<<<<<<<<<<
+ * cdef _Fst ofst = _Fst.__new__(_Fst)
+ * ofst._fst.reset(<FstClass_ptr> tfst)
+ */
+ __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_Operation_failed); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 2596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__30);
+ __Pyx_GIVEREF(__pyx_tuple__30);
+
+ /* "pywrapfst.pyx":2604
+ * cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst):
+ * if tfst.Properties(fst.kError, True):
+ * raise FstOpError("Operation failed") # <<<<<<<<<<<<<<
+ * cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst)
+ * ofst._fst.reset(<MutableFstClass_ptr> tfst)
+ */
+ __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_Operation_failed); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 2604, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__31);
+ __Pyx_GIVEREF(__pyx_tuple__31);
+
+ /* "pywrapfst.pyx":2862
+ * def __init__(self, _Fst ifst, int64 state):
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ * self._fst = ifst._fst
+ */
+ __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 2862, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__32);
+ __Pyx_GIVEREF(__pyx_tuple__32);
+
+ /* "pywrapfst.pyx":3000
+ * def __init__(self, _MutableFst ifst, int64 state):
+ * if not ifst._fst.get().ValidStateId(state):
+ * raise FstIndexError("State index out of range") # <<<<<<<<<<<<<<
+ * # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ * self._mfst = ifst._mfst
+ */
+ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_State_index_out_of_range); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 3000, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__33);
+ __Pyx_GIVEREF(__pyx_tuple__33);
+
+ /* "pywrapfst.pyx":3542
+ * addr(error))
+ * if error:
+ * raise FstOpError("Equivalence test encountered error") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_Equivalence_test_encountered_err); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 3542, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__42);
+ __Pyx_GIVEREF(__pyx_tuple__42);
+
+ /* "pywrapfst.pyx":3737
+ * addr(error))
+ * if error:
+ * raise FstOpError("Random equivalence test encountered error") # <<<<<<<<<<<<<<
+ * return result
+ *
+ */
+ __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_s_Random_equivalence_test_encounte); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 3737, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__49);
+ __Pyx_GIVEREF(__pyx_tuple__49);
+
+ /* "pywrapfst.pyx":4184
+ * self._sstrm.reset(new stringstream())
+ * if tfst == NULL:
+ * raise FstOpError("Compilation failed") # <<<<<<<<<<<<<<
+ * return _init_XFst(tfst)
+ *
+ */
+ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_s_Compilation_failed); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 4184, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__61);
+ __Pyx_GIVEREF(__pyx_tuple__61);
+
+ /* "pywrapfst.pyx":4469
+ * # used by the FAR was initialized to use.
+ * if not self._writer.get().Add(tostring(key), deref(ifst._fst)):
+ * raise FstOpError("Incompatible or invalid arc type") # <<<<<<<<<<<<<<
+ * # An error here usually indicates a key out of order.
+ * if self._writer.get().Error():
+ */
+ __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_s_Incompatible_or_invalid_arc_type); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 4469, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__62);
+ __Pyx_GIVEREF(__pyx_tuple__62);
+
+ /* "pywrapfst.pyx":4472
+ * # An error here usually indicates a key out of order.
+ * if self._writer.get().Error():
+ * raise FstArgError("Key out of order") # <<<<<<<<<<<<<<
+ *
+ * cpdef string arc_type(self):
+ */
+ __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_s_Key_out_of_order); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 4472, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__63);
+ __Pyx_GIVEREF(__pyx_tuple__63);
+
+ /* "pywrapfst.pyx":446
+ *
+ *
+ * def plus(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * """
+ * plus(lhs, rhs)
+ */
+ __pyx_tuple__64 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_result); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 446, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__64);
+ __Pyx_GIVEREF(__pyx_tuple__64);
+ __pyx_codeobj__65 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__64, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_plus, 446, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__65)) __PYX_ERR(0, 446, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":478
+ *
+ *
+ * def times(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * """
+ * times(lhs, rhs)
+ */
+ __pyx_tuple__66 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_result); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 478, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__66);
+ __Pyx_GIVEREF(__pyx_tuple__66);
+ __pyx_codeobj__67 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__66, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_times, 478, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__67)) __PYX_ERR(0, 478, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":510
+ *
+ *
+ * def divide(Weight lhs, Weight rhs): # <<<<<<<<<<<<<<
+ * """
+ * divide(lhs, rhs)
+ */
+ __pyx_tuple__68 = PyTuple_Pack(3, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_result); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 510, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__68);
+ __Pyx_GIVEREF(__pyx_tuple__68);
+ __pyx_codeobj__69 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__68, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_divide, 510, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__69)) __PYX_ERR(0, 510, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":543
+ *
+ *
+ * def power(Weight w, size_t n): # <<<<<<<<<<<<<<
+ * """
+ * times(lhs, rhs)
+ */
+ __pyx_tuple__70 = PyTuple_Pack(3, __pyx_n_s_w, __pyx_n_s_n, __pyx_n_s_result); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 543, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__70);
+ __Pyx_GIVEREF(__pyx_tuple__70);
+ __pyx_codeobj__71 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__70, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_power, 543, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__71)) __PYX_ERR(0, 543, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":2668
+ * """
+ *
+ * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<<
+ * return _create_Fst(arc_type)
+ *
+ */
+ __pyx_tuple__72 = PyTuple_Pack(2, __pyx_n_s_cls, __pyx_n_s_arc_type); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 2668, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__72);
+ __Pyx_GIVEREF(__pyx_tuple__72);
+ __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_new, 2668, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) __PYX_ERR(0, 2668, __pyx_L1_error)
+ __pyx_tuple__74 = PyTuple_Pack(1, ((PyObject*)__pyx_n_b_standard)); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 2668, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__74);
+ __Pyx_GIVEREF(__pyx_tuple__74);
+
+ /* "pywrapfst.pyx":2672
+ *
+ * @staticmethod
+ * def read(filename, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read(filename, fst_type=None)
+ */
+ __pyx_tuple__75 = PyTuple_Pack(2, __pyx_n_s_filename, __pyx_n_s_fst_type); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 2672, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__75);
+ __Pyx_GIVEREF(__pyx_tuple__75);
+ __pyx_codeobj__76 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_read, 2672, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__76)) __PYX_ERR(0, 2672, __pyx_L1_error)
+ __pyx_tuple__77 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 2672, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__77);
+ __Pyx_GIVEREF(__pyx_tuple__77);
+
+ /* "pywrapfst.pyx":2693
+ *
+ * @staticmethod
+ * def read_from_string(fst_string, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read_from_string(fst_string, fst_type=None)
+ */
+ __pyx_tuple__78 = PyTuple_Pack(2, __pyx_n_s_fst_string, __pyx_n_s_fst_type); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 2693, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__78);
+ __Pyx_GIVEREF(__pyx_tuple__78);
+ __pyx_codeobj__79 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__78, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_read_from_string, 2693, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__79)) __PYX_ERR(0, 2693, __pyx_L1_error)
+ __pyx_tuple__80 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 2693, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__80);
+ __Pyx_GIVEREF(__pyx_tuple__80);
+
+ /* "pywrapfst.pyx":3936
+ *
+ *
+ * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_tuple__81 = PyTuple_Pack(9, __pyx_n_s_ifst, __pyx_n_s_delta, __pyx_n_s_nstate, __pyx_n_s_qt, __pyx_n_s_reverse, __pyx_n_s_distance, __pyx_n_s_weight_type, __pyx_n_s_result, __pyx_n_s_it); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 3936, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__81);
+ __Pyx_GIVEREF(__pyx_tuple__81);
+ __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(5, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_shortestdistance, 3936, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) __PYX_ERR(0, 3936, __pyx_L1_error)
+
+ /* "pywrapfst.pyx":4508
+ *
+ * @atexit.register
+ * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<<
+ * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old
+ *
+ */
+ __pyx_codeobj__83 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_usr_local_google_home_kbg_scrat, __pyx_n_s_reset_fst_error_fatal, 4508, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__83)) __PYX_ERR(0, 4508, __pyx_L1_error)
+ __Pyx_RefNannyFinishContext();
+ return 0;
+ __pyx_L1_error:;
+ __Pyx_RefNannyFinishContext();
+ return -1;
+}
+
+static int __Pyx_InitGlobals(void) {
+ if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+ __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+ return 0;
+ __pyx_L1_error:;
+ return -1;
+}
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC initpywrapfst(void); /*proto*/
+PyMODINIT_FUNC initpywrapfst(void)
+#else
+PyMODINIT_FUNC PyInit_pywrapfst(void); /*proto*/
+PyMODINIT_FUNC PyInit_pywrapfst(void)
+#endif
+{
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ PyObject *__pyx_t_5 = NULL;
+ std::string __pyx_t_6;
+ __Pyx_RefNannyDeclarations
+ #if CYTHON_REFNANNY
+ __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+ if (!__Pyx_RefNanny) {
+ PyErr_Clear();
+ __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+ if (!__Pyx_RefNanny)
+ Py_FatalError("failed to import 'refnanny' module");
+ }
+ #endif
+ __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_pywrapfst(void)", 0);
+ if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
+ #ifdef __Pyx_CyFunction_USED
+ if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ #endif
+ #ifdef __Pyx_FusedFunction_USED
+ if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ #endif
+ #ifdef __Pyx_Coroutine_USED
+ if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ #endif
+ #ifdef __Pyx_Generator_USED
+ if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ #endif
+ #ifdef __Pyx_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 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)
+ __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)
+ #if CYTHON_COMPILING_IN_PYPY
+ Py_INCREF(__pyx_b);
+ #endif
+ if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+ /*--- Initialize various global constants etc. ---*/
+ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+ if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ #endif
+ if (__pyx_module_is_main_pywrapfst) {
+ if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ }
+ #if PY_MAJOR_VERSION >= 3
+ {
+ PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (!PyDict_GetItemString(modules, "pywrapfst")) {
+ if (unlikely(PyDict_SetItemString(modules, "pywrapfst", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
+ }
+ }
+ #endif
+ /*--- Builtin init code ---*/
+ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ /*--- Constants init code ---*/
+ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ /*--- Global init code ---*/
+ /*--- Variable export code ---*/
+ /*--- Function export code ---*/
+ if (__Pyx_ExportFunction("tostring", (void (*)(void))__pyx_f_9pywrapfst_tostring, "std::string (PyObject *, struct __pyx_opt_args_9pywrapfst_tostring *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("weighttostring", (void (*)(void))__pyx_f_9pywrapfst_weighttostring, "std::string (PyObject *, struct __pyx_opt_args_9pywrapfst_weighttostring *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_get_compose_filter", (void (*)(void))__pyx_f_9pywrapfst__get_compose_filter, "enum fst::ComposeFilter (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_get_determinize_type", (void (*)(void))__pyx_f_9pywrapfst__get_determinize_type, "enum fst::DeterminizeType (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_get_queue_type", (void (*)(void))__pyx_f_9pywrapfst__get_queue_type, "enum fst::QueueType (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_get_rand_arc_selection", (void (*)(void))__pyx_f_9pywrapfst__get_rand_arc_selection, "enum fst::script::RandArcSelection (std::string const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_get_replace_label_type", (void (*)(void))__pyx_f_9pywrapfst__get_replace_label_type, "enum fst::ReplaceLabelType (std::string const &, bool)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_get_WeightClass_or_One", (void (*)(void))__pyx_f_9pywrapfst__get_WeightClass_or_One, "fst::script::WeightClass (std::string const &, PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_get_WeightClass_or_Zero", (void (*)(void))__pyx_f_9pywrapfst__get_WeightClass_or_Zero, "fst::script::WeightClass (std::string const &, PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_Weight_Zero", (void (*)(void))__pyx_f_9pywrapfst__Weight_Zero, "struct __pyx_obj_9pywrapfst_Weight *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_Weight_One", (void (*)(void))__pyx_f_9pywrapfst__Weight_One, "struct __pyx_obj_9pywrapfst_Weight *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_Weight_NoWeight", (void (*)(void))__pyx_f_9pywrapfst__Weight_NoWeight, "struct __pyx_obj_9pywrapfst_Weight *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_plus", (void (*)(void))__pyx_f_9pywrapfst__plus, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_times", (void (*)(void))__pyx_f_9pywrapfst__times, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_divide", (void (*)(void))__pyx_f_9pywrapfst__divide, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, struct __pyx_obj_9pywrapfst_Weight *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_power", (void (*)(void))__pyx_f_9pywrapfst__power, "struct __pyx_obj_9pywrapfst_Weight *(struct __pyx_obj_9pywrapfst_Weight *, size_t)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_init_EncodeMapperSymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_EncodeMapperSymbolTable, "struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(fst::SymbolTable *, std::shared_ptr<fst::script::EncodeMapperClass> )") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_init_FstSymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_FstSymbolTable, "struct __pyx_obj_9pywrapfst__FstSymbolTable *(fst::SymbolTable *, std::shared_ptr<fst::script::FstClass> )") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_init_MutableFstSymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_MutableFstSymbolTable, "struct __pyx_obj_9pywrapfst__MutableFstSymbolTable *(fst::SymbolTable *, std::shared_ptr<fst::script::MutableFstClass> )") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_init_SymbolTable", (void (*)(void))__pyx_f_9pywrapfst__init_SymbolTable, "struct __pyx_obj_9pywrapfst_SymbolTable *(fst::SymbolTable *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_init_Fst", (void (*)(void))__pyx_f_9pywrapfst__init_Fst, "struct __pyx_obj_9pywrapfst__Fst *(__pyx_t_9pywrapfst_FstClass_ptr)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_init_MutableFst", (void (*)(void))__pyx_f_9pywrapfst__init_MutableFst, "struct __pyx_obj_9pywrapfst__MutableFst *(__pyx_t_9pywrapfst_MutableFstClass_ptr)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_init_XFst", (void (*)(void))__pyx_f_9pywrapfst__init_XFst, "struct __pyx_obj_9pywrapfst__Fst *(__pyx_t_9pywrapfst_FstClass_ptr)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_create_Fst", (void (*)(void))__pyx_f_9pywrapfst__create_Fst, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_opt_args_9pywrapfst__create_Fst *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_read_Fst", (void (*)(void))__pyx_f_9pywrapfst__read_Fst, "struct __pyx_obj_9pywrapfst__Fst *(PyObject *, struct __pyx_opt_args_9pywrapfst__read_Fst *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_deserialize_Fst", (void (*)(void))__pyx_f_9pywrapfst__deserialize_Fst, "struct __pyx_obj_9pywrapfst__Fst *(PyObject *, struct __pyx_opt_args_9pywrapfst__deserialize_Fst *__pyx_optional_args)") < 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("rmepsilon", (void (*)(void))__pyx_f_9pywrapfst_rmepsilon, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_rmepsilon *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("_shortestdistance", (void (*)(void))__pyx_f_9pywrapfst__shortestdistance, "std::vector<fst::script::WeightClass> *(struct __pyx_obj_9pywrapfst__Fst *, struct __pyx_opt_args_9pywrapfst__shortestdistance *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("shortestpath", (void (*)(void))__pyx_f_9pywrapfst_shortestpath, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_shortestpath *__pyx_optional_args)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("statemap", (void (*)(void))__pyx_f_9pywrapfst_statemap, "struct __pyx_obj_9pywrapfst__Fst *(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (__Pyx_ExportFunction("synchronize", (void (*)(void))__pyx_f_9pywrapfst_synchronize, "struct __pyx_obj_9pywrapfst__MutableFst *(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ /*--- Type init code ---*/
+ __pyx_vtabptr_9pywrapfst_Weight = &__pyx_vtable_9pywrapfst_Weight;
+ __pyx_vtable_9pywrapfst_Weight._check_weight = (void (*)(struct __pyx_obj_9pywrapfst_Weight *))__pyx_f_9pywrapfst_6Weight__check_weight;
+ __pyx_vtable_9pywrapfst_Weight.copy = (struct __pyx_obj_9pywrapfst_Weight *(*)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_6Weight_copy;
+ __pyx_vtable_9pywrapfst_Weight.to_string = (std::string (*)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_6Weight_to_string;
+ __pyx_vtable_9pywrapfst_Weight.type = (std::string (*)(struct __pyx_obj_9pywrapfst_Weight *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_6Weight_type;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 344, __pyx_L1_error)
+ __pyx_type_9pywrapfst_Weight.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Weight.tp_dict, __pyx_vtabptr_9pywrapfst_Weight) < 0) __PYX_ERR(0, 344, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "Weight", (PyObject *)&__pyx_type_9pywrapfst_Weight) < 0) __PYX_ERR(0, 344, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_Weight = &__pyx_type_9pywrapfst_Weight;
+ __pyx_vtabptr_9pywrapfst__SymbolTable = &__pyx_vtable_9pywrapfst__SymbolTable;
+ __pyx_vtable_9pywrapfst__SymbolTable.available_key = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_available_key;
+ __pyx_vtable_9pywrapfst__SymbolTable.checksum = (std::string (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_checksum;
+ __pyx_vtable_9pywrapfst__SymbolTable.copy = (struct __pyx_obj_9pywrapfst_SymbolTable *(*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_copy;
+ __pyx_vtable_9pywrapfst__SymbolTable.get_nth_key = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, Py_ssize_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_get_nth_key;
+ __pyx_vtable_9pywrapfst__SymbolTable.labeled_checksum = (std::string (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_labeled_checksum;
+ __pyx_vtable_9pywrapfst__SymbolTable.member = (bool (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_member;
+ __pyx_vtable_9pywrapfst__SymbolTable.name = (std::string (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_name;
+ __pyx_vtable_9pywrapfst__SymbolTable.num_symbols = (size_t (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_num_symbols;
+ __pyx_vtable_9pywrapfst__SymbolTable.write = (void (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_write;
+ __pyx_vtable_9pywrapfst__SymbolTable.write_text = (void (*)(struct __pyx_obj_9pywrapfst__SymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12_SymbolTable_write_text;
+ if (PyType_Ready(&__pyx_type_9pywrapfst__SymbolTable) < 0) __PYX_ERR(0, 665, __pyx_L1_error)
+ __pyx_type_9pywrapfst__SymbolTable.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst__SymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__SymbolTable) < 0) __PYX_ERR(0, 665, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "_SymbolTable", (PyObject *)&__pyx_type_9pywrapfst__SymbolTable) < 0) __PYX_ERR(0, 665, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst__SymbolTable = &__pyx_type_9pywrapfst__SymbolTable;
+ __pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable = &__pyx_vtable_9pywrapfst__EncodeMapperSymbolTable;
+ __pyx_vtable_9pywrapfst__EncodeMapperSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__SymbolTable;
+ __pyx_type_9pywrapfst__EncodeMapperSymbolTable.tp_base = __pyx_ptype_9pywrapfst__SymbolTable;
+ if (PyType_Ready(&__pyx_type_9pywrapfst__EncodeMapperSymbolTable) < 0) __PYX_ERR(0, 817, __pyx_L1_error)
+ __pyx_type_9pywrapfst__EncodeMapperSymbolTable.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst__EncodeMapperSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__EncodeMapperSymbolTable) < 0) __PYX_ERR(0, 817, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "_EncodeMapperSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__EncodeMapperSymbolTable) < 0) __PYX_ERR(0, 817, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst__EncodeMapperSymbolTable = &__pyx_type_9pywrapfst__EncodeMapperSymbolTable;
+ __pyx_vtabptr_9pywrapfst__FstSymbolTable = &__pyx_vtable_9pywrapfst__FstSymbolTable;
+ __pyx_vtable_9pywrapfst__FstSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__SymbolTable;
+ __pyx_type_9pywrapfst__FstSymbolTable.tp_base = __pyx_ptype_9pywrapfst__SymbolTable;
+ if (PyType_Ready(&__pyx_type_9pywrapfst__FstSymbolTable) < 0) __PYX_ERR(0, 837, __pyx_L1_error)
+ __pyx_type_9pywrapfst__FstSymbolTable.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst__FstSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__FstSymbolTable) < 0) __PYX_ERR(0, 837, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "_FstSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__FstSymbolTable) < 0) __PYX_ERR(0, 837, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst__FstSymbolTable = &__pyx_type_9pywrapfst__FstSymbolTable;
+ __pyx_vtabptr_9pywrapfst__MutableSymbolTable = &__pyx_vtable_9pywrapfst__MutableSymbolTable;
+ __pyx_vtable_9pywrapfst__MutableSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__SymbolTable;
+ __pyx_vtable_9pywrapfst__MutableSymbolTable.add_symbol = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_19_MutableSymbolTable_add_symbol *__pyx_optional_args))__pyx_f_9pywrapfst_19_MutableSymbolTable_add_symbol;
+ __pyx_vtable_9pywrapfst__MutableSymbolTable.add_table = (void (*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19_MutableSymbolTable_add_table;
+ __pyx_vtable_9pywrapfst__MutableSymbolTable.set_name = (void (*)(struct __pyx_obj_9pywrapfst__MutableSymbolTable *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19_MutableSymbolTable_set_name;
+ __pyx_type_9pywrapfst__MutableSymbolTable.tp_base = __pyx_ptype_9pywrapfst__SymbolTable;
+ if (PyType_Ready(&__pyx_type_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 856, __pyx_L1_error)
+ __pyx_type_9pywrapfst__MutableSymbolTable.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 856, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "_MutableSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__MutableSymbolTable) < 0) __PYX_ERR(0, 856, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst__MutableSymbolTable = &__pyx_type_9pywrapfst__MutableSymbolTable;
+ __pyx_vtabptr_9pywrapfst__MutableFstSymbolTable = &__pyx_vtable_9pywrapfst__MutableFstSymbolTable;
+ __pyx_vtable_9pywrapfst__MutableFstSymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__MutableSymbolTable;
+ __pyx_type_9pywrapfst__MutableFstSymbolTable.tp_base = __pyx_ptype_9pywrapfst__MutableSymbolTable;
+ if (PyType_Ready(&__pyx_type_9pywrapfst__MutableFstSymbolTable) < 0) __PYX_ERR(0, 907, __pyx_L1_error)
+ __pyx_type_9pywrapfst__MutableFstSymbolTable.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableFstSymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst__MutableFstSymbolTable) < 0) __PYX_ERR(0, 907, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "_MutableFstSymbolTable", (PyObject *)&__pyx_type_9pywrapfst__MutableFstSymbolTable) < 0) __PYX_ERR(0, 907, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst__MutableFstSymbolTable = &__pyx_type_9pywrapfst__MutableFstSymbolTable;
+ __pyx_vtabptr_9pywrapfst_SymbolTable = &__pyx_vtable_9pywrapfst_SymbolTable;
+ __pyx_vtable_9pywrapfst_SymbolTable.__pyx_base = *__pyx_vtabptr_9pywrapfst__MutableSymbolTable;
+ __pyx_type_9pywrapfst_SymbolTable.tp_base = __pyx_ptype_9pywrapfst__MutableSymbolTable;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 927, __pyx_L1_error)
+ __pyx_type_9pywrapfst_SymbolTable.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_SymbolTable.tp_dict, __pyx_vtabptr_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 927, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "SymbolTable", (PyObject *)&__pyx_type_9pywrapfst_SymbolTable) < 0) __PYX_ERR(0, 927, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_SymbolTable = &__pyx_type_9pywrapfst_SymbolTable;
+ __pyx_vtabptr_9pywrapfst_SymbolTableIterator = &__pyx_vtable_9pywrapfst_SymbolTableIterator;
+ __pyx_vtable_9pywrapfst_SymbolTableIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_done;
+ __pyx_vtable_9pywrapfst_SymbolTableIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_next;
+ __pyx_vtable_9pywrapfst_SymbolTableIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_reset;
+ __pyx_vtable_9pywrapfst_SymbolTableIterator.symbol = (std::string (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_symbol;
+ __pyx_vtable_9pywrapfst_SymbolTableIterator.value = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst_SymbolTableIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_19SymbolTableIterator_value;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_SymbolTableIterator) < 0) __PYX_ERR(0, 1117, __pyx_L1_error)
+ __pyx_type_9pywrapfst_SymbolTableIterator.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_SymbolTableIterator.tp_dict, __pyx_vtabptr_9pywrapfst_SymbolTableIterator) < 0) __PYX_ERR(0, 1117, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "SymbolTableIterator", (PyObject *)&__pyx_type_9pywrapfst_SymbolTableIterator) < 0) __PYX_ERR(0, 1117, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_SymbolTableIterator = &__pyx_type_9pywrapfst_SymbolTableIterator;
+ __pyx_vtabptr_9pywrapfst_EncodeMapper = &__pyx_vtable_9pywrapfst_EncodeMapper;
+ __pyx_vtable_9pywrapfst_EncodeMapper.arc_type = (std::string (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_arc_type;
+ __pyx_vtable_9pywrapfst_EncodeMapper.flags = (__pyx_t_10basictypes_uint32 (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_flags;
+ __pyx_vtable_9pywrapfst_EncodeMapper.input_symbols = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_input_symbols;
+ __pyx_vtable_9pywrapfst_EncodeMapper.output_symbols = (struct __pyx_obj_9pywrapfst__EncodeMapperSymbolTable *(*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_output_symbols;
+ __pyx_vtable_9pywrapfst_EncodeMapper.properties = (__pyx_t_10basictypes_uint64 (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, __pyx_t_10basictypes_uint64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_properties;
+ __pyx_vtable_9pywrapfst_EncodeMapper.set_input_symbols = (void (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_set_input_symbols;
+ __pyx_vtable_9pywrapfst_EncodeMapper.set_output_symbols = (void (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, struct __pyx_obj_9pywrapfst__SymbolTable *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_set_output_symbols;
+ __pyx_vtable_9pywrapfst_EncodeMapper.weight_type = (std::string (*)(struct __pyx_obj_9pywrapfst_EncodeMapper *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_12EncodeMapper_weight_type;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1217, __pyx_L1_error)
+ __pyx_type_9pywrapfst_EncodeMapper.tp_print = 0;
+ #if CYTHON_COMPILING_IN_CPYTHON
+ {
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_9pywrapfst_EncodeMapper, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(0, 1217, __pyx_L1_error)
+ if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
+ __pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__ = *((PyWrapperDescrObject *)wrapper)->d_base;
+ __pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__.doc = __pyx_doc_9pywrapfst_12EncodeMapper_6__call__;
+ ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pywrapfst_12EncodeMapper_6__call__;
+ }
+ }
+ #endif
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_EncodeMapper.tp_dict, __pyx_vtabptr_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1217, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "EncodeMapper", (PyObject *)&__pyx_type_9pywrapfst_EncodeMapper) < 0) __PYX_ERR(0, 1217, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_EncodeMapper = &__pyx_type_9pywrapfst_EncodeMapper;
+ __pyx_vtabptr_9pywrapfst__Fst = &__pyx_vtable_9pywrapfst__Fst;
+ __pyx_vtable_9pywrapfst__Fst.arc_type = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_arc_type;
+ __pyx_vtable_9pywrapfst__Fst.arcs = (struct __pyx_obj_9pywrapfst_ArcIterator *(*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_arcs;
+ __pyx_vtable_9pywrapfst__Fst.copy = (struct __pyx_obj_9pywrapfst__Fst *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_copy;
+ __pyx_vtable_9pywrapfst__Fst.draw = (void (*)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_draw *__pyx_optional_args))__pyx_f_9pywrapfst_4_Fst_draw;
+ __pyx_vtable_9pywrapfst__Fst.final = (struct __pyx_obj_9pywrapfst_Weight *(*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_final;
+ __pyx_vtable_9pywrapfst__Fst.fst_type = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_fst_type;
+ __pyx_vtable_9pywrapfst__Fst.input_symbols = (struct __pyx_obj_9pywrapfst__FstSymbolTable *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_input_symbols;
+ __pyx_vtable_9pywrapfst__Fst.num_arcs = (size_t (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_num_arcs;
+ __pyx_vtable_9pywrapfst__Fst.num_input_epsilons = (size_t (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_num_input_epsilons;
+ __pyx_vtable_9pywrapfst__Fst.num_output_epsilons = (size_t (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_num_output_epsilons;
+ __pyx_vtable_9pywrapfst__Fst.output_symbols = (struct __pyx_obj_9pywrapfst__FstSymbolTable *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_output_symbols;
+ __pyx_vtable_9pywrapfst__Fst.properties = (__pyx_t_10basictypes_uint64 (*)(struct __pyx_obj_9pywrapfst__Fst *, __pyx_t_10basictypes_uint64, bool, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_properties;
+ __pyx_vtable_9pywrapfst__Fst.start = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_start;
+ __pyx_vtable_9pywrapfst__Fst.states = (struct __pyx_obj_9pywrapfst_StateIterator *(*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_states;
+ __pyx_vtable_9pywrapfst__Fst.text = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch, struct __pyx_opt_args_9pywrapfst_4_Fst_text *__pyx_optional_args))__pyx_f_9pywrapfst_4_Fst_text;
+ __pyx_vtable_9pywrapfst__Fst.verify = (bool (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_verify;
+ __pyx_vtable_9pywrapfst__Fst.weight_type = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_weight_type;
+ __pyx_vtable_9pywrapfst__Fst.write = (void (*)(struct __pyx_obj_9pywrapfst__Fst *, PyObject *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_write;
+ __pyx_vtable_9pywrapfst__Fst.WriteToString = (std::string (*)(struct __pyx_obj_9pywrapfst__Fst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_4_Fst_WriteToString;
+ if (PyType_Ready(&__pyx_type_9pywrapfst__Fst) < 0) __PYX_ERR(0, 1348, __pyx_L1_error)
+ __pyx_type_9pywrapfst__Fst.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst__Fst.tp_dict, __pyx_vtabptr_9pywrapfst__Fst) < 0) __PYX_ERR(0, 1348, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "_Fst", (PyObject *)&__pyx_type_9pywrapfst__Fst) < 0) __PYX_ERR(0, 1348, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst__Fst = &__pyx_type_9pywrapfst__Fst;
+ __pyx_vtabptr_9pywrapfst__MutableFst = &__pyx_vtable_9pywrapfst__MutableFst;
+ __pyx_vtable_9pywrapfst__MutableFst.__pyx_base = *__pyx_vtabptr_9pywrapfst__Fst;
+ __pyx_vtable_9pywrapfst__MutableFst._check_mutating_imethod = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__check_mutating_imethod;
+ __pyx_vtable_9pywrapfst__MutableFst._add_arc = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_obj_9pywrapfst_Arc *))__pyx_f_9pywrapfst_11_MutableFst__add_arc;
+ __pyx_vtable_9pywrapfst__MutableFst.add_state = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11_MutableFst_add_state;
+ __pyx_vtable_9pywrapfst__MutableFst._arcsort = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__arcsort *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__arcsort;
+ __pyx_vtable_9pywrapfst__MutableFst._closure = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__closure *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__closure;
+ __pyx_vtable_9pywrapfst__MutableFst._concat = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *))__pyx_f_9pywrapfst_11_MutableFst__concat;
+ __pyx_vtable_9pywrapfst__MutableFst._connect = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__connect;
+ __pyx_vtable_9pywrapfst__MutableFst._decode = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *))__pyx_f_9pywrapfst_11_MutableFst__decode;
+ __pyx_vtable_9pywrapfst__MutableFst._delete_arcs = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_arcs *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__delete_arcs;
+ __pyx_vtable_9pywrapfst__MutableFst._delete_states = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__delete_states *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__delete_states;
+ __pyx_vtable_9pywrapfst__MutableFst._encode = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst_EncodeMapper *))__pyx_f_9pywrapfst_11_MutableFst__encode;
+ __pyx_vtable_9pywrapfst__MutableFst._invert = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__invert;
+ __pyx_vtable_9pywrapfst__MutableFst._minimize = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__minimize *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__minimize;
+ __pyx_vtable_9pywrapfst__MutableFst.mutable_arcs = (struct __pyx_obj_9pywrapfst_MutableArcIterator *(*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11_MutableFst_mutable_arcs;
+ __pyx_vtable_9pywrapfst__MutableFst.num_states = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst__MutableFst *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11_MutableFst_num_states;
+ __pyx_vtable_9pywrapfst__MutableFst._project = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__project *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__project;
+ __pyx_vtable_9pywrapfst__MutableFst._prune = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__prune *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__prune;
+ __pyx_vtable_9pywrapfst__MutableFst._push = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__push *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__push;
+ __pyx_vtable_9pywrapfst__MutableFst._relabel_pairs = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_pairs *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__relabel_pairs;
+ __pyx_vtable_9pywrapfst__MutableFst._relabel_tables = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__relabel_tables *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__relabel_tables;
+ __pyx_vtable_9pywrapfst__MutableFst._reserve_arcs = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, size_t))__pyx_f_9pywrapfst_11_MutableFst__reserve_arcs;
+ __pyx_vtable_9pywrapfst__MutableFst._reserve_states = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64))__pyx_f_9pywrapfst_11_MutableFst__reserve_states;
+ __pyx_vtable_9pywrapfst__MutableFst._reweight = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, PyObject *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__reweight *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__reweight;
+ __pyx_vtable_9pywrapfst__MutableFst._rmepsilon = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_opt_args_9pywrapfst_11_MutableFst__rmepsilon *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__rmepsilon;
+ __pyx_vtable_9pywrapfst__MutableFst._set_final = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64, struct __pyx_opt_args_9pywrapfst_11_MutableFst__set_final *__pyx_optional_args))__pyx_f_9pywrapfst_11_MutableFst__set_final;
+ __pyx_vtable_9pywrapfst__MutableFst._set_properties = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_uint64, __pyx_t_10basictypes_uint64))__pyx_f_9pywrapfst_11_MutableFst__set_properties;
+ __pyx_vtable_9pywrapfst__MutableFst._set_start = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, __pyx_t_10basictypes_int64))__pyx_f_9pywrapfst_11_MutableFst__set_start;
+ __pyx_vtable_9pywrapfst__MutableFst._set_input_symbols = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *))__pyx_f_9pywrapfst_11_MutableFst__set_input_symbols;
+ __pyx_vtable_9pywrapfst__MutableFst._set_output_symbols = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__SymbolTable *))__pyx_f_9pywrapfst_11_MutableFst__set_output_symbols;
+ __pyx_vtable_9pywrapfst__MutableFst._topsort = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *))__pyx_f_9pywrapfst_11_MutableFst__topsort;
+ __pyx_vtable_9pywrapfst__MutableFst._union = (void (*)(struct __pyx_obj_9pywrapfst__MutableFst *, struct __pyx_obj_9pywrapfst__Fst *))__pyx_f_9pywrapfst_11_MutableFst__union;
+ __pyx_type_9pywrapfst__MutableFst.tp_base = __pyx_ptype_9pywrapfst__Fst;
+ if (PyType_Ready(&__pyx_type_9pywrapfst__MutableFst) < 0) __PYX_ERR(0, 1711, __pyx_L1_error)
+ __pyx_type_9pywrapfst__MutableFst.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst__MutableFst.tp_dict, __pyx_vtabptr_9pywrapfst__MutableFst) < 0) __PYX_ERR(0, 1711, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "_MutableFst", (PyObject *)&__pyx_type_9pywrapfst__MutableFst) < 0) __PYX_ERR(0, 1711, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst__MutableFst = &__pyx_type_9pywrapfst__MutableFst;
+ __pyx_vtabptr_9pywrapfst_Arc = &__pyx_vtable_9pywrapfst_Arc;
+ __pyx_vtable_9pywrapfst_Arc.copy = (struct __pyx_obj_9pywrapfst_Arc *(*)(struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_3Arc_copy;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_Arc) < 0) __PYX_ERR(0, 2779, __pyx_L1_error)
+ __pyx_type_9pywrapfst_Arc.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Arc.tp_dict, __pyx_vtabptr_9pywrapfst_Arc) < 0) __PYX_ERR(0, 2779, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "Arc", (PyObject *)&__pyx_type_9pywrapfst_Arc) < 0) __PYX_ERR(0, 2779, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_Arc = &__pyx_type_9pywrapfst_Arc;
+ __pyx_vtabptr_9pywrapfst_ArcIterator = &__pyx_vtable_9pywrapfst_ArcIterator;
+ __pyx_vtable_9pywrapfst_ArcIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_done;
+ __pyx_vtable_9pywrapfst_ArcIterator.flags = (__pyx_t_10basictypes_uint32 (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_flags;
+ __pyx_vtable_9pywrapfst_ArcIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_next;
+ __pyx_vtable_9pywrapfst_ArcIterator.position = (size_t (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_position;
+ __pyx_vtable_9pywrapfst_ArcIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_reset;
+ __pyx_vtable_9pywrapfst_ArcIterator.seek = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, size_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_seek;
+ __pyx_vtable_9pywrapfst_ArcIterator.set_flags = (void (*)(struct __pyx_obj_9pywrapfst_ArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_set_flags;
+ __pyx_vtable_9pywrapfst_ArcIterator.value = (PyObject *(*)(struct __pyx_obj_9pywrapfst_ArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_11ArcIterator_value;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 2847, __pyx_L1_error)
+ __pyx_type_9pywrapfst_ArcIterator.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_ArcIterator.tp_dict, __pyx_vtabptr_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 2847, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "ArcIterator", (PyObject *)&__pyx_type_9pywrapfst_ArcIterator) < 0) __PYX_ERR(0, 2847, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_ArcIterator = &__pyx_type_9pywrapfst_ArcIterator;
+ __pyx_vtabptr_9pywrapfst_MutableArcIterator = &__pyx_vtable_9pywrapfst_MutableArcIterator;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_done;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.flags = (__pyx_t_10basictypes_uint32 (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_flags;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_next;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.position = (size_t (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_position;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_reset;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.seek = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, size_t, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_seek;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.set_flags = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, __pyx_t_10basictypes_uint32, __pyx_t_10basictypes_uint32, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_set_flags;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.set_value = (void (*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, struct __pyx_obj_9pywrapfst_Arc *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_set_value;
+ __pyx_vtable_9pywrapfst_MutableArcIterator.value = (PyObject *(*)(struct __pyx_obj_9pywrapfst_MutableArcIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_18MutableArcIterator_value;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 2984, __pyx_L1_error)
+ __pyx_type_9pywrapfst_MutableArcIterator.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_MutableArcIterator.tp_dict, __pyx_vtabptr_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 2984, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "MutableArcIterator", (PyObject *)&__pyx_type_9pywrapfst_MutableArcIterator) < 0) __PYX_ERR(0, 2984, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_MutableArcIterator = &__pyx_type_9pywrapfst_MutableArcIterator;
+ __pyx_vtabptr_9pywrapfst_StateIterator = &__pyx_vtable_9pywrapfst_StateIterator;
+ __pyx_vtable_9pywrapfst_StateIterator.done = (bool (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_done;
+ __pyx_vtable_9pywrapfst_StateIterator.next = (void (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_next;
+ __pyx_vtable_9pywrapfst_StateIterator.reset = (void (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_reset;
+ __pyx_vtable_9pywrapfst_StateIterator.value = (__pyx_t_10basictypes_int64 (*)(struct __pyx_obj_9pywrapfst_StateIterator *, int __pyx_skip_dispatch))__pyx_f_9pywrapfst_13StateIterator_value;
+ if (PyType_Ready(&__pyx_type_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3136, __pyx_L1_error)
+ __pyx_type_9pywrapfst_StateIterator.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_StateIterator.tp_dict, __pyx_vtabptr_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3136, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "StateIterator", (PyObject *)&__pyx_type_9pywrapfst_StateIterator) < 0) __PYX_ERR(0, 3136, __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, 4083, __pyx_L1_error)
+ __pyx_type_9pywrapfst_Compiler.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_Compiler.tp_dict, __pyx_vtabptr_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4083, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "Compiler", (PyObject *)&__pyx_type_9pywrapfst_Compiler) < 0) __PYX_ERR(0, 4083, __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, 4209, __pyx_L1_error)
+ __pyx_type_9pywrapfst_FarReader.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_FarReader.tp_dict, __pyx_vtabptr_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4209, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "FarReader", (PyObject *)&__pyx_type_9pywrapfst_FarReader) < 0) __PYX_ERR(0, 4209, __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, 4383, __pyx_L1_error)
+ __pyx_type_9pywrapfst_FarWriter.tp_print = 0;
+ if (__Pyx_SetVtable(__pyx_type_9pywrapfst_FarWriter.tp_dict, __pyx_vtabptr_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4383, __pyx_L1_error)
+ if (PyObject_SetAttrString(__pyx_m, "FarWriter", (PyObject *)&__pyx_type_9pywrapfst_FarWriter) < 0) __PYX_ERR(0, 4383, __pyx_L1_error)
+ __pyx_ptype_9pywrapfst_FarWriter = &__pyx_type_9pywrapfst_FarWriter;
+ /*--- Type import code ---*/
+ /*--- Variable import code ---*/
+ /*--- Function import code ---*/
+ /*--- Execution code ---*/
+ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+ if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ #endif
+
+ /* "pywrapfst.pyx":107
+ *
+ * # Python imports.
+ * import atexit # <<<<<<<<<<<<<<
+ * import numbers
+ * import subprocess
+ */
+ __pyx_t_1 = __Pyx_Import(__pyx_n_s_atexit, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 107, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_atexit, __pyx_t_1) < 0) __PYX_ERR(0, 107, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":108
+ * # Python imports.
+ * import atexit
+ * import numbers # <<<<<<<<<<<<<<
+ * import subprocess
+ * import logging
+ */
+ __pyx_t_1 = __Pyx_Import(__pyx_n_s_numbers, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 108, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_numbers, __pyx_t_1) < 0) __PYX_ERR(0, 108, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":109
+ * import atexit
+ * import numbers
+ * import subprocess # <<<<<<<<<<<<<<
+ * import logging
+ *
+ */
+ __pyx_t_1 = __Pyx_Import(__pyx_n_s_subprocess, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 109, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_subprocess, __pyx_t_1) < 0) __PYX_ERR(0, 109, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":110
+ * import numbers
+ * import subprocess
+ * import logging # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_1 = __Pyx_Import(__pyx_n_s_logging, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_logging, __pyx_t_1) < 0) __PYX_ERR(0, 110, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":116
+ *
+ *
+ * class FstError(Exception): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 116, __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, 116, __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, 116, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 116, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstError, __pyx_t_4) < 0) __PYX_ERR(0, 116, __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":121
+ *
+ *
+ * class FstArgError(FstError, ValueError): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 121, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __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, 121, __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, 121, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstArgError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstArgError, __pyx_t_4) < 0) __PYX_ERR(0, 121, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":126
+ *
+ *
+ * class FstBadWeightError(FstError, ValueError): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 126, __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, 126, __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, 126, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstBadWeightError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 126, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstBadWeightError, __pyx_t_4) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":131
+ *
+ *
+ * class FstDeletedConstructorError(FstError, RuntimeError): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 131, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __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, 131, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_FstDeletedConstructorError, __pyx_n_s_FstDeletedConstructorError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstDeletedConstructorError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 131, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstDeletedConstructorError, __pyx_t_4) < 0) __PYX_ERR(0, 131, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":136
+ *
+ *
+ * class FstIndexError(FstError, IndexError): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 136, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+ __Pyx_INCREF(__pyx_builtin_IndexError);
+ __Pyx_GIVEREF(__pyx_builtin_IndexError);
+ PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_IndexError);
+ __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_FstIndexError, __pyx_n_s_FstIndexError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstIndexError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 136, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstIndexError, __pyx_t_4) < 0) __PYX_ERR(0, 136, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":141
+ *
+ *
+ * class FstIOError(FstError, IOError): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+ __Pyx_INCREF(__pyx_builtin_IOError);
+ __Pyx_GIVEREF(__pyx_builtin_IOError);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_builtin_IOError);
+ __pyx_t_1 = 0;
+ __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 141, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_FstIOError, __pyx_n_s_FstIOError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 141, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstIOError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstIOError, __pyx_t_4) < 0) __PYX_ERR(0, 141, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":146
+ *
+ *
+ * class FstOpError(FstError, RuntimeError): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+ __Pyx_INCREF(__pyx_builtin_RuntimeError);
+ __Pyx_GIVEREF(__pyx_builtin_RuntimeError);
+ PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_builtin_RuntimeError);
+ __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 146, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_1, __pyx_n_s_FstOpError, __pyx_n_s_FstOpError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 146, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_FstOpError, __pyx_t_1, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 146, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstOpError, __pyx_t_4) < 0) __PYX_ERR(0, 146, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":151
+ *
+ *
+ * class FstUnknownWeightTypeError(FstError, ValueError): # <<<<<<<<<<<<<<
+ *
+ * pass
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_FstError); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __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, 151, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_FstUnknownWeightTypeError, __pyx_n_s_FstUnknownWeightTypeError, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 151, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_FstUnknownWeightTypeError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 151, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FstUnknownWeightTypeError, __pyx_t_4) < 0) __PYX_ERR(0, 151, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":403
+ *
+ * @classmethod
+ * def Zero(cls, weight_type): # <<<<<<<<<<<<<<
+ * """
+ * Weight.Zero(weight_type)
+ */
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_Zero); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 403, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":402
+ * # the 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, 402, __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, 403, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_Weight);
+
+ /* "pywrapfst.pyx":410
+ *
+ * @classmethod
+ * def One(cls, weight_type): # <<<<<<<<<<<<<<
+ * """
+ * Weight.One(weight_type)
+ */
+ __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_One); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 410, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+
+ /* "pywrapfst.pyx":409
+ * return _Weight_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, 409, __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, 410, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_Weight);
+
+ /* "pywrapfst.pyx":417
+ *
+ * @classmethod
+ * def NoWeight(cls, weight_type): # <<<<<<<<<<<<<<
+ * """
+ * Weight.NoWeight(weight_type)
+ */
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_Weight, __pyx_n_s_NoWeight); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 417, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":416
+ * return _Weight_One(weight_type)
+ *
+ * @classmethod # <<<<<<<<<<<<<<
+ * def NoWeight(cls, weight_type):
+ * """
+ */
+ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 416, __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_NoWeight, __pyx_t_1) < 0) __PYX_ERR(0, 417, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_Weight);
+
+ /* "pywrapfst.pyx":446
+ *
+ *
+ * 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, 446, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_plus, __pyx_t_1) < 0) __PYX_ERR(0, 446, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":478
+ *
+ *
+ * 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, 478, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_times, __pyx_t_1) < 0) __PYX_ERR(0, 478, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":510
+ *
+ *
+ * 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, 510, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_divide, __pyx_t_1) < 0) __PYX_ERR(0, 510, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":543
+ *
+ *
+ * def power(Weight w, size_t n): # <<<<<<<<<<<<<<
+ * """
+ * times(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, 543, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_power, __pyx_t_1) < 0) __PYX_ERR(0, 543, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":960
+ *
+ * @classmethod
+ * def read(cls, filename): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read(filename)
+ */
+ __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 960, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+
+ /* "pywrapfst.pyx":959
+ * self._smart_table.reset(self._table)
+ *
+ * @classmethod # <<<<<<<<<<<<<<
+ * def read(cls, filename):
+ * """
+ */
+ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 959, __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, 960, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable);
+
+ /* "pywrapfst.pyx":982
+ *
+ * @classmethod
+ * def read_text(cls, filename, bool allow_negative_labels=False): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read_text(filename)
+ */
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read_text); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 982, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":981
+ * return _init_SymbolTable(tsyms)
+ *
+ * @classmethod # <<<<<<<<<<<<<<
+ * def read_text(cls, filename, bool allow_negative_labels=False):
+ * """
+ */
+ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 981, __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, 982, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable);
+
+ /* "pywrapfst.pyx":1009
+ *
+ * @classmethod
+ * def read_fst(cls, filename, bool input_table): # <<<<<<<<<<<<<<
+ * """
+ * SymbolTable.read_fst(filename, input_table)
+ */
+ __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_SymbolTable, __pyx_n_s_read_fst); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1009, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+
+ /* "pywrapfst.pyx":1008
+ * return _init_SymbolTable(tsyms)
+ *
+ * @classmethod # <<<<<<<<<<<<<<
+ * def read_fst(cls, filename, bool input_table):
+ * """
+ */
+ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1008, __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, 1009, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_SymbolTable);
+
+ /* "pywrapfst.pyx":2001
+ * return self
+ *
+ * cdef void _minimize(self, float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * bool allow_nondet=False) except *:
+ * # This runs in-place when the second argument is null.
+ */
+ __pyx_k__11 = fst::kDelta;
+
+ /* "pywrapfst.pyx":2007
+ * self._check_mutating_imethod()
+ *
+ * def minimize(self, float delta=fst.kDelta, bool allow_nondet=False): # <<<<<<<<<<<<<<
+ * """
+ * minimize(self, delta=0.0009765625, allow_nondet=False)
+ */
+ __pyx_k__12 = fst::kDelta;
+
+ /* "pywrapfst.pyx":2093
+ * return self
+ *
+ * cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None) except *:
+ * # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ */
+ __pyx_k__13 = fst::kDelta;
+ __pyx_k__14 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":2102
+ *
+ * def prune(self,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * weight=None):
+ */
+ __pyx_k__15 = fst::kDelta;
+
+ /* "pywrapfst.pyx":2103
+ * def prune(self,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ __pyx_k__16 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":2130
+ *
+ * cdef void _push(self,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * bool remove_total_weight=False,
+ * bool to_final=False) except *:
+ */
+ __pyx_k__17 = fst::kDelta;
+
+ /* "pywrapfst.pyx":2138
+ *
+ * def push(self,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * bool remove_total_weight=False,
+ * bool to_final=False):
+ */
+ __pyx_k__18 = fst::kDelta;
+
+ /* "pywrapfst.pyx":2360
+ * cdef void _rmepsilon(self,
+ * bool connect=True,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * weight=None) except *:
+ */
+ __pyx_k__22 = fst::kDelta;
+
+ /* "pywrapfst.pyx":2361
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None) except *:
+ * # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ */
+ __pyx_k__23 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":2371
+ * def rmepsilon(self,
+ * bool connect=True,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * weight=None):
+ */
+ __pyx_k__24 = fst::kDelta;
+
+ /* "pywrapfst.pyx":2372
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ __pyx_k__25 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":2651
+ * return _init_XFst(ofst)
+ *
+ * class Fst(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2651, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_builtin_object);
+ __Pyx_GIVEREF(__pyx_builtin_object);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_object);
+ __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2651, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_Fst, __pyx_n_s_Fst, (PyObject *) NULL, __pyx_n_s_pywrapfst_2, __pyx_kp_s_Fst_arc_type_standard_Construct); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2651, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+
+ /* "pywrapfst.pyx":2668
+ * """
+ *
+ * def __new__(cls, arc_type=b"standard"): # <<<<<<<<<<<<<<
+ * return _create_Fst(arc_type)
+ *
+ */
+ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9pywrapfst_3Fst_1__new__, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Fst___new, NULL, __pyx_n_s_pywrapfst_2, __pyx_d, ((PyObject *)__pyx_codeobj__73)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2668, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__74);
+ if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_new, __pyx_t_4) < 0) __PYX_ERR(0, 2668, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+ /* "pywrapfst.pyx":2672
+ *
+ * @staticmethod
+ * def read(filename, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read(filename, fst_type=None)
+ */
+ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9pywrapfst_3Fst_3read, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Fst_read, NULL, __pyx_n_s_pywrapfst_2, __pyx_d, ((PyObject *)__pyx_codeobj__76)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2672, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__77);
+
+ /* "pywrapfst.pyx":2671
+ * return _create_Fst(arc_type)
+ *
+ * @staticmethod # <<<<<<<<<<<<<<
+ * def read(filename, fst_type=None):
+ * """
+ */
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2671, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_staticmethod, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2671, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_read, __pyx_t_4) < 0) __PYX_ERR(0, 2672, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+ /* "pywrapfst.pyx":2693
+ *
+ * @staticmethod
+ * def read_from_string(fst_string, fst_type=None): # <<<<<<<<<<<<<<
+ * """
+ * read_from_string(fst_string, fst_type=None)
+ */
+ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_9pywrapfst_3Fst_5read_from_string, __Pyx_CYFUNCTION_STATICMETHOD, __pyx_n_s_Fst_read_from_string, NULL, __pyx_n_s_pywrapfst_2, __pyx_d, ((PyObject *)__pyx_codeobj__79)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2693, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__80);
+
+ /* "pywrapfst.pyx":2692
+ * return _read_Fst(filename, fst_type)
+ *
+ * @staticmethod # <<<<<<<<<<<<<<
+ * def read_from_string(fst_string, fst_type=None):
+ * """
+ */
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2692, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
+ __pyx_t_4 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_staticmethod, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2692, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_read_from_string, __pyx_t_4) < 0) __PYX_ERR(0, 2693, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+ /* "pywrapfst.pyx":2651
+ * return _init_XFst(ofst)
+ *
+ * class Fst(object): # <<<<<<<<<<<<<<
+ *
+ * """
+ */
+ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_Fst, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2651, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_Fst, __pyx_t_4) < 0) __PYX_ERR(0, 2651, __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":2716
+ *
+ *
+ * EXPANDED = fst.kExpanded # <<<<<<<<<<<<<<
+ * MUTABLE = fst.kMutable
+ * ERROR = fst.kError
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kExpanded); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2716, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_EXPANDED, __pyx_t_2) < 0) __PYX_ERR(0, 2716, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2717
+ *
+ * EXPANDED = fst.kExpanded
+ * MUTABLE = fst.kMutable # <<<<<<<<<<<<<<
+ * ERROR = fst.kError
+ * ACCEPTOR = fst.kAcceptor
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kMutable); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2717, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_MUTABLE, __pyx_t_2) < 0) __PYX_ERR(0, 2717, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2718
+ * EXPANDED = fst.kExpanded
+ * MUTABLE = fst.kMutable
+ * ERROR = fst.kError # <<<<<<<<<<<<<<
+ * ACCEPTOR = fst.kAcceptor
+ * NOT_ACCEPTOR = fst.kNotAcceptor
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2718, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 2718, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2719
+ * MUTABLE = fst.kMutable
+ * ERROR = fst.kError
+ * ACCEPTOR = fst.kAcceptor # <<<<<<<<<<<<<<
+ * NOT_ACCEPTOR = fst.kNotAcceptor
+ * I_DETERMINISTIC = fst.kIDeterministic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kAcceptor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2719, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACCEPTOR, __pyx_t_2) < 0) __PYX_ERR(0, 2719, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2720
+ * ERROR = fst.kError
+ * ACCEPTOR = fst.kAcceptor
+ * NOT_ACCEPTOR = fst.kNotAcceptor # <<<<<<<<<<<<<<
+ * I_DETERMINISTIC = fst.kIDeterministic
+ * NON_I_DETERMINISTIC = fst.kNonIDeterministic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNotAcceptor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2720, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_ACCEPTOR, __pyx_t_2) < 0) __PYX_ERR(0, 2720, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2721
+ * ACCEPTOR = fst.kAcceptor
+ * NOT_ACCEPTOR = fst.kNotAcceptor
+ * I_DETERMINISTIC = fst.kIDeterministic # <<<<<<<<<<<<<<
+ * NON_I_DETERMINISTIC = fst.kNonIDeterministic
+ * O_DETERMINISTIC = fst.kODeterministic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kIDeterministic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2721, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_DETERMINISTIC, __pyx_t_2) < 0) __PYX_ERR(0, 2721, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2722
+ * NOT_ACCEPTOR = fst.kNotAcceptor
+ * I_DETERMINISTIC = fst.kIDeterministic
+ * NON_I_DETERMINISTIC = fst.kNonIDeterministic # <<<<<<<<<<<<<<
+ * O_DETERMINISTIC = fst.kODeterministic
+ * NON_O_DETERMINISTIC = fst.kNonODeterministic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNonIDeterministic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2722, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NON_I_DETERMINISTIC, __pyx_t_2) < 0) __PYX_ERR(0, 2722, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2723
+ * I_DETERMINISTIC = fst.kIDeterministic
+ * NON_I_DETERMINISTIC = fst.kNonIDeterministic
+ * O_DETERMINISTIC = fst.kODeterministic # <<<<<<<<<<<<<<
+ * NON_O_DETERMINISTIC = fst.kNonODeterministic
+ * EPSILONS = fst.kEpsilons
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kODeterministic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2723, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_DETERMINISTIC, __pyx_t_2) < 0) __PYX_ERR(0, 2723, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2724
+ * NON_I_DETERMINISTIC = fst.kNonIDeterministic
+ * O_DETERMINISTIC = fst.kODeterministic
+ * NON_O_DETERMINISTIC = fst.kNonODeterministic # <<<<<<<<<<<<<<
+ * EPSILONS = fst.kEpsilons
+ * NO_EPSILONS = fst.kNoEpsilons
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNonODeterministic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2724, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NON_O_DETERMINISTIC, __pyx_t_2) < 0) __PYX_ERR(0, 2724, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2725
+ * O_DETERMINISTIC = fst.kODeterministic
+ * NON_O_DETERMINISTIC = fst.kNonODeterministic
+ * EPSILONS = fst.kEpsilons # <<<<<<<<<<<<<<
+ * NO_EPSILONS = fst.kNoEpsilons
+ * I_EPSILONS = fst.kIEpsilons
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kEpsilons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2725, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_EPSILONS, __pyx_t_2) < 0) __PYX_ERR(0, 2725, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2726
+ * NON_O_DETERMINISTIC = fst.kNonODeterministic
+ * EPSILONS = fst.kEpsilons
+ * NO_EPSILONS = fst.kNoEpsilons # <<<<<<<<<<<<<<
+ * I_EPSILONS = fst.kIEpsilons
+ * NO_I_EPSILONS = fst.kNoIEpsilons
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNoEpsilons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2726, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_EPSILONS, __pyx_t_2) < 0) __PYX_ERR(0, 2726, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2727
+ * EPSILONS = fst.kEpsilons
+ * NO_EPSILONS = fst.kNoEpsilons
+ * I_EPSILONS = fst.kIEpsilons # <<<<<<<<<<<<<<
+ * NO_I_EPSILONS = fst.kNoIEpsilons
+ * O_EPSILONS = fst.kOEpsilons
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kIEpsilons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2727, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_EPSILONS, __pyx_t_2) < 0) __PYX_ERR(0, 2727, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2728
+ * NO_EPSILONS = fst.kNoEpsilons
+ * I_EPSILONS = fst.kIEpsilons
+ * NO_I_EPSILONS = fst.kNoIEpsilons # <<<<<<<<<<<<<<
+ * O_EPSILONS = fst.kOEpsilons
+ * NO_O_EPSILONS = fst.kNoOEpsilons
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNoIEpsilons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2728, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_I_EPSILONS, __pyx_t_2) < 0) __PYX_ERR(0, 2728, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2729
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kOEpsilons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2729, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_EPSILONS, __pyx_t_2) < 0) __PYX_ERR(0, 2729, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2730
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kNoOEpsilons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2730, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NO_O_EPSILONS, __pyx_t_2) < 0) __PYX_ERR(0, 2730, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2731
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kILabelSorted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2731, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_LABEL_SORTED, __pyx_t_2) < 0) __PYX_ERR(0, 2731, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2732
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kNotILabelSorted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2732, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_I_LABEL_SORTED, __pyx_t_2) < 0) __PYX_ERR(0, 2732, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2733
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kOLabelSorted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2733, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_LABEL_SORTED, __pyx_t_2) < 0) __PYX_ERR(0, 2733, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2734
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kNotOLabelSorted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2734, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_O_LABEL_SORTED, __pyx_t_2) < 0) __PYX_ERR(0, 2734, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2735
+ * O_LABEL_SORTED = fst.kOLabelSorted
+ * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted
+ * WEIGHTED = fst.kWeighted # <<<<<<<<<<<<<<
+ * UNWEIGHTED = fst.kUnweighted
+ * CYCLIC = fst.kCyclic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kWeighted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2735, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_WEIGHTED, __pyx_t_2) < 0) __PYX_ERR(0, 2735, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2736
+ * NOT_O_LABEL_SORTED = fst.kNotOLabelSorted
+ * WEIGHTED = fst.kWeighted
+ * UNWEIGHTED = fst.kUnweighted # <<<<<<<<<<<<<<
+ * CYCLIC = fst.kCyclic
+ * ACYCLIC = fst.kAcyclic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kUnweighted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2736, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_UNWEIGHTED, __pyx_t_2) < 0) __PYX_ERR(0, 2736, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2737
+ * WEIGHTED = fst.kWeighted
+ * UNWEIGHTED = fst.kUnweighted
+ * CYCLIC = fst.kCyclic # <<<<<<<<<<<<<<
+ * ACYCLIC = fst.kAcyclic
+ * INITIAL_CYCLIC = fst.kInitialCyclic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kCyclic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2737, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_CYCLIC, __pyx_t_2) < 0) __PYX_ERR(0, 2737, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2738
+ * UNWEIGHTED = fst.kUnweighted
+ * CYCLIC = fst.kCyclic
+ * ACYCLIC = fst.kAcyclic # <<<<<<<<<<<<<<
+ * INITIAL_CYCLIC = fst.kInitialCyclic
+ * INITIAL_ACYCLIC = fst.kInitialAcyclic
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kAcyclic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2738, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACYCLIC, __pyx_t_2) < 0) __PYX_ERR(0, 2738, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2739
+ * CYCLIC = fst.kCyclic
+ * ACYCLIC = fst.kAcyclic
+ * INITIAL_CYCLIC = fst.kInitialCyclic # <<<<<<<<<<<<<<
+ * INITIAL_ACYCLIC = fst.kInitialAcyclic
+ * TOP_SORTED = fst.kTopSorted
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kInitialCyclic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2739, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_INITIAL_CYCLIC, __pyx_t_2) < 0) __PYX_ERR(0, 2739, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2740
+ * ACYCLIC = fst.kAcyclic
+ * INITIAL_CYCLIC = fst.kInitialCyclic
+ * INITIAL_ACYCLIC = fst.kInitialAcyclic # <<<<<<<<<<<<<<
+ * TOP_SORTED = fst.kTopSorted
+ * NOT_TOP_SORTED = fst.kNotTopSorted
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kInitialAcyclic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2740, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_INITIAL_ACYCLIC, __pyx_t_2) < 0) __PYX_ERR(0, 2740, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2741
+ * INITIAL_CYCLIC = fst.kInitialCyclic
+ * INITIAL_ACYCLIC = fst.kInitialAcyclic
+ * TOP_SORTED = fst.kTopSorted # <<<<<<<<<<<<<<
+ * NOT_TOP_SORTED = fst.kNotTopSorted
+ * ACCESSIBLE = fst.kAccessible
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kTopSorted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2741, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_TOP_SORTED, __pyx_t_2) < 0) __PYX_ERR(0, 2741, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2742
+ * INITIAL_ACYCLIC = fst.kInitialAcyclic
+ * TOP_SORTED = fst.kTopSorted
+ * NOT_TOP_SORTED = fst.kNotTopSorted # <<<<<<<<<<<<<<
+ * ACCESSIBLE = fst.kAccessible
+ * NOT_ACCESSIBLE = fst.kNotAccessible
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNotTopSorted); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2742, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_TOP_SORTED, __pyx_t_2) < 0) __PYX_ERR(0, 2742, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2743
+ * TOP_SORTED = fst.kTopSorted
+ * NOT_TOP_SORTED = fst.kNotTopSorted
+ * ACCESSIBLE = fst.kAccessible # <<<<<<<<<<<<<<
+ * NOT_ACCESSIBLE = fst.kNotAccessible
+ * COACCESSIBLE = fst.kCoAccessible
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kAccessible); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2743, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ACCESSIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 2743, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2744
+ * NOT_TOP_SORTED = fst.kNotTopSorted
+ * ACCESSIBLE = fst.kAccessible
+ * NOT_ACCESSIBLE = fst.kNotAccessible # <<<<<<<<<<<<<<
+ * COACCESSIBLE = fst.kCoAccessible
+ * NOT_COACCESSIBLE = fst.kNotCoAccessible
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNotAccessible); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2744, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_ACCESSIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 2744, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2745
+ * ACCESSIBLE = fst.kAccessible
+ * NOT_ACCESSIBLE = fst.kNotAccessible
+ * COACCESSIBLE = fst.kCoAccessible # <<<<<<<<<<<<<<
+ * NOT_COACCESSIBLE = fst.kNotCoAccessible
+ * STRING = fst.kString
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kCoAccessible); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2745, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_COACCESSIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 2745, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2746
+ * NOT_ACCESSIBLE = fst.kNotAccessible
+ * COACCESSIBLE = fst.kCoAccessible
+ * NOT_COACCESSIBLE = fst.kNotCoAccessible # <<<<<<<<<<<<<<
+ * STRING = fst.kString
+ * NOT_STRING = fst.kNotString
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNotCoAccessible); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2746, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_COACCESSIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 2746, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2747
+ * COACCESSIBLE = fst.kCoAccessible
+ * NOT_COACCESSIBLE = fst.kNotCoAccessible
+ * STRING = fst.kString # <<<<<<<<<<<<<<
+ * NOT_STRING = fst.kNotString
+ * WEIGHTED_CYCLES = fst.kWeightedCycles
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2747, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_STRING, __pyx_t_2) < 0) __PYX_ERR(0, 2747, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2748
+ * NOT_COACCESSIBLE = fst.kNotCoAccessible
+ * STRING = fst.kString
+ * NOT_STRING = fst.kNotString # <<<<<<<<<<<<<<
+ * WEIGHTED_CYCLES = fst.kWeightedCycles
+ * UNWEIGHTED_CYCLES = fst.kUnweightedCycles
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNotString); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2748, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NOT_STRING, __pyx_t_2) < 0) __PYX_ERR(0, 2748, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2749
+ * STRING = fst.kString
+ * NOT_STRING = fst.kNotString
+ * WEIGHTED_CYCLES = fst.kWeightedCycles # <<<<<<<<<<<<<<
+ * UNWEIGHTED_CYCLES = fst.kUnweightedCycles
+ * NULL_PROPERTIES = fst.kNullProperties
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kWeightedCycles); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2749, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_WEIGHTED_CYCLES, __pyx_t_2) < 0) __PYX_ERR(0, 2749, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2750
+ * NOT_STRING = fst.kNotString
+ * WEIGHTED_CYCLES = fst.kWeightedCycles
+ * UNWEIGHTED_CYCLES = fst.kUnweightedCycles # <<<<<<<<<<<<<<
+ * NULL_PROPERTIES = fst.kNullProperties
+ * COPY_PROPERTIES = fst.kCopyProperties
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kUnweightedCycles); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2750, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_UNWEIGHTED_CYCLES, __pyx_t_2) < 0) __PYX_ERR(0, 2750, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2751
+ * WEIGHTED_CYCLES = fst.kWeightedCycles
+ * UNWEIGHTED_CYCLES = fst.kUnweightedCycles
+ * NULL_PROPERTIES = fst.kNullProperties # <<<<<<<<<<<<<<
+ * COPY_PROPERTIES = fst.kCopyProperties
+ * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNullProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2751, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NULL_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2751, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2752
+ * UNWEIGHTED_CYCLES = fst.kUnweightedCycles
+ * NULL_PROPERTIES = fst.kNullProperties
+ * COPY_PROPERTIES = fst.kCopyProperties # <<<<<<<<<<<<<<
+ * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties
+ * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kCopyProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2752, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_COPY_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2752, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2753
+ * NULL_PROPERTIES = fst.kNullProperties
+ * COPY_PROPERTIES = fst.kCopyProperties
+ * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties # <<<<<<<<<<<<<<
+ * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties
+ * SET_START_PROPERTIES = fst.kSetStartProperties
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kIntrinsicProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2753, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTRINSIC_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2753, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2754
+ * COPY_PROPERTIES = fst.kCopyProperties
+ * INTRINSIC_PROPERTIES = fst.kIntrinsicProperties
+ * EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties # <<<<<<<<<<<<<<
+ * SET_START_PROPERTIES = fst.kSetStartProperties
+ * SET_FINAL_PROPERTIES = fst.kSetFinalProperties
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kExtrinsicProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2754, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_EXTRINSIC_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2754, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2755
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kSetStartProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2755, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_SET_START_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2755, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2756
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kSetFinalProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2756, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_SET_FINAL_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2756, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2757
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kAddStateProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2757, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD_STATE_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2757, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2758
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kAddArcProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2758, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD_ARC_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2758, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2759
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kSetArcProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2759, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_SET_ARC_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2759, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2760
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kDeleteStatesProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2760, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_DELETE_STATE_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2760, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2761
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kDeleteArcsProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2761, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_DELETE_ARC_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2761, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2762
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kStateSortProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2762, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_STATE_SORT_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2762, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2763
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kArcSortProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2763, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARC_SORT_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2763, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2764
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kILabelInvariantProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2764, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_I_LABEL_INVARIANT_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2764, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2765
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kOLabelInvariantProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2765, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_O_LABEL_INVARIANT_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2765, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2766
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kWeightInvariantProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2766, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_WEIGHT_INVARIANT_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2766, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2767
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kAddSuperFinalProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2767, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADD_SUPERFINAL_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2767, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2768
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kRmSuperFinalProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2768, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_RM_SUPERFINAL_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2768, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2769
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kBinaryProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2769, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_BINARY_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2769, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2770
+ * 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_2 = __Pyx_PyInt_From_uint64_t(fst::kTrinaryProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2770, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_TRINARY_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2770, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2771
+ * BINARY_PROPERTIES = fst.kBinaryProperties
+ * TRINARY_PROPERTIES = fst.kTrinaryProperties
+ * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties # <<<<<<<<<<<<<<
+ * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties
+ * FST_PROPERTIES = fst.kFstProperties
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kPosTrinaryProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2771, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_POS_TRINARY_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2771, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2772
+ * TRINARY_PROPERTIES = fst.kTrinaryProperties
+ * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties
+ * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties # <<<<<<<<<<<<<<
+ * FST_PROPERTIES = fst.kFstProperties
+ *
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kNegTrinaryProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2772, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NEG_TRINARY_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2772, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":2773
+ * POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties
+ * NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties
+ * FST_PROPERTIES = fst.kFstProperties # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_uint64_t(fst::kFstProperties); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2773, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_FST_PROPERTIES, __pyx_t_2) < 0) __PYX_ERR(0, 2773, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":3218
+ *
+ * cdef _Fst _map(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * mt=b"identity",
+ * weight=None):
+ */
+ __pyx_k__34 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3231
+ *
+ * cpdef _Fst arcmap(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * mt=b"identity",
+ * weight=None):
+ */
+ __pyx_k__35 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3230
+ *
+ *
+ * cpdef _Fst arcmap(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * mt=b"identity",
+ */
+ __pyx_k__35 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3334
+ *
+ * cpdef _MutableFst determinize(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * dt=b"functional",
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_k__36 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3336
+ * float delta=fst.kDelta,
+ * dt=b"functional",
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * int64 subsequential_label=0,
+ * weight=None,
+ */
+ __pyx_k__37 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3334
+ *
+ * cpdef _MutableFst determinize(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * dt=b"functional",
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_k__36 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3336
+ * float delta=fst.kDelta,
+ * dt=b"functional",
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * int64 subsequential_label=0,
+ * weight=None,
+ */
+ __pyx_k__37 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3423
+ *
+ * cpdef _MutableFst disambiguate(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * int64 subsequential_label=0,
+ */
+ __pyx_k__38 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3424
+ * cpdef _MutableFst disambiguate(_Fst ifst,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * int64 subsequential_label=0,
+ * weight=None):
+ */
+ __pyx_k__39 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3423
+ *
+ * cpdef _MutableFst disambiguate(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * int64 subsequential_label=0,
+ */
+ __pyx_k__38 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3424
+ * cpdef _MutableFst disambiguate(_Fst ifst,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * int64 subsequential_label=0,
+ * weight=None):
+ */
+ __pyx_k__39 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3492
+ *
+ *
+ * cpdef bool equal(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<<
+ * """
+ * equal(ifst1, ifst2, delta=0.0009765625)
+ */
+ __pyx_k__40 = fst::kDelta;
+ __pyx_k__40 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3515
+ *
+ *
+ * cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *: # <<<<<<<<<<<<<<
+ * """
+ * equivalent(ifst1, ifst2, delta=0.0009765625)
+ */
+ __pyx_k__41 = fst::kDelta;
+ __pyx_k__41 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3577
+ *
+ *
+ * cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta): # <<<<<<<<<<<<<<
+ * """
+ * isomorphic(ifst1, ifst2, delta=0.0009765625)
+ */
+ __pyx_k__43 = fst::kDelta;
+ __pyx_k__43 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3604
+ *
+ * cpdef _MutableFst prune(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * weight=None):
+ */
+ __pyx_k__44 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3605
+ * cpdef _MutableFst prune(_Fst ifst,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ __pyx_k__45 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3604
+ *
+ * cpdef _MutableFst prune(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * weight=None):
+ */
+ __pyx_k__44 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3605
+ * cpdef _MutableFst prune(_Fst ifst,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * weight=None):
+ * """
+ */
+ __pyx_k__45 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3636
+ *
+ * cpdef _MutableFst push(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * bool push_weights=False,
+ * bool push_labels=False,
+ */
+ __pyx_k__46 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3635
+ *
+ *
+ * cpdef _MutableFst push(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * bool push_weights=False,
+ */
+ __pyx_k__46 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3690
+ * _Fst ifst2,
+ * int32 npath=1,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * time_t seed=0,
+ * select=b"uniform",
+ */
+ __pyx_k__47 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3693
+ * time_t seed=0,
+ * select=b"uniform",
+ * int32 max_length=INT32_MAX) except *: # <<<<<<<<<<<<<<
+ * """
+ * randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0,
+ */
+ __pyx_k__48 = INT32_MAX;
+
+ /* "pywrapfst.pyx":3690
+ * _Fst ifst2,
+ * int32 npath=1,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * time_t seed=0,
+ * select=b"uniform",
+ */
+ __pyx_k__47 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3693
+ * time_t seed=0,
+ * select=b"uniform",
+ * int32 max_length=INT32_MAX) except *: # <<<<<<<<<<<<<<
+ * """
+ * randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0,
+ */
+ __pyx_k__48 = INT32_MAX;
+
+ /* "pywrapfst.pyx":3745
+ * time_t seed=0,
+ * select=b"uniform",
+ * int32 max_length=INT32_MAX, # <<<<<<<<<<<<<<
+ * bool weighted=False,
+ * bool remove_total_weight=False):
+ */
+ __pyx_k__50 = INT32_MAX;
+
+ /* "pywrapfst.pyx":3741
+ *
+ *
+ * cpdef _MutableFst randgen(_Fst ifst, # <<<<<<<<<<<<<<
+ * int32 npath=1,
+ * time_t seed=0,
+ */
+ __pyx_k__50 = INT32_MAX;
+
+ /* "pywrapfst.pyx":3878
+ * cpdef _MutableFst rmepsilon(_Fst ifst,
+ * bool connect=True,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ */
+ __pyx_k__51 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3879
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * qt=b"auto",
+ * bool reverse=False,
+ */
+ __pyx_k__52 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3878
+ * cpdef _MutableFst rmepsilon(_Fst ifst,
+ * bool connect=True,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ */
+ __pyx_k__51 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3879
+ * bool connect=True,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * qt=b"auto",
+ * bool reverse=False,
+ */
+ __pyx_k__52 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3919
+ *
+ * cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst,
+ * float delta=fst.kDelta, int64 nstate=fst.kNoStateId, qt=b"auto", # <<<<<<<<<<<<<<
+ * bool reverse=False) except *:
+ * cdef vector[fst.WeightClass] *distance = new vector[fst.WeightClass]()
+ */
+ __pyx_k__53 = fst::kDelta;
+ __pyx_k__54 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3937
+ *
+ * def shortestdistance(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int64 nstate=fst.kNoStateId,
+ * qt=b"auto",
+ */
+ __pyx_k__55 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3938
+ * def shortestdistance(_Fst ifst,
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * qt=b"auto",
+ * bool reverse=False):
+ */
+ __pyx_k__56 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3936
+ *
+ *
+ * def shortestdistance(_Fst ifst, # <<<<<<<<<<<<<<
+ * float delta=fst.kDelta,
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_49shortestdistance, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3936, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_shortestdistance, __pyx_t_2) < 0) __PYX_ERR(0, 3936, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":3981
+ *
+ * cpdef _MutableFst shortestpath(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int32 nshortest=1,
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_k__57 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3983
+ * float delta=fst.kDelta,
+ * int32 nshortest=1,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * qt=b"auto",
+ * bool unique=False,
+ */
+ __pyx_k__58 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":3981
+ *
+ * cpdef _MutableFst shortestpath(_Fst ifst,
+ * float delta=fst.kDelta, # <<<<<<<<<<<<<<
+ * int32 nshortest=1,
+ * int64 nstate=fst.kNoStateId,
+ */
+ __pyx_k__57 = fst::kDelta;
+
+ /* "pywrapfst.pyx":3983
+ * float delta=fst.kDelta,
+ * int32 nshortest=1,
+ * int64 nstate=fst.kNoStateId, # <<<<<<<<<<<<<<
+ * qt=b"auto",
+ * bool unique=False,
+ */
+ __pyx_k__58 = fst::kNoStateId;
+
+ /* "pywrapfst.pyx":4135
+ *
+ * def __cinit__(self,
+ * string fst_type=b"vector", # <<<<<<<<<<<<<<
+ * string arc_type=b"standard",
+ * SymbolTable isymbols=None,
+ */
+ __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_vector); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4135, __pyx_L1_error)
+ __pyx_k__59 = __pyx_t_6;
+
+ /* "pywrapfst.pyx":4136
+ * def __cinit__(self,
+ * string fst_type=b"vector",
+ * string arc_type=b"standard", # <<<<<<<<<<<<<<
+ * SymbolTable isymbols=None,
+ * SymbolTable osymbols=None,
+ */
+ __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_n_b_standard); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4136, __pyx_L1_error)
+ __pyx_k__60 = __pyx_t_6;
+
+ /* "pywrapfst.pyx":4236
+ *
+ * @classmethod
+ * def open(cls, *filenames): # <<<<<<<<<<<<<<
+ * """
+ * FarReader.open(*filenames)
+ */
+ __pyx_t_2 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_FarReader, __pyx_n_s_open); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4236, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+
+ /* "pywrapfst.pyx":4235
+ * return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self))
+ *
+ * @classmethod # <<<<<<<<<<<<<<
+ * def open(cls, *filenames):
+ * """
+ */
+ __pyx_t_1 = __Pyx_Method_ClassMethod(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4235, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __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_1) < 0) __PYX_ERR(0, 4236, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_FarReader);
+
+ /* "pywrapfst.pyx":4411
+ *
+ * @classmethod
+ * def create(cls, filename, arc_type=b"standard", far_type=b"default"): # <<<<<<<<<<<<<<
+ * """
+ * FarWriter.
+ */
+ __pyx_t_1 = __Pyx_GetNameInClass((PyObject *)__pyx_ptype_9pywrapfst_FarWriter, __pyx_n_s_create); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4411, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+
+ /* "pywrapfst.pyx":4410
+ * return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self))
+ *
+ * @classmethod # <<<<<<<<<<<<<<
+ * def create(cls, filename, arc_type=b"standard", far_type=b"default"):
+ * """
+ */
+ __pyx_t_2 = __Pyx_Method_ClassMethod(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4410, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (PyDict_SetItem((PyObject *)__pyx_ptype_9pywrapfst_FarWriter->tp_dict, __pyx_n_s_create, __pyx_t_2) < 0) __PYX_ERR(0, 4411, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ PyType_Modified(__pyx_ptype_9pywrapfst_FarWriter);
+
+ /* "pywrapfst.pyx":4503
+ *
+ *
+ * _fst_error_fatal_old = fst.FLAGS_fst_error_fatal # <<<<<<<<<<<<<<
+ * fst.FLAGS_fst_error_fatal = False
+ *
+ */
+ __pyx_t_2 = __Pyx_PyBool_FromLong(FLAGS_fst_error_fatal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4503, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_fst_error_fatal_old, __pyx_t_2) < 0) __PYX_ERR(0, 4503, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":4504
+ *
+ * _fst_error_fatal_old = fst.FLAGS_fst_error_fatal
+ * fst.FLAGS_fst_error_fatal = False # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ FLAGS_fst_error_fatal = 0;
+
+ /* "pywrapfst.pyx":4507
+ *
+ *
+ * @atexit.register # <<<<<<<<<<<<<<
+ * def _reset_fst_error_fatal():
+ * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_atexit); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_register); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "pywrapfst.pyx":4508
+ *
+ * @atexit.register
+ * def _reset_fst_error_fatal(): # <<<<<<<<<<<<<<
+ * fst.FLAGS_fst_error_fatal = _fst_error_fatal_old
+ *
+ */
+ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_9pywrapfst_57_reset_fst_error_fatal, NULL, __pyx_n_s_pywrapfst_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4508, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_4 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_3, function);
+ }
+ }
+ if (!__pyx_t_4) {
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ } else {
+ #if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
+ __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ } else
+ #endif
+ #if CYTHON_FAST_PYCCALL
+ if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+ PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_1};
+ __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ } else
+ #endif
+ {
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __Pyx_GIVEREF(__pyx_t_1);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_1);
+ __pyx_t_1 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ }
+ }
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_reset_fst_error_fatal, __pyx_t_2) < 0) __PYX_ERR(0, 4508, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "pywrapfst.pyx":1
+ * #cython: nonecheck=True # <<<<<<<<<<<<<<
+ * # Licensed under the Apache License, Version 2.0 (the "License");
+ * # you may not use this file except in compliance with the License.
+ */
+ __pyx_t_2 = PyDict_New(); 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":50
+ *
+ * @cname("__pyx_convert_vector_from_py_std_3a__3a_string")
+ * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: # <<<<<<<<<<<<<<
+ * cdef vector[X] v
+ * for item in o:
+ */
+
+ /*--- Wrapped vars code ---*/
+
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_XDECREF(__pyx_t_5);
+ if (__pyx_m) {
+ if (__pyx_d) {
+ __Pyx_AddTraceback("init pywrapfst", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ }
+ Py_DECREF(__pyx_m); __pyx_m = 0;
+ } else if (!PyErr_Occurred()) {
+ PyErr_SetString(PyExc_ImportError, "init pywrapfst");
+ }
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ #if PY_MAJOR_VERSION < 3
+ return;
+ #else
+ return __pyx_m;
+ #endif
+}
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+ PyObject *m = NULL, *p = NULL;
+ void *r = NULL;
+ m = PyImport_ImportModule((char *)modname);
+ if (!m) goto end;
+ p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
+ if (!p) goto end;
+ r = PyLong_AsVoidPtr(p);
+end:
+ Py_XDECREF(p);
+ Py_XDECREF(m);
+ return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+ PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
+ if (unlikely(!result)) {
+ PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+ "name '%U' is not defined", name);
+#else
+ "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+ }
+ return result;
+}
+
+/* PyCFunctionFastCall */
+#if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
+ PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
+ PyCFunction meth = PyCFunction_GET_FUNCTION(func);
+ PyObject *self = PyCFunction_GET_SELF(func);
+ assert(PyCFunction_Check(func));
+ assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)));
+ 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());
+ return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL);
+}
+#endif // CYTHON_FAST_PYCCALL
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL
+#include "frameobject.h"
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+ PyObject *globals) {
+ PyFrameObject *f;
+ PyThreadState *tstate = PyThreadState_GET();
+ PyObject **fastlocals;
+ Py_ssize_t i;
+ PyObject *result;
+ assert(globals != NULL);
+ /* XXX Perhaps we should create a specialized
+ PyFrame_New() that doesn't take locals, but does
+ take builtins without sanity checking them.
+ */
+ assert(tstate != NULL);
+ f = PyFrame_New(tstate, co, globals, NULL);
+ if (f == NULL) {
+ return NULL;
+ }
+ fastlocals = f->f_localsplus;
+ for (i = 0; i < na; i++) {
+ Py_INCREF(*args);
+ fastlocals[i] = *args++;
+ }
+ result = PyEval_EvalFrameEx(f,0);
+ ++tstate->recursion_depth;
+ Py_DECREF(f);
+ --tstate->recursion_depth;
+ return result;
+}
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) {
+ PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+ PyObject *globals = PyFunction_GET_GLOBALS(func);
+ PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+ PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+ PyObject *kwdefs;
+#endif
+ PyObject *kwtuple, **k;
+ PyObject **d;
+ Py_ssize_t nd;
+ Py_ssize_t nk;
+ PyObject *result;
+ assert(kwargs == NULL || PyDict_Check(kwargs));
+ nk = kwargs ? PyDict_Size(kwargs) : 0;
+ if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+ return NULL;
+ }
+ if (
+#if PY_MAJOR_VERSION >= 3
+ co->co_kwonlyargcount == 0 &&
+#endif
+ likely(kwargs == NULL || nk == 0) &&
+ co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+ if (argdefs == NULL && co->co_argcount == nargs) {
+ result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+ goto done;
+ }
+ else if (nargs == 0 && argdefs != NULL
+ && co->co_argcount == Py_SIZE(argdefs)) {
+ /* function called with no arguments, but all parameters have
+ a default value: use default values as arguments .*/
+ args = &PyTuple_GET_ITEM(argdefs, 0);
+ result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+ goto done;
+ }
+ }
+ if (kwargs != NULL) {
+ Py_ssize_t pos, i;
+ kwtuple = PyTuple_New(2 * nk);
+ if (kwtuple == NULL) {
+ result = NULL;
+ goto done;
+ }
+ k = &PyTuple_GET_ITEM(kwtuple, 0);
+ pos = i = 0;
+ while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+ Py_INCREF(k[i]);
+ Py_INCREF(k[i+1]);
+ i += 2;
+ }
+ nk = i / 2;
+ }
+ else {
+ kwtuple = NULL;
+ k = NULL;
+ }
+ closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+ kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+ if (argdefs != NULL) {
+ d = &PyTuple_GET_ITEM(argdefs, 0);
+ nd = Py_SIZE(argdefs);
+ }
+ else {
+ d = NULL;
+ nd = 0;
+ }
+#if PY_MAJOR_VERSION >= 3
+ result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+ args, nargs,
+ k, (int)nk,
+ d, (int)nd, kwdefs, closure);
+#else
+ result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+ args, nargs,
+ k, (int)nk,
+ d, (int)nd, closure);
+#endif
+ Py_XDECREF(kwtuple);
+done:
+ Py_LeaveRecursiveCall();
+ return result;
+}
+#endif // CPython < 3.6
+#endif // CYTHON_FAST_PYCALL
+
+/* 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
+#ifdef __Pyx_CyFunction_USED
+ if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
+#else
+ if (likely(PyCFunction_Check(func))) {
+#endif
+ if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
+ return __Pyx_PyObject_CallMethO(func, arg);
+#if CYTHON_FAST_PYCCALL
+ } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
+ return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+#endif
+ }
+ }
+ return __Pyx__PyObject_CallOneArg(func, arg);
+}
+#else
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+ PyObject *result;
+ PyObject *args = PyTuple_Pack(1, arg);
+ if (unlikely(!args)) return NULL;
+ result = __Pyx_PyObject_Call(func, args, NULL);
+ Py_DECREF(args);
+ return result;
+}
+#endif
+
+/* GetModuleGlobalName */
+ static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
+ PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+ result = PyDict_GetItem(__pyx_d, name);
+ if (likely(result)) {
+ Py_INCREF(result);
+ } else {
+#else
+ result = PyObject_GetItem(__pyx_d, name);
+ if (!result) {
+ PyErr_Clear();
+#endif
+ result = __Pyx_GetBuiltinName(name);
+ }
+ return result;
+}
+
+/* PyErrFetchRestore */
+ #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+ PyObject *tmp_type, *tmp_value, *tmp_tb;
+ tmp_type = tstate->curexc_type;
+ tmp_value = tstate->curexc_value;
+ tmp_tb = tstate->curexc_traceback;
+ tstate->curexc_type = type;
+ tstate->curexc_value = value;
+ tstate->curexc_traceback = tb;
+ Py_XDECREF(tmp_type);
+ Py_XDECREF(tmp_value);
+ Py_XDECREF(tmp_tb);
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+ *type = tstate->curexc_type;
+ *value = tstate->curexc_value;
+ *tb = tstate->curexc_traceback;
+ tstate->curexc_type = 0;
+ tstate->curexc_value = 0;
+ tstate->curexc_traceback = 0;
+}
+#endif
+
+/* RaiseException */
+ #if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
+ CYTHON_UNUSED PyObject *cause) {
+ __Pyx_PyThreadState_declare
+ Py_XINCREF(type);
+ if (!value || value == Py_None)
+ value = NULL;
+ else
+ Py_INCREF(value);
+ if (!tb || tb == Py_None)
+ tb = NULL;
+ else {
+ Py_INCREF(tb);
+ if (!PyTraceBack_Check(tb)) {
+ PyErr_SetString(PyExc_TypeError,
+ "raise: arg 3 must be a traceback or None");
+ goto raise_error;
+ }
+ }
+ if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+ if (!value) {
+ Py_INCREF(Py_None);
+ value = Py_None;
+ }
+#endif
+ PyErr_NormalizeException(&type, &value, &tb);
+ } else {
+ if (value) {
+ PyErr_SetString(PyExc_TypeError,
+ "instance exception may not have a separate value");
+ goto raise_error;
+ }
+ value = type;
+ type = (PyObject*) Py_TYPE(type);
+ Py_INCREF(type);
+ if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+ PyErr_SetString(PyExc_TypeError,
+ "raise: exception class must be a subclass of BaseException");
+ goto raise_error;
+ }
+ }
+ __Pyx_PyThreadState_assign
+ __Pyx_ErrRestore(type, value, tb);
+ return;
+raise_error:
+ Py_XDECREF(value);
+ Py_XDECREF(type);
+ Py_XDECREF(tb);
+ return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+ PyObject* owned_instance = NULL;
+ if (tb == Py_None) {
+ tb = 0;
+ } else if (tb && !PyTraceBack_Check(tb)) {
+ PyErr_SetString(PyExc_TypeError,
+ "raise: arg 3 must be a traceback or None");
+ goto bad;
+ }
+ if (value == Py_None)
+ value = 0;
+ if (PyExceptionInstance_Check(type)) {
+ if (value) {
+ PyErr_SetString(PyExc_TypeError,
+ "instance exception may not have a separate value");
+ goto bad;
+ }
+ value = type;
+ type = (PyObject*) Py_TYPE(value);
+ } else if (PyExceptionClass_Check(type)) {
+ PyObject *instance_class = NULL;
+ if (value && PyExceptionInstance_Check(value)) {
+ instance_class = (PyObject*) Py_TYPE(value);
+ if (instance_class != type) {
+ int is_subclass = PyObject_IsSubclass(instance_class, type);
+ if (!is_subclass) {
+ instance_class = NULL;
+ } else if (unlikely(is_subclass == -1)) {
+ goto bad;
+ } else {
+ type = instance_class;
+ }
+ }
+ }
+ if (!instance_class) {
+ PyObject *args;
+ if (!value)
+ args = PyTuple_New(0);
+ else if (PyTuple_Check(value)) {
+ Py_INCREF(value);
+ args = value;
+ } else
+ args = PyTuple_Pack(1, value);
+ if (!args)
+ goto bad;
+ owned_instance = PyObject_Call(type, args, NULL);
+ Py_DECREF(args);
+ if (!owned_instance)
+ goto bad;
+ value = owned_instance;
+ if (!PyExceptionInstance_Check(value)) {
+ PyErr_Format(PyExc_TypeError,
+ "calling %R should have returned an instance of "
+ "BaseException, not %R",
+ type, Py_TYPE(value));
+ goto bad;
+ }
+ }
+ } else {
+ PyErr_SetString(PyExc_TypeError,
+ "raise: exception class must be a subclass of BaseException");
+ goto bad;
+ }
+#if PY_VERSION_HEX >= 0x03030000
+ if (cause) {
+#else
+ if (cause && cause != Py_None) {
+#endif
+ 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 = PyThreadState_GET();
+ PyObject* tmp_tb = tstate->curexc_traceback;
+ if (tb != tmp_tb) {
+ Py_INCREF(tb);
+ tstate->curexc_traceback = tb;
+ Py_XDECREF(tmp_tb);
+ }
+#endif
+ }
+bad:
+ Py_XDECREF(owned_instance);
+ return;
+}
+#endif
+
+/* RaiseArgTupleInvalid */
+ static void __Pyx_RaiseArgtupleInvalid(
+ const char* func_name,
+ int exact,
+ Py_ssize_t num_min,
+ Py_ssize_t num_max,
+ Py_ssize_t num_found)
+{
+ Py_ssize_t num_expected;
+ const char *more_or_less;
+ if (num_found < num_min) {
+ num_expected = num_min;
+ more_or_less = "at least";
+ } else {
+ num_expected = num_max;
+ more_or_less = "at most";
+ }
+ if (exact) {
+ more_or_less = "exactly";
+ }
+ PyErr_Format(PyExc_TypeError,
+ "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+ func_name, more_or_less, num_expected,
+ (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* RaiseDoubleKeywords */
+ static void __Pyx_RaiseDoubleKeywordsError(
+ const char* func_name,
+ PyObject* kw_name)
+{
+ PyErr_Format(PyExc_TypeError,
+ #if PY_MAJOR_VERSION >= 3
+ "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+ #else
+ "%s() got multiple values for keyword argument '%s'", func_name,
+ PyString_AsString(kw_name));
+ #endif
+}
+
+/* ParseKeywords */
+ static int __Pyx_ParseOptionalKeywords(
+ PyObject *kwds,
+ PyObject **argnames[],
+ PyObject *kwds2,
+ PyObject *values[],
+ Py_ssize_t num_pos_args,
+ const char* function_name)
+{
+ PyObject *key = 0, *value = 0;
+ Py_ssize_t pos = 0;
+ PyObject*** name;
+ PyObject*** first_kw_arg = argnames + num_pos_args;
+ while (PyDict_Next(kwds, &pos, &key, &value)) {
+ name = first_kw_arg;
+ while (*name && (**name != key)) name++;
+ if (*name) {
+ values[name-argnames] = value;
+ continue;
+ }
+ name = first_kw_arg;
+ #if PY_MAJOR_VERSION < 3
+ if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
+ while (*name) {
+ if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+ && _PyString_Eq(**name, key)) {
+ values[name-argnames] = value;
+ break;
+ }
+ name++;
+ }
+ if (*name) continue;
+ else {
+ PyObject*** argname = argnames;
+ while (argname != first_kw_arg) {
+ if ((**argname == key) || (
+ (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+ && _PyString_Eq(**argname, key))) {
+ goto arg_passed_twice;
+ }
+ argname++;
+ }
+ }
+ } else
+ #endif
+ if (likely(PyUnicode_Check(key))) {
+ while (*name) {
+ int cmp = (**name == key) ? 0 :
+ #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+ (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
+ #endif
+ PyUnicode_Compare(**name, key);
+ if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+ if (cmp == 0) {
+ values[name-argnames] = value;
+ break;
+ }
+ name++;
+ }
+ if (*name) continue;
+ else {
+ PyObject*** argname = argnames;
+ while (argname != first_kw_arg) {
+ int cmp = (**argname == key) ? 0 :
+ #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+ (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
+ #endif
+ PyUnicode_Compare(**argname, key);
+ if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+ if (cmp == 0) goto arg_passed_twice;
+ argname++;
+ }
+ }
+ } else
+ goto invalid_keyword_type;
+ if (kwds2) {
+ if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+ } else {
+ goto invalid_keyword;
+ }
+ }
+ return 0;
+arg_passed_twice:
+ __Pyx_RaiseDoubleKeywordsError(function_name, key);
+ goto bad;
+invalid_keyword_type:
+ PyErr_Format(PyExc_TypeError,
+ "%.200s() keywords must be strings", function_name);
+ goto bad;
+invalid_keyword:
+ PyErr_Format(PyExc_TypeError,
+ #if PY_MAJOR_VERSION < 3
+ "%.200s() got an unexpected keyword argument '%.200s'",
+ function_name, PyString_AsString(key));
+ #else
+ "%s() got an unexpected keyword argument '%U'",
+ function_name, key);
+ #endif
+bad:
+ return -1;
+}
+
+/* PyObjectCallNoArg */
+ #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+#if CYTHON_FAST_PYCALL
+ if (PyFunction_Check(func)) {
+ return __Pyx_PyFunction_FastCall(func, NULL, 0);
+ }
+#endif
+#ifdef __Pyx_CyFunction_USED
+ if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
+#else
+ if (likely(PyCFunction_Check(func))) {
+#endif
+ if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
+ return __Pyx_PyObject_CallMethO(func, NULL);
+ }
+ }
+ return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
+}
+#endif
+
+/* ExtTypeTest */
+ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+ if (unlikely(!type)) {
+ PyErr_SetString(PyExc_SystemError, "Missing type object");
+ return 0;
+ }
+ if (likely(PyObject_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 void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
+ PyErr_Format(PyExc_TypeError,
+ "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
+ name, type->tp_name, Py_TYPE(obj)->tp_name);
+}
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+ const char *name, int exact)
+{
+ if (unlikely(!type)) {
+ PyErr_SetString(PyExc_SystemError, "Missing type object");
+ return 0;
+ }
+ if (none_allowed && obj == Py_None) return 1;
+ else if (exact) {
+ if (likely(Py_TYPE(obj) == type)) return 1;
+ #if PY_MAJOR_VERSION == 2
+ else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+ #endif
+ }
+ else {
+ if (likely(PyObject_TypeCheck(obj, type))) return 1;
+ }
+ __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
+ 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 CYTHON_INLINE 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_CheckExact(key)) && 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;
+}
+
+/* PyIntBinop */
+ #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
+ if (op1 == op2) {
+ Py_RETURN_TRUE;
+ }
+ #if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_CheckExact(op1))) {
+ const long b = intval;
+ long a = PyInt_AS_LONG(op1);
+ if (a == b) {
+ Py_RETURN_TRUE;
+ } else {
+ Py_RETURN_FALSE;
+ }
+ }
+ #endif
+ #if CYTHON_USE_PYLONG_INTERNALS
+ if (likely(PyLong_CheckExact(op1))) {
+ const long b = intval;
+ long a;
+ const digit* digits = ((PyLongObject*)op1)->ob_digit;
+ const Py_ssize_t size = Py_SIZE(op1);
+ if (likely(__Pyx_sst_abs(size) <= 1)) {
+ a = likely(size) ? digits[0] : 0;
+ if (size == -1) a = -a;
+ } else {
+ switch (size) {
+ case -2:
+ if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+ a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+ break;
+ }
+ case 2:
+ if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+ a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+ break;
+ }
+ case -3:
+ if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+ a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+ break;
+ }
+ case 3:
+ if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+ a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+ break;
+ }
+ case -4:
+ if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+ a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+ break;
+ }
+ case 4:
+ if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+ a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+ break;
+ }
+ #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15
+ default: return PyLong_Type.tp_richcompare(op1, op2, Py_EQ);
+ #else
+ default: Py_RETURN_FALSE;
+ #endif
+ }
+ }
+ if (a == b) {
+ Py_RETURN_TRUE;
+ } else {
+ Py_RETURN_FALSE;
+ }
+ }
+ #endif
+ if (PyFloat_CheckExact(op1)) {
+ const long b = intval;
+ double a = PyFloat_AS_DOUBLE(op1);
+ if ((double)a == (double)b) {
+ Py_RETURN_TRUE;
+ } else {
+ Py_RETURN_FALSE;
+ }
+ }
+ return PyObject_RichCompare(op1, op2, Py_EQ);
+}
+#endif
+
+/* SaveResetException */
+ #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+ *type = tstate->exc_type;
+ *value = tstate->exc_value;
+ *tb = tstate->exc_traceback;
+ 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;
+ 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;
+ Py_XDECREF(tmp_type);
+ Py_XDECREF(tmp_value);
+ Py_XDECREF(tmp_tb);
+}
+#endif
+
+/* PyErrExceptionMatches */
+ #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+ PyObject *exc_type = tstate->curexc_type;
+ if (exc_type == err) return 1;
+ if (unlikely(!exc_type)) return 0;
+ return 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
+ 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;
+ 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;
+}
+
+/* BytesEquals */
+ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY
+ return PyObject_RichCompareBool(s1, s2, equals);
+#else
+ if (s1 == s2) {
+ return (equals == Py_EQ);
+ } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+ const char *ps1, *ps2;
+ Py_ssize_t length = PyBytes_GET_SIZE(s1);
+ if (length != PyBytes_GET_SIZE(s2))
+ return (equals == Py_NE);
+ ps1 = PyBytes_AS_STRING(s1);
+ ps2 = PyBytes_AS_STRING(s2);
+ if (ps1[0] != ps2[0]) {
+ return (equals == Py_NE);
+ } else if (length == 1) {
+ return (equals == Py_EQ);
+ } else {
+ int result = memcmp(ps1, ps2, (size_t)length);
+ return (equals == Py_EQ) ? (result == 0) : (result != 0);
+ }
+ } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+ return (equals == Py_NE);
+ } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+ return (equals == Py_NE);
+ } else {
+ int result;
+ PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+ if (!py_result)
+ return -1;
+ result = __Pyx_PyObject_IsTrue(py_result);
+ Py_DECREF(py_result);
+ return result;
+ }
+#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 = PyThreadState_GET();
+ PyObject* exc_type = tstate->curexc_type;
+ if (unlikely(exc_type)) {
+ if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) {
+ PyObject *exc_value, *exc_tb;
+ exc_value = tstate->curexc_value;
+ exc_tb = tstate->curexc_traceback;
+ tstate->curexc_type = 0;
+ tstate->curexc_value = 0;
+ tstate->curexc_traceback = 0;
+ Py_DECREF(exc_type);
+ Py_XDECREF(exc_value);
+ Py_XDECREF(exc_tb);
+ return 0;
+ } else {
+ return -1;
+ }
+ }
+ return 0;
+#else
+ if (unlikely(PyErr_Occurred())) {
+ if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
+ PyErr_Clear();
+ return 0;
+ } else {
+ return -1;
+ }
+ }
+ return 0;
+#endif
+}
+
+/* UnpackItemEndCheck */
+ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+ if (unlikely(retval)) {
+ Py_DECREF(retval);
+ __Pyx_RaiseTooManyValuesError(expected);
+ return -1;
+ } else {
+ return __Pyx_IterFinish();
+ }
+ return 0;
+}
+
+/* IterNext */
+ static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) {
+ PyObject* next;
+ iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
+#if CYTHON_USE_TYPE_SLOTS
+ if (unlikely(!iternext)) {
+#else
+ if (unlikely(!iternext) || unlikely(!PyIter_Check(iterator))) {
+#endif
+ PyErr_Format(PyExc_TypeError,
+ "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name);
+ return NULL;
+ }
+ next = iternext(iterator);
+ if (likely(next))
+ return next;
+#if CYTHON_USE_TYPE_SLOTS
+#if PY_VERSION_HEX >= 0x02070000
+ if (unlikely(iternext == &_PyObject_NextNotImplemented))
+ return NULL;
+#endif
+#endif
+ if (defval) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (unlikely(exc_type != PyExc_StopIteration) &&
+ !PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))
+ return NULL;
+ PyErr_Clear();
+ }
+ Py_INCREF(defval);
+ return defval;
+ }
+ if (!PyErr_Occurred())
+ PyErr_SetNone(PyExc_StopIteration);
+ return NULL;
+}
+
+/* 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;
+}
+
+/* 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_VERSION_HEX < 0x03030000
+ PyObject *py_import;
+ py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+ if (!py_import)
+ goto bad;
+ #endif
+ if (from_list)
+ list = from_list;
+ else {
+ empty_list = PyList_New(0);
+ if (!empty_list)
+ goto bad;
+ list = empty_list;
+ }
+ global_dict = PyModule_GetDict(__pyx_m);
+ if (!global_dict)
+ goto bad;
+ empty_dict = PyDict_New();
+ if (!empty_dict)
+ goto bad;
+ {
+ #if PY_MAJOR_VERSION >= 3
+ if (level == -1) {
+ if (strchr(__Pyx_MODULE_NAME, '.')) {
+ #if PY_VERSION_HEX < 0x03030000
+ PyObject *py_level = PyInt_FromLong(1);
+ if (!py_level)
+ goto bad;
+ module = PyObject_CallFunctionObjArgs(py_import,
+ name, global_dict, empty_dict, list, py_level, NULL);
+ Py_DECREF(py_level);
+ #else
+ module = PyImport_ImportModuleLevelObject(
+ name, global_dict, empty_dict, list, 1);
+ #endif
+ if (!module) {
+ if (!PyErr_ExceptionMatches(PyExc_ImportError))
+ goto bad;
+ PyErr_Clear();
+ }
+ }
+ level = 0;
+ }
+ #endif
+ if (!module) {
+ #if PY_VERSION_HEX < 0x03030000
+ PyObject *py_level = PyInt_FromLong(level);
+ if (!py_level)
+ goto bad;
+ module = PyObject_CallFunctionObjArgs(py_import,
+ name, global_dict, empty_dict, list, py_level, NULL);
+ Py_DECREF(py_level);
+ #else
+ module = PyImport_ImportModuleLevelObject(
+ name, global_dict, empty_dict, list, level);
+ #endif
+ }
+ }
+bad:
+ #if PY_VERSION_HEX < 0x03030000
+ Py_XDECREF(py_import);
+ #endif
+ Py_XDECREF(empty_list);
+ Py_XDECREF(empty_dict);
+ return module;
+}
+
+/* CalculateMetaclass */
+ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
+ Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);
+ for (i=0; i < nbases; i++) {
+ PyTypeObject *tmptype;
+ PyObject *tmp = PyTuple_GET_ITEM(bases, i);
+ tmptype = Py_TYPE(tmp);
+#if PY_MAJOR_VERSION < 3
+ if (tmptype == &PyClass_Type)
+ continue;
+#endif
+ if (!metaclass) {
+ metaclass = tmptype;
+ continue;
+ }
+ if (PyType_IsSubtype(metaclass, tmptype))
+ continue;
+ if (PyType_IsSubtype(tmptype, metaclass)) {
+ metaclass = tmptype;
+ continue;
+ }
+ PyErr_SetString(PyExc_TypeError,
+ "metaclass conflict: "
+ "the metaclass of a derived class "
+ "must be a (non-strict) subclass "
+ "of the metaclasses of all its bases");
+ return NULL;
+ }
+ if (!metaclass) {
+#if PY_MAJOR_VERSION < 3
+ metaclass = &PyClass_Type;
+#else
+ metaclass = &PyType_Type;
+#endif
+ }
+ Py_INCREF((PyObject*) metaclass);
+ return (PyObject*) metaclass;
+}
+
+/* Py3ClassCreate */
+ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
+ PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
+ PyObject *ns;
+ if (metaclass) {
+ PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare);
+ if (prep) {
+ PyObject *pargs = PyTuple_Pack(2, name, bases);
+ if (unlikely(!pargs)) {
+ Py_DECREF(prep);
+ return NULL;
+ }
+ ns = PyObject_Call(prep, pargs, mkw);
+ Py_DECREF(prep);
+ Py_DECREF(pargs);
+ } else {
+ if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError)))
+ return NULL;
+ PyErr_Clear();
+ ns = PyDict_New();
+ }
+ } else {
+ ns = PyDict_New();
+ }
+ if (unlikely(!ns))
+ return NULL;
+ if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad;
+ if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad;
+ if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad;
+ return ns;
+bad:
+ Py_DECREF(ns);
+ return NULL;
+}
+static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
+ PyObject *dict, PyObject *mkw,
+ int calculate_metaclass, int allow_py2_metaclass) {
+ PyObject *result, *margs;
+ PyObject *owned_metaclass = NULL;
+ if (allow_py2_metaclass) {
+ owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass);
+ if (owned_metaclass) {
+ metaclass = owned_metaclass;
+ } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
+ PyErr_Clear();
+ } else {
+ return NULL;
+ }
+ }
+ if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) {
+ metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
+ Py_XDECREF(owned_metaclass);
+ if (unlikely(!metaclass))
+ return NULL;
+ owned_metaclass = metaclass;
+ }
+ margs = PyTuple_Pack(3, name, bases, dict);
+ if (unlikely(!margs)) {
+ result = NULL;
+ } else {
+ result = PyObject_Call(metaclass, margs, mkw);
+ Py_DECREF(margs);
+ }
+ Py_XDECREF(owned_metaclass);
+ return result;
+}
+
+/* GetNameInClass */
+ static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name) {
+ PyObject *result;
+ result = __Pyx_PyObject_GetAttrStr(nmspace, name);
+ if (!result)
+ result = __Pyx_GetModuleGlobalName(name);
+ return result;
+}
+
+/* ClassMethod */
+ static PyObject* __Pyx_Method_ClassMethod(PyObject *method) {
+#if CYTHON_COMPILING_IN_PYPY
+ if (PyObject_TypeCheck(method, &PyWrapperDescr_Type)) {
+ return PyClassMethod_New(method);
+ }
+#else
+#if CYTHON_COMPILING_IN_PYSTON
+ if (PyMethodDescr_Check(method)) {
+#else
+ static PyTypeObject *methoddescr_type = NULL;
+ if (methoddescr_type == NULL) {
+ PyObject *meth = PyObject_GetAttrString((PyObject*)&PyList_Type, "append");
+ if (!meth) return NULL;
+ methoddescr_type = Py_TYPE(meth);
+ Py_DECREF(meth);
+ }
+ if (PyObject_TypeCheck(method, methoddescr_type)) {
+#endif
+ PyMethodDescrObject *descr = (PyMethodDescrObject *)method;
+ #if PY_VERSION_HEX < 0x03020000
+ PyTypeObject *d_type = descr->d_type;
+ #else
+ PyTypeObject *d_type = descr->d_common.d_type;
+ #endif
+ return PyDescr_NewClassMethod(d_type, descr->d_method);
+ }
+#endif
+ else if (PyMethod_Check(method)) {
+ return PyClassMethod_New(PyMethod_GET_FUNCTION(method));
+ }
+ else if (PyCFunction_Check(method)) {
+ return PyClassMethod_New(method);
+ }
+#ifdef __Pyx_CyFunction_USED
+ else if (PyObject_TypeCheck(method, __pyx_CyFunctionType)) {
+ return PyClassMethod_New(method);
+ }
+#endif
+ PyErr_SetString(PyExc_TypeError,
+ "Class-level classmethod() can only be called on "
+ "a method_descriptor or instance method.");
+ return NULL;
+}
+
+/* FetchCommonType */
+ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+ PyObject* fake_module;
+ PyTypeObject* cached_type = NULL;
+ fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
+ if (!fake_module) return NULL;
+ Py_INCREF(fake_module);
+ cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
+ if (cached_type) {
+ if (!PyType_Check((PyObject*)cached_type)) {
+ PyErr_Format(PyExc_TypeError,
+ "Shared Cython type %.200s is not a type object",
+ type->tp_name);
+ goto bad;
+ }
+ if (cached_type->tp_basicsize != type->tp_basicsize) {
+ PyErr_Format(PyExc_TypeError,
+ "Shared Cython type %.200s has the wrong size, try recompiling",
+ type->tp_name);
+ goto bad;
+ }
+ } else {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+ PyErr_Clear();
+ if (PyType_Ready(type) < 0) goto bad;
+ if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
+ goto bad;
+ Py_INCREF(type);
+ cached_type = type;
+ }
+done:
+ Py_DECREF(fake_module);
+ return cached_type;
+bad:
+ Py_XDECREF(cached_type);
+ cached_type = NULL;
+ goto done;
+}
+
+/* CythonFunction */
+ static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
+{
+ if (unlikely(op->func_doc == NULL)) {
+ if (op->func.m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+ op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
+#else
+ op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
+#endif
+ if (unlikely(op->func_doc == NULL))
+ return NULL;
+ } else {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ }
+ Py_INCREF(op->func_doc);
+ return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value)
+{
+ PyObject *tmp = op->func_doc;
+ if (value == NULL) {
+ value = Py_None;
+ }
+ Py_INCREF(value);
+ op->func_doc = value;
+ Py_XDECREF(tmp);
+ return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op)
+{
+ if (unlikely(op->func_name == NULL)) {
+#if PY_MAJOR_VERSION >= 3
+ op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
+#else
+ op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
+#endif
+ if (unlikely(op->func_name == NULL))
+ return NULL;
+ }
+ Py_INCREF(op->func_name);
+ return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value)
+{
+ PyObject *tmp;
+#if PY_MAJOR_VERSION >= 3
+ if (unlikely(value == NULL || !PyUnicode_Check(value))) {
+#else
+ if (unlikely(value == NULL || !PyString_Check(value))) {
+#endif
+ PyErr_SetString(PyExc_TypeError,
+ "__name__ must be set to a string object");
+ return -1;
+ }
+ tmp = op->func_name;
+ Py_INCREF(value);
+ op->func_name = value;
+ Py_XDECREF(tmp);
+ return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op)
+{
+ Py_INCREF(op->func_qualname);
+ return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value)
+{
+ PyObject *tmp;
+#if PY_MAJOR_VERSION >= 3
+ if (unlikely(value == NULL || !PyUnicode_Check(value))) {
+#else
+ if (unlikely(value == NULL || !PyString_Check(value))) {
+#endif
+ PyErr_SetString(PyExc_TypeError,
+ "__qualname__ must be set to a string object");
+ return -1;
+ }
+ tmp = op->func_qualname;
+ Py_INCREF(value);
+ op->func_qualname = value;
+ Py_XDECREF(tmp);
+ return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
+{
+ PyObject *self;
+ self = m->func_closure;
+ if (self == NULL)
+ self = Py_None;
+ Py_INCREF(self);
+ return self;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op)
+{
+ if (unlikely(op->func_dict == NULL)) {
+ op->func_dict = PyDict_New();
+ if (unlikely(op->func_dict == NULL))
+ return NULL;
+ }
+ Py_INCREF(op->func_dict);
+ return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value)
+{
+ PyObject *tmp;
+ if (unlikely(value == NULL)) {
+ PyErr_SetString(PyExc_TypeError,
+ "function's dictionary may not be deleted");
+ return -1;
+ }
+ if (unlikely(!PyDict_Check(value))) {
+ PyErr_SetString(PyExc_TypeError,
+ "setting function's dictionary to a non-dict");
+ return -1;
+ }
+ tmp = op->func_dict;
+ Py_INCREF(value);
+ op->func_dict = value;
+ Py_XDECREF(tmp);
+ return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op)
+{
+ Py_INCREF(op->func_globals);
+ return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op)
+{
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op)
+{
+ PyObject* result = (op->func_code) ? op->func_code : Py_None;
+ Py_INCREF(result);
+ return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+ int result = 0;
+ PyObject *res = op->defaults_getter((PyObject *) op);
+ if (unlikely(!res))
+ return -1;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+ Py_INCREF(op->defaults_tuple);
+ op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+ Py_INCREF(op->defaults_kwdict);
+ #else
+ op->defaults_tuple = PySequence_ITEM(res, 0);
+ if (unlikely(!op->defaults_tuple)) result = -1;
+ else {
+ op->defaults_kwdict = PySequence_ITEM(res, 1);
+ if (unlikely(!op->defaults_kwdict)) result = -1;
+ }
+ #endif
+ Py_DECREF(res);
+ return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) {
+ PyObject* tmp;
+ if (!value) {
+ value = Py_None;
+ } else if (value != Py_None && !PyTuple_Check(value)) {
+ PyErr_SetString(PyExc_TypeError,
+ "__defaults__ must be set to a tuple object");
+ return -1;
+ }
+ Py_INCREF(value);
+ tmp = op->defaults_tuple;
+ op->defaults_tuple = value;
+ Py_XDECREF(tmp);
+ return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) {
+ PyObject* result = op->defaults_tuple;
+ if (unlikely(!result)) {
+ if (op->defaults_getter) {
+ if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+ result = op->defaults_tuple;
+ } else {
+ result = Py_None;
+ }
+ }
+ Py_INCREF(result);
+ return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) {
+ PyObject* tmp;
+ if (!value) {
+ value = Py_None;
+ } else if (value != Py_None && !PyDict_Check(value)) {
+ PyErr_SetString(PyExc_TypeError,
+ "__kwdefaults__ must be set to a dict object");
+ return -1;
+ }
+ Py_INCREF(value);
+ tmp = op->defaults_kwdict;
+ op->defaults_kwdict = value;
+ Py_XDECREF(tmp);
+ return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) {
+ PyObject* result = op->defaults_kwdict;
+ if (unlikely(!result)) {
+ if (op->defaults_getter) {
+ if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
+ result = op->defaults_kwdict;
+ } else {
+ result = Py_None;
+ }
+ }
+ Py_INCREF(result);
+ return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) {
+ PyObject* tmp;
+ if (!value || value == Py_None) {
+ value = NULL;
+ } else if (!PyDict_Check(value)) {
+ PyErr_SetString(PyExc_TypeError,
+ "__annotations__ must be set to a dict object");
+ return -1;
+ }
+ Py_XINCREF(value);
+ tmp = op->func_annotations;
+ op->func_annotations = value;
+ Py_XDECREF(tmp);
+ return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) {
+ PyObject* result = op->func_annotations;
+ if (unlikely(!result)) {
+ result = PyDict_New();
+ if (unlikely(!result)) return NULL;
+ op->func_annotations = result;
+ }
+ Py_INCREF(result);
+ return result;
+}
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+ {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+ {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+ {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+ {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+ {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+ {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0},
+ {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+ {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+ {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+ {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+ {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+ {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+ {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+ {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+ {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+ {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+ {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+ {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+ {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+ {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0},
+ {0, 0, 0, 0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
+{
+#if PY_MAJOR_VERSION >= 3
+ return PyUnicode_FromString(m->func.m_ml->ml_name);
+#else
+ return PyString_FromString(m->func.m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+ {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+ {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname,
+ PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+ __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type);
+ if (op == NULL)
+ return NULL;
+ op->flags = flags;
+ __Pyx_CyFunction_weakreflist(op) = NULL;
+ op->func.m_ml = ml;
+ op->func.m_self = (PyObject *) op;
+ Py_XINCREF(closure);
+ op->func_closure = closure;
+ Py_XINCREF(module);
+ op->func.m_module = module;
+ op->func_dict = NULL;
+ op->func_name = NULL;
+ Py_INCREF(qualname);
+ op->func_qualname = qualname;
+ op->func_doc = NULL;
+ op->func_classobj = NULL;
+ op->func_globals = globals;
+ Py_INCREF(op->func_globals);
+ Py_XINCREF(code);
+ op->func_code = code;
+ op->defaults_pyobjects = 0;
+ op->defaults = NULL;
+ op->defaults_tuple = NULL;
+ op->defaults_kwdict = NULL;
+ op->defaults_getter = NULL;
+ op->func_annotations = NULL;
+ PyObject_GC_Track(op);
+ return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+ Py_CLEAR(m->func_closure);
+ Py_CLEAR(m->func.m_module);
+ Py_CLEAR(m->func_dict);
+ Py_CLEAR(m->func_name);
+ Py_CLEAR(m->func_qualname);
+ Py_CLEAR(m->func_doc);
+ Py_CLEAR(m->func_globals);
+ Py_CLEAR(m->func_code);
+ Py_CLEAR(m->func_classobj);
+ Py_CLEAR(m->defaults_tuple);
+ Py_CLEAR(m->defaults_kwdict);
+ Py_CLEAR(m->func_annotations);
+ if (m->defaults) {
+ PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+ int i;
+ for (i = 0; i < m->defaults_pyobjects; i++)
+ Py_XDECREF(pydefaults[i]);
+ PyObject_Free(m->defaults);
+ m->defaults = NULL;
+ }
+ return 0;
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+ PyObject_GC_UnTrack(m);
+ if (__Pyx_CyFunction_weakreflist(m) != NULL)
+ PyObject_ClearWeakRefs((PyObject *) m);
+ __Pyx_CyFunction_clear(m);
+ PyObject_GC_Del(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+ Py_VISIT(m->func_closure);
+ Py_VISIT(m->func.m_module);
+ Py_VISIT(m->func_dict);
+ Py_VISIT(m->func_name);
+ Py_VISIT(m->func_qualname);
+ Py_VISIT(m->func_doc);
+ Py_VISIT(m->func_globals);
+ Py_VISIT(m->func_code);
+ Py_VISIT(m->func_classobj);
+ Py_VISIT(m->defaults_tuple);
+ Py_VISIT(m->defaults_kwdict);
+ if (m->defaults) {
+ PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+ int i;
+ for (i = 0; i < m->defaults_pyobjects; i++)
+ Py_VISIT(pydefaults[i]);
+ }
+ return 0;
+}
+static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
+{
+ __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+ if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
+ Py_INCREF(func);
+ return func;
+ }
+ if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
+ if (type == NULL)
+ type = (PyObject *)(Py_TYPE(obj));
+ return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type)));
+ }
+ if (obj == Py_None)
+ obj = NULL;
+ return __Pyx_PyMethod_New(func, obj, type);
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+ return PyUnicode_FromFormat("<cyfunction %U at %p>",
+ op->func_qualname, (void *)op);
+#else
+ return PyString_FromFormat("<cyfunction %s at %p>",
+ PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+ PyCFunctionObject* f = (PyCFunctionObject*)func;
+ PyCFunction meth = f->m_ml->ml_meth;
+ Py_ssize_t size;
+ switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+ case METH_VARARGS:
+ if (likely(kw == NULL || PyDict_Size(kw) == 0))
+ return (*meth)(self, arg);
+ break;
+ case METH_VARARGS | METH_KEYWORDS:
+ return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
+ case METH_NOARGS:
+ if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+ size = PyTuple_GET_SIZE(arg);
+ if (likely(size == 0))
+ return (*meth)(self, NULL);
+ PyErr_Format(PyExc_TypeError,
+ "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+ f->m_ml->ml_name, size);
+ return NULL;
+ }
+ break;
+ case METH_O:
+ if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+ size = PyTuple_GET_SIZE(arg);
+ if (likely(size == 1)) {
+ PyObject *result, *arg0 = PySequence_ITEM(arg, 0);
+ if (unlikely(!arg0)) return NULL;
+ result = (*meth)(self, arg0);
+ Py_DECREF(arg0);
+ return result;
+ }
+ PyErr_Format(PyExc_TypeError,
+ "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+ f->m_ml->ml_name, size);
+ return NULL;
+ }
+ break;
+ default:
+ PyErr_SetString(PyExc_SystemError, "Bad call flags in "
+ "__Pyx_CyFunction_Call. METH_OLDARGS is no "
+ "longer supported!");
+ return NULL;
+ }
+ PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+ f->m_ml->ml_name);
+ return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+ return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw);
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+ PyObject *result;
+ __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+ if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+ Py_ssize_t argc;
+ PyObject *new_args;
+ PyObject *self;
+ argc = PyTuple_GET_SIZE(args);
+ new_args = PyTuple_GetSlice(args, 1, argc);
+ if (unlikely(!new_args))
+ return NULL;
+ self = PyTuple_GetItem(args, 0);
+ if (unlikely(!self)) {
+ Py_DECREF(new_args);
+ return NULL;
+ }
+ result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+ Py_DECREF(new_args);
+ } else {
+ result = __Pyx_CyFunction_Call(func, args, kw);
+ }
+ return result;
+}
+static PyTypeObject __pyx_CyFunctionType_type = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "cython_function_or_method",
+ sizeof(__pyx_CyFunctionObject),
+ 0,
+ (destructor) __Pyx_CyFunction_dealloc,
+ 0,
+ 0,
+ 0,
+#if PY_MAJOR_VERSION < 3
+ 0,
+#else
+ 0,
+#endif
+ (reprfunc) __Pyx_CyFunction_repr,
+ 0,
+ 0,
+ 0,
+ 0,
+ __Pyx_CyFunction_CallAsMethod,
+ 0,
+ 0,
+ 0,
+ 0,
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
+ 0,
+ (traverseproc) __Pyx_CyFunction_traverse,
+ (inquiry) __Pyx_CyFunction_clear,
+ 0,
+#if PY_VERSION_HEX < 0x030500A0
+ offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+ offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+ 0,
+ 0,
+ __pyx_CyFunction_methods,
+ __pyx_CyFunction_members,
+ __pyx_CyFunction_getsets,
+ 0,
+ 0,
+ __Pyx_CyFunction_descr_get,
+ 0,
+ offsetof(__pyx_CyFunctionObject, func_dict),
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+#if PY_VERSION_HEX >= 0x030400a1
+ 0,
+#endif
+};
+static int __pyx_CyFunction_init(void) {
+ __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+ if (__pyx_CyFunctionType == NULL) {
+ return -1;
+ }
+ return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+ __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+ m->defaults = PyObject_Malloc(size);
+ if (!m->defaults)
+ return PyErr_NoMemory();
+ memset(m->defaults, 0, size);
+ m->defaults_pyobjects = pyobjects;
+ return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+ __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+ m->defaults_tuple = tuple;
+ Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+ __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+ m->defaults_kwdict = dict;
+ Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+ __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+ m->func_annotations = dict;
+ Py_INCREF(dict);
+}
+
+/* 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;
+ 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(
+ PyThreadState_GET(), /*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_uint64_t(uint64_t value) {
+ const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(uint64_t) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(uint64_t) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(uint64_t) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(uint64_t),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+ const int neg_one = (int) -1, const_zero = (int) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(int) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(int) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(int) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(int),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value) {
+ const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(int64_t) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(int64_t) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(int64_t) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(int64_t),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) {
+ const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(uint32_t) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(uint32_t) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(uint32_t) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(uint32_t),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) {
+ const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(int32_t) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(int32_t) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(int32_t) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(int32_t),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__fst_3a__3a_script_3a__3a_ArcSortType(enum fst::script::ArcSortType value) {
+ const enum fst::script::ArcSortType neg_one = (enum fst::script::ArcSortType) -1, const_zero = (enum fst::script::ArcSortType) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(enum fst::script::ArcSortType) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(enum fst::script::ArcSortType) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(enum fst::script::ArcSortType) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(enum fst::script::ArcSortType) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(enum fst::script::ArcSortType) <= 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(enum fst::script::ArcSortType),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__fst_3a__3a_script_3a__3a_MapType(enum fst::script::MapType value) {
+ const enum fst::script::MapType neg_one = (enum fst::script::MapType) -1, const_zero = (enum fst::script::MapType) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(enum fst::script::MapType) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(enum fst::script::MapType) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(enum fst::script::MapType) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(enum fst::script::MapType) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(enum fst::script::MapType) <= 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(enum fst::script::MapType),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+ const int neg_one = (int) -1, const_zero = (int) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(int) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (int) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+ case 2:
+ if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+ return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+ return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+ return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (int) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(int) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+ return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+ return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+ return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+ return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+ return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+ return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(int) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ int val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (int) -1;
+ }
+ } else {
+ int val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (int) -1;
+ val = __Pyx_PyInt_As_int(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to int");
+ return (int) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to int");
+ return (int) -1;
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
+ const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(size_t) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (size_t) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (size_t) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+ case 2:
+ if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+ return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+ return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+ return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (size_t) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(size_t) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (size_t) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+ return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+ return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+ return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+ return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+ return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+ return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(size_t) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ size_t val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (size_t) -1;
+ }
+ } else {
+ size_t val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (size_t) -1;
+ val = __Pyx_PyInt_As_size_t(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to size_t");
+ return (size_t) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to size_t");
+ return (size_t) -1;
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *x) {
+ const int64_t neg_one = (int64_t) -1, const_zero = (int64_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(int64_t) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(int64_t, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (int64_t) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int64_t) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, digits[0])
+ case 2:
+ if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) >= 2 * PyLong_SHIFT) {
+ return (int64_t) (((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) >= 3 * PyLong_SHIFT) {
+ return (int64_t) (((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) >= 4 * PyLong_SHIFT) {
+ return (int64_t) (((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (int64_t) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(int64_t) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int64_t) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(int64_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(int64_t) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) {
+ return (int64_t) (((int64_t)-1)*(((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(int64_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) {
+ return (int64_t) ((((((int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(int64_t) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) {
+ return (int64_t) (((int64_t)-1)*(((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int64_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) {
+ return (int64_t) ((((((((int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(int64_t) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) - 1 > 4 * PyLong_SHIFT) {
+ return (int64_t) (((int64_t)-1)*(((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int64_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int64_t) - 1 > 4 * PyLong_SHIFT) {
+ return (int64_t) ((((((((((int64_t)digits[3]) << PyLong_SHIFT) | (int64_t)digits[2]) << PyLong_SHIFT) | (int64_t)digits[1]) << PyLong_SHIFT) | (int64_t)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(int64_t) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int64_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int64_t) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ int64_t val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (int64_t) -1;
+ }
+ } else {
+ int64_t val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (int64_t) -1;
+ val = __Pyx_PyInt_As_int64_t(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to int64_t");
+ return (int64_t) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to int64_t");
+ return (int64_t) -1;
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) {
+ const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(uint64_t) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (uint64_t) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (uint64_t) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, digits[0])
+ case 2:
+ if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) >= 2 * PyLong_SHIFT) {
+ return (uint64_t) (((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) >= 3 * PyLong_SHIFT) {
+ return (uint64_t) (((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) >= 4 * PyLong_SHIFT) {
+ return (uint64_t) (((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (uint64_t) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(uint64_t) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (uint64_t) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(uint64_t) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
+ return (uint64_t) (((uint64_t)-1)*(((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
+ return (uint64_t) ((((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
+ return (uint64_t) (((uint64_t)-1)*(((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
+ return (uint64_t) ((((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) {
+ return (uint64_t) (((uint64_t)-1)*(((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) {
+ return (uint64_t) ((((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(uint64_t) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint64_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ uint64_t val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (uint64_t) -1;
+ }
+ } else {
+ uint64_t val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (uint64_t) -1;
+ val = __Pyx_PyInt_As_uint64_t(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to uint64_t");
+ return (uint64_t) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to uint64_t");
+ return (uint64_t) -1;
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *x) {
+ const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(int32_t) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(int32_t, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (int32_t) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int32_t) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, digits[0])
+ case 2:
+ if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) >= 2 * PyLong_SHIFT) {
+ return (int32_t) (((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) >= 3 * PyLong_SHIFT) {
+ return (int32_t) (((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) >= 4 * PyLong_SHIFT) {
+ return (int32_t) (((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (int32_t) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(int32_t) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int32_t) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(int32_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(int32_t) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) {
+ return (int32_t) (((int32_t)-1)*(((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) {
+ return (int32_t) ((((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) {
+ return (int32_t) (((int32_t)-1)*(((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) {
+ return (int32_t) ((((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) {
+ return (int32_t) (((int32_t)-1)*(((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int32_t) - 1 > 4 * PyLong_SHIFT) {
+ return (int32_t) ((((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(int32_t) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int32_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int32_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ int32_t val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (int32_t) -1;
+ }
+ } else {
+ int32_t val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (int32_t) -1;
+ val = __Pyx_PyInt_As_int32_t(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to int32_t");
+ return (int32_t) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to int32_t");
+ return (int32_t) -1;
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) {
+ const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(uint32_t) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (uint32_t) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (uint32_t) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, digits[0])
+ case 2:
+ if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT) {
+ return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT) {
+ return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) >= 4 * PyLong_SHIFT) {
+ return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (uint32_t) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(uint32_t) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (uint32_t) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(uint32_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(uint32_t) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) {
+ return (uint32_t) (((uint32_t)-1)*(((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(uint32_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) {
+ return (uint32_t) ((((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) {
+ return (uint32_t) (((uint32_t)-1)*(((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(uint32_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) {
+ return (uint32_t) ((((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT) {
+ return (uint32_t) (((uint32_t)-1)*(((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(uint32_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT) {
+ return (uint32_t) ((((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(uint32_t) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint32_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ uint32_t val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (uint32_t) -1;
+ }
+ } else {
+ uint32_t val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (uint32_t) -1;
+ val = __Pyx_PyInt_As_uint32_t(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to uint32_t");
+ return (uint32_t) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to uint32_t");
+ return (uint32_t) -1;
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) {
+ const time_t neg_one = (time_t) -1, const_zero = (time_t) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(time_t) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(time_t, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (time_t) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (time_t) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, digits[0])
+ case 2:
+ if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) >= 2 * PyLong_SHIFT) {
+ return (time_t) (((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) >= 3 * PyLong_SHIFT) {
+ return (time_t) (((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) >= 4 * PyLong_SHIFT) {
+ return (time_t) (((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (time_t) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(time_t) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(time_t) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (time_t) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(time_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(time_t) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) {
+ return (time_t) (((time_t)-1)*(((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) {
+ return (time_t) ((((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) {
+ return (time_t) (((time_t)-1)*(((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) {
+ return (time_t) ((((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) {
+ return (time_t) (((time_t)-1)*(((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) {
+ return (time_t) ((((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(time_t) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(time_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(time_t) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(time_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ time_t val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (time_t) -1;
+ }
+ } else {
+ time_t val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (time_t) -1;
+ val = __Pyx_PyInt_As_time_t(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to time_t");
+ return (time_t) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to time_t");
+ return (time_t) -1;
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+ const long neg_one = (long) -1, const_zero = (long) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(long) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(long) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+ }
+ } else {
+ if (sizeof(long) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(long),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+ const long neg_one = (long) -1, const_zero = (long) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(long) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (long) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (long) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+ case 2:
+ if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+ return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+ return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+ return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (long) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(long) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (long) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+ return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+ return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+ return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+ return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+ return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+ return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(long) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+ } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ long val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (long) -1;
+ }
+ } else {
+ long val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (long) -1;
+ val = __Pyx_PyInt_As_long(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to long");
+ return (long) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to long");
+ return (long) -1;
+}
+
+/* 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;
+ ++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 char* __Pyx_PyObject_AsString(PyObject* o) {
+ Py_ssize_t ignore;
+ return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if CYTHON_COMPILING_IN_CPYTHON && (__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)) {
+#if PY_VERSION_HEX < 0x03030000
+ 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
+ if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+ if (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
+ } 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 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 (PyInt_Check(x) || PyLong_Check(x))
+#else
+ if (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 = PyNumber_Int(x);
+ }
+ else if (m && m->nb_long) {
+ name = "long";
+ res = PyNumber_Long(x);
+ }
+ #else
+ if (m && m->nb_int) {
+ name = "int";
+ res = PyNumber_Long(x);
+ }
+ #endif
+#else
+ res = PyNumber_Int(x);
+#endif
+ if (res) {
+#if PY_MAJOR_VERSION < 3
+ if (!PyInt_Check(res) && !PyLong_Check(res)) {
+#else
+ if (!PyLong_Check(res)) {
+#endif
+ PyErr_Format(PyExc_TypeError,
+ "__%.4s__ returned non-%.4s (type %.200s)",
+ name, name, Py_TYPE(res)->tp_name);
+ Py_DECREF(res);
+ return NULL;
+ }
+ }
+ else if (!PyErr_Occurred()) {
+ PyErr_SetString(PyExc_TypeError,
+ "an integer is required");
+ }
+ return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+ Py_ssize_t ival;
+ PyObject *x;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_CheckExact(b))) {
+ if (sizeof(Py_ssize_t) >= sizeof(long))
+ return PyInt_AS_LONG(b);
+ else
+ return PyInt_AsSsize_t(x);
+ }
+#endif
+ if (likely(PyLong_CheckExact(b))) {
+ #if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)b)->ob_digit;
+ const Py_ssize_t size = Py_SIZE(b);
+ if (likely(__Pyx_sst_abs(size) <= 1)) {
+ ival = likely(size) ? digits[0] : 0;
+ if (size == -1) ival = -ival;
+ return ival;
+ } else {
+ switch (size) {
+ case 2:
+ if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+ return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ break;
+ case -2:
+ if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+ return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ break;
+ case 3:
+ if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+ return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ break;
+ case -3:
+ if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+ return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ break;
+ case 4:
+ if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+ return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ break;
+ case -4:
+ if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+ return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+ }
+ break;
+ }
+ }
+ #endif
+ return PyLong_AsSsize_t(b);
+ }
+ x = PyNumber_Index(b);
+ if (!x) return -1;
+ ival = PyInt_AsSsize_t(x);
+ Py_DECREF(x);
+ return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+ return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
--- /dev/null
+# See www.openfst.org for extensive documentation on this weighted
+# finite-state transducer library.
+
+
+from libc.time cimport time
+from libc.time cimport time_t
+
+from libcpp cimport bool
+from libcpp.memory cimport shared_ptr
+from libcpp.memory cimport unique_ptr
+from libcpp.utility cimport pair
+from libcpp.vector cimport vector
+
+from basictypes cimport int32
+from basictypes cimport int64
+from basictypes cimport uint32
+from basictypes cimport uint64
+cimport fst as fst
+from ios cimport stringstream
+from libcpp.string cimport string
+
+
+# Exportable helper functions
+
+
+cdef string tostring(data, encoding=?) except *
+
+cdef string weighttostring(data, encoding=?) except *
+
+cdef fst.ComposeFilter _get_compose_filter(const string &cf) except *
+
+cdef fst.DeterminizeType _get_determinize_type(const string &dt) except *
+
+cdef fst.QueueType _get_queue_type(const string &qt) except *
+
+cdef fst.RandArcSelection _get_rand_arc_selection(const string &ras) except *
+
+cdef fst.ReplaceLabelType _get_replace_label_type(const string &rlt,
+ bool epsilon_on_replace) except *
+
+
+# Weight.
+
+
+cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type,
+ weight_string) except *
+
+cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type,
+ weight_string) except *
+
+
+cdef class Weight(object):
+
+ cdef unique_ptr[fst.WeightClass] _weight
+
+ cdef void _check_weight(self) except *
+
+ cpdef Weight copy(self)
+
+ cpdef string to_string(self)
+
+ cpdef string type(self)
+
+
+cdef Weight _Weight_Zero(weight_type)
+
+cdef Weight _Weight_One(weight_type)
+
+cdef Weight _Weight_NoWeight(weight_type)
+
+cdef Weight _plus(Weight lhs, Weight rhs)
+
+cdef Weight _times(Weight lhs, Weight rhs)
+
+cdef Weight _divide(Weight lhs, Weight rhs)
+
+cdef Weight _power(Weight lhs, size_t n)
+
+
+# SymbolTable.
+
+ctypedef fst.SymbolTable * SymbolTable_ptr
+
+
+cdef class _SymbolTable(object):
+
+ cdef fst.SymbolTable *_table
+
+ cpdef int64 available_key(self)
+
+ cpdef string checksum(self)
+
+ cpdef SymbolTable copy(self)
+
+ cpdef int64 get_nth_key(self, ssize_t pos) except *
+
+ cpdef string labeled_checksum(self)
+
+ cpdef bool member(self, key)
+
+ cpdef string name(self)
+
+ cpdef size_t num_symbols(self)
+
+ cpdef void write(self, filename) except *
+
+ cpdef void write_text(self, filename) except *
+
+
+cdef class _EncodeMapperSymbolTable(_SymbolTable):
+
+ cdef shared_ptr[fst.EncodeMapperClass] _encoder
+
+
+cdef class _FstSymbolTable(_SymbolTable):
+
+ cdef shared_ptr[fst.FstClass] _fst
+
+
+cdef class _MutableSymbolTable(_SymbolTable):
+
+ cpdef int64 add_symbol(self, symbol, int64 key=?)
+
+ cpdef void add_table(self, _SymbolTable syms)
+
+ cpdef void set_name(self, new_name) except *
+
+
+cdef class _MutableFstSymbolTable(_MutableSymbolTable):
+
+ cdef shared_ptr[fst.MutableFstClass] _mfst
+
+
+cdef class SymbolTable(_MutableSymbolTable):
+
+ cdef unique_ptr[fst.SymbolTable] _smart_table
+
+
+cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable(
+ fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder)
+
+
+cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table,
+ shared_ptr[fst.FstClass] ifst)
+
+
+cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table,
+ shared_ptr[fst.MutableFstClass] ifst)
+
+
+cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table)
+
+
+
+cdef class SymbolTableIterator(object):
+
+ cdef shared_ptr[fst.SymbolTable] _table
+ cdef unique_ptr[fst.SymbolTableIterator] _siter
+
+ cpdef bool done(self)
+
+ cpdef void next(self)
+
+ cpdef void reset(self)
+
+ cpdef string symbol(self)
+
+ cpdef int64 value(self)
+
+
+# EncodeMapper.
+
+
+cdef class EncodeMapper(object):
+
+ cdef shared_ptr[fst.EncodeMapperClass] _encoder
+
+ cpdef string arc_type(self)
+
+ cpdef uint32 flags(self)
+
+ cpdef _EncodeMapperSymbolTable input_symbols(self)
+
+ cpdef _EncodeMapperSymbolTable output_symbols(self)
+
+ cpdef uint64 properties(self, uint64 mask)
+
+ cpdef void set_input_symbols(self, _SymbolTable syms) except *
+
+ cpdef void set_output_symbols(self, _SymbolTable syms) except *
+
+ cpdef string weight_type(self)
+
+
+# Fst.
+
+
+ctypedef fst.FstClass * FstClass_ptr
+ctypedef fst.MutableFstClass * MutableFstClass_ptr
+ctypedef fst.VectorFstClass * VectorFstClass_ptr
+
+
+cdef class _Fst(object):
+
+ cdef shared_ptr[fst.FstClass] _fst
+
+ cpdef string arc_type(self)
+
+ cpdef ArcIterator arcs(self, int64 state)
+
+ cpdef _Fst copy(self)
+
+ cpdef void draw(self, filename, _SymbolTable isymbols=?,
+ _SymbolTable osymbols=?, SymbolTable ssymbols=?,
+ bool acceptor=?, title=?, double width=?,
+ double height=?, bool portrait=?, bool vertical=?,
+ double ranksep=?, double nodesep=?, int32 fontsize=?,
+ int32 precision=?, bool show_weight_one=?)
+
+ cpdef Weight final(self, int64 state)
+
+ cpdef string fst_type(self)
+
+ cpdef _FstSymbolTable input_symbols(self)
+
+ cpdef size_t num_arcs(self, int64 state) except *
+
+ cpdef size_t num_input_epsilons(self, int64 state) except *
+
+ cpdef size_t num_output_epsilons(self, int64 state) except *
+
+ cpdef _FstSymbolTable output_symbols(self)
+
+ cpdef uint64 properties(self, uint64 mask, bool test)
+
+ cpdef int64 start(self)
+
+ cpdef StateIterator states(self)
+
+ cpdef string text(self, _SymbolTable isymbols=?, _SymbolTable osymbols=?,
+ _SymbolTable ssymbols=?, bool acceptor=?,
+ bool show_weight_one=?, missing_sym=?)
+
+ cpdef bool verify(self)
+
+ cpdef string weight_type(self)
+
+ cpdef void write(self, filename) except *
+
+ cpdef string WriteToString(self)
+
+
+cdef class _MutableFst(_Fst):
+
+ cdef shared_ptr[fst.MutableFstClass] _mfst
+
+ cdef void _check_mutating_imethod(self) except *
+
+ cdef void _add_arc(self, int64 state, Arc arc) except *
+
+ cpdef int64 add_state(self) except *
+
+ cdef void _arcsort(self, st=?) except *
+
+ cdef void _closure(self, bool closure_plus=?) except *
+
+ cdef void _concat(self, _Fst ifst) except *
+
+ cdef void _connect(self) except *
+
+ cdef void _decode(self, EncodeMapper) except *
+
+ cdef void _delete_arcs(self, int64 state, size_t n=?) except *
+
+ cdef void _delete_states(self, states=?) except *
+
+ cdef void _encode(self, EncodeMapper) except *
+
+ cdef void _invert(self) except *
+
+ cdef void _minimize(self, float delta=?, bool allow_nondet=?) except *
+
+ cpdef MutableArcIterator mutable_arcs(self, int64 state)
+
+ cpdef int64 num_states(self)
+
+ cdef void _project(self, bool project_output=?) except *
+
+ cdef void _prune(self, float delta=?, int64 nstate=?, weight=?) except *
+
+ cdef void _push(self, float delta=?, bool remove_total_weight=?,
+ bool to_final=?) except *
+
+ cdef void _relabel_pairs(self, ipairs=?, opairs=?) except *
+
+ cdef void _relabel_tables(self, _SymbolTable old_isymbols=?,
+ _SymbolTable new_isymbols=?, bool attach_new_isymbols=?,
+ _SymbolTable old_osymbols=?, _SymbolTable new_osymbols=?,
+ bool attach_new_osymbols=?) except *
+
+ cdef void _reserve_arcs(self, int64 state, size_t n) except *
+
+ cdef void _reserve_states(self, int64 n) except *
+
+ cdef void _reweight(self, potentials, bool to_final=?) except *
+
+ cdef void _rmepsilon(self, bool connect=?, float delta=?, int64 nstate=?,
+ weight=?) except *
+
+ cdef void _set_final(self, int64 state, weight=?) except *
+
+ cdef void _set_properties(self, uint64 props, uint64 mask) except *
+
+ cdef void _set_start(self, int64 state) except *
+
+ cdef void _set_input_symbols(self, _SymbolTable syms) except *
+
+ cdef void _set_output_symbols(self, _SymbolTable syms) except *
+
+ cdef void _topsort(self) except *
+
+ cdef void _union(self, _Fst ifst) except *
+
+
+# Fst construction helpers.
+
+
+cdef _Fst _init_Fst(FstClass_ptr tfst)
+
+cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst)
+
+cdef _Fst _init_XFst(FstClass_ptr tfst)
+
+cdef _MutableFst _create_Fst(arc_type=?)
+
+cdef _Fst _read_Fst(filename, fst_type=?)
+
+cdef _Fst _deserialize_Fst(fst_string, fst_type=?)
+
+
+# Iterators.
+
+
+cdef class Arc(object):
+
+ cdef unique_ptr[fst.ArcClass] _arc
+
+ cpdef Arc copy(self)
+
+
+cdef Arc _init_Arc(const fst.ArcClass &arc)
+
+
+cdef class ArcIterator(object):
+
+ cdef shared_ptr[fst.FstClass] _fst
+ cdef unique_ptr[fst.ArcIteratorClass] _aiter
+
+ cpdef bool done(self)
+
+ cpdef uint32 flags(self)
+
+ cpdef void next(self)
+
+ cpdef size_t position(self)
+
+ cpdef void reset(self)
+
+ cpdef void seek(self, size_t a)
+
+ cpdef void set_flags(self, uint32 flags, uint32 mask)
+
+ cpdef object value(self)
+
+
+cdef class MutableArcIterator(object):
+
+ cdef shared_ptr[fst.MutableFstClass] _mfst
+ cdef unique_ptr[fst.MutableArcIteratorClass] _aiter
+
+ cpdef bool done(self)
+
+ cpdef uint32 flags(self)
+
+ cpdef void next(self)
+
+ cpdef size_t position(self)
+
+ cpdef void reset(self)
+
+ cpdef void seek(self, size_t a)
+
+ cpdef void set_flags(self, uint32 flags, uint32 mask)
+
+ cpdef void set_value(self, Arc arc)
+
+ cpdef object value(self)
+
+
+cdef class StateIterator(object):
+
+ cdef shared_ptr[fst.FstClass] _fst
+ cdef unique_ptr[fst.StateIteratorClass] _siter
+
+ cpdef bool done(self)
+
+ cpdef void next(self)
+
+ cpdef void reset(self)
+
+ cpdef int64 value(self)
+
+
+# Constructive operations on Fst.
+
+
+cdef _Fst _map(_Fst ifst, float delta=?, mt=?, weight=?)
+
+cpdef _Fst arcmap(_Fst ifst, float delta=?, mt=?, weight=?)
+
+cpdef _MutableFst compose(_Fst ifst1, _Fst ifst2, cf=?, bool connect=?)
+
+cpdef _Fst convert(_Fst ifst, fst_type=?)
+
+cpdef _MutableFst determinize(_Fst ifst, float delta=?, dt=?,
+ int64 nstate=?, int64 subsequential_label=?,
+ weight=?, bool increment_subsequential_label=?)
+
+cpdef _MutableFst difference(_Fst ifst1, _Fst ifst2, cf=?, 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, cf=?, bool connect=?)
+
+cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=?)
+
+cpdef _MutableFst prune(_Fst ifst, float delta=?, int64 nstate=?,
+ weight=?)
+
+cpdef _MutableFst push(_Fst ifst, float delta=?, bool push_weights=?,
+ bool push_labels=?, bool remove_common_affix=?,
+ bool remove_total_weight=?, bool to_final=?)
+
+cpdef bool randequivalent(_Fst ifst1, _Fst ifst2, int32 npath=?,
+ float delta=?, time_t seed=?, select=?,
+ int32 max_length=?) except *
+
+cpdef _MutableFst randgen(_Fst ifst, int32 npath=?, time_t seed=?,
+ select=?, int32 max_length=?,
+ bool remove_total_weight=?, bool weighted=?)
+
+cdef fst.ReplaceLabelType _get_replace_label_type(string rlt,
+ bool epsilon_on_replace) except *
+
+cpdef _MutableFst replace(pairs, call_arc_labeling=?,
+ return_arc_labeling=?, bool epsilon_on_replace=?,
+ int64 return_label=?)
+
+cpdef _MutableFst reverse(_Fst ifst, bool require_superinitial=?)
+
+cpdef _MutableFst rmepsilon(_Fst ifst, bool connect=?, float delta=?,
+ int64 nstate=?, qt=?, bool reverse=?,
+ weight=?)
+
+cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst, float delta=?,
+ int64 nstate=?, qt=?,
+ bool reverse=?) except *
+
+cpdef _MutableFst shortestpath(_Fst ifst, float delta=?, int32 nshortest=?,
+ int64 nstate=?, qt=?, bool unique=?,
+ weight=?)
+
+cpdef _Fst statemap(_Fst ifst, mt)
+
+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)
--- /dev/null
+#cython: nonecheck=True
+# See www.openfst.org for extensive documentation on this weighted
+# finite-state transducer library.
+
+
+"""Python interface to the FST scripting API.
+
+Operations which construct new FSTs are implemented as traditional functions, as
+are two-argument boolean functions like `equal` and `equivalent`. Destructive
+operations---those that mutate an FST, in place---are instance methods, as is
+`write`. Operator overloading is not used. The following example, based on
+Mohri et al. 2002, shows the construction of an ASR system given a pronunciation
+lexicon L, grammar G, a transducer from context-dependent phones to
+context-independent phones C, and an HMM set H:
+
+ L = fst.Fst.read("L.fst")
+ G = fst.Fst.read("G.fst")
+ C = fst.Fst.read("C.fst")
+ H = fst.Fst.read("H.fst")
+ LG = fst.determinize(fst.compose(L, G))
+ CLG = fst.determinize(fst.compose(C, LG))
+ HCLG = fst.determinize(fst.compose(H, CLG))
+ HCLG.minimize() # NB: works in-place.
+
+Python variables here use snake_case and constants are in all caps, minus the
+normal `k` prefix.
+"""
+
+# Overview of the file:
+#
+# * Imports
+# * Custom exceptions
+# * General helpers
+# * Weight and helpers
+# * _SymbolTable, _EncodeMapperSymbolTable, _FstSymbolTable,
+# _MutableFstSymbolTable, SymbolTable, and helpers
+# * SymbolTableIterator
+# * EncodeMapper
+# * _Fst, _MutableFst, Fst, and helpers
+# * FST properties
+# * Arc, ArcIterator, and MutableArcIterator
+# * StateIterator
+# * FST operations
+# * Compiler
+# * FarReader and FarWriter
+# * Cleanup operations for module entrance and exit.
+#
+# TODO(kbg): Try breaking this apart into smaller pieces.
+#
+# A few of the more idiosyncratic choices made here are due to "impedance
+# mismatches" between C++ and Python, as follows.
+#
+# Another issue is that due to differences in C++ and Python scope rules, most
+# C++ class instances have to be heap-allocated. Since all are packed into
+# Python class instances, Python destructors are used to semi-automatically
+# free C++ instances. The one exception are the various `...Options` structs.
+# All that is included here are the constructors; there is no need to include
+# the names of the struct members. Cython does not draw any meaningful
+# distinction between structs and C++ classes, so these look just like class
+# definitions.
+#
+# Cython's type annotations (e.g., `string`) are used when the variables will
+# be sent as arguments to C++ functions, but are not used for variables used
+# within the module.
+#
+# Internal functions which may raise a Python error do not have a C++ return
+# type simply because this leads the C++ compiler to think that the resulting
+# value could be used before it is populated.
+
+
+## Imports.
+
+# C imports.
+from libc.stdint cimport INT32_MAX
+from libc.stdint cimport SIZE_MAX
+from posix.unistd cimport getpid
+
+# C++ imports.
+from libcpp cimport bool
+from libcpp.cast cimport const_cast
+from libcpp.cast cimport static_cast
+
+# Our C++ imports.
+from ios cimport ofstream
+from memory cimport static_pointer_cast
+
+# Cython operator workarounds.
+from cython.operator cimport address as addr # &foo
+from cython.operator cimport dereference as deref # *foo
+from cython.operator cimport preincrement as inc # ++foo
+
+# Python imports.
+import atexit
+import numbers
+import subprocess
+import logging
+
+
+## Custom exceptions.
+
+
+class FstError(Exception):
+
+ pass
+
+
+class FstArgError(FstError, ValueError):
+
+ pass
+
+
+class FstBadWeightError(FstError, ValueError):
+
+ pass
+
+
+class FstDeletedConstructorError(FstError, RuntimeError):
+
+ pass
+
+
+class FstIndexError(FstError, IndexError):
+
+ pass
+
+
+class FstIOError(FstError, IOError):
+
+ pass
+
+
+class FstOpError(FstError, RuntimeError):
+
+ pass
+
+
+class FstUnknownWeightTypeError(FstError, ValueError):
+
+ pass
+
+
+## General helpers.
+
+
+cdef string tostring(data, encoding="utf8") except *:
+ """Converts strings to bytestrings.
+
+ This function converts Python bytestrings and Unicode strings to bytestrings
+ encoded in UTF-8. It is used to process most Python string arguments before
+ passing them to the lower-level library.
+
+ Args:
+ data: A Unicode string or bytestring.
+ encoding: The desired encoding, defaulting to UTF-8.
+
+ Returns:
+ A bytestring.
+
+ Raises:
+ FstArgError: Cannot encode string.
+ UnicodeEncodeError.
+
+ This function is not visible to Python users.
+ """
+ # A Python bytestring can be implicitly cast to a C++ string.
+ if isinstance(data, bytes):
+ return data
+ elif isinstance(data, unicode):
+ return data.encode(encoding)
+ raise FstArgError("Cannot encode as string: {!r}".format(data))
+
+
+cdef string weighttostring(data, encoding="utf8") except *:
+ """Converts strings or numerics to bytestrings.
+
+ This function converts Python bytestrings, Unicode strings, and numerics
+ which can be cast to floats to bytestrings encoded in UTF-8. It is used to
+ process Python string arguments so they can be used to construct Weight
+ objects. In most cases, weights are underlyingly floating-point, but since
+ not all weights are, they can only be constructed using a string.
+
+ Args:
+ data: A Unicode string, bytestring, or type which can be converted to a
+ Python float.
+
+ Returns:
+ A bytestring.
+
+ Raise:
+ FstArgError: Cannot encode string.
+ ValueError: Invalid literal for float.
+ UnicodeEncodeError.
+
+ This function is not visible to Python users.
+ """
+ # A Python bytestring can be implicitly cast to a C++ string.
+ if isinstance(data, bytes):
+ return data
+ elif isinstance(data, unicode):
+ return data.encode(encoding)
+ elif isinstance(data, numbers.Number):
+ return str(data).encode(encoding)
+ raise FstArgError("Cannot encode as string: {!r}".format(data))
+
+
+cdef fst.ComposeFilter _get_compose_filter(const string &cf) 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:
+ cf: A string matching a known composition filter; one of: "alt_sequence",
+ "auto", "match", "null", "sequence", "trivial".
+
+ Returns:
+ A ComposeFilter enum value.
+
+ Raises:
+ FstArgError: Unknown compose filter type.
+
+ This function is not visible to Python users.
+ """
+ cdef fst.ComposeFilter compose_filter
+ if not fst.GetComposeFilter(cf, addr(compose_filter)):
+ raise FstArgError("Unknown compose filter type: {!r}".format(cf))
+ return compose_filter
+
+
+cdef fst.DeterminizeType _get_determinize_type(const string &dt) except *:
+ """Matches string with the appropriate DeterminizeType enum value.
+
+ Args:
+ dt: 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 determinize_type
+ if not fst.GetDeterminizeType(dt, addr(determinize_type)):
+ raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ return determinize_type
+
+
+cdef fst.QueueType _get_queue_type(const string &qt) 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:
+ qt: 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(qt, addr(queue_type)):
+ raise FstArgError("Unknown queue type: {!r}".format(qt))
+ return queue_type
+
+
+cdef fst.RandArcSelection _get_rand_arc_selection(const string &ras) 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:
+ ras: 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 rand_arc_selection
+ if not fst.GetRandArcSelection(ras, addr(rand_arc_selection)):
+ raise FstArgError("Unknown random arc selection type: {!r}".format(ras))
+ return rand_arc_selection
+
+
+cdef fst.ReplaceLabelType _get_replace_label_type(const string &rlt,
+ 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:
+ rlt: 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(rlt, epsilon_on_replace,
+ addr(replace_label_type)):
+ raise FstArgError("Unknown replace label type: {!r}".format(rlt))
+ return replace_label_type
+
+
+## Weight and helpers.
+
+
+cdef class Weight(object):
+
+ """
+ Weight(weight_type, weight_string)
+
+ FST weight class.
+
+ This class represents an FST weight. When passed as an argument to an FST
+ operation, it should have the weight type of the input FST(s) to said
+ operation.
+
+ Args:
+ weight_type: A string indicating the weight type.
+ weight_string: A string indicating the underlying weight.
+
+ Raises:
+ FstBadWeightError: invalid weight.
+ FstUnknownWeightTypeError: weight type not found.
+ """
+
+ def __repr__(self):
+ return "<{} Weight {} at 0x{:x}>".format(self.type(), self.to_string(),
+ id(self))
+
+ def __str__(self):
+ return self.to_string()
+
+ # This attempts to convert the string form into a float, raising
+ # ValueError when that is not appropriate.
+
+ def __float__(self):
+ return float(self.to_string())
+
+ def __init__(self, weight_type, weight):
+ self._weight.reset(new fst.WeightClass(tostring(weight_type),
+ weighttostring(weight)))
+ self._check_weight()
+
+ cdef void _check_weight(self) except *:
+ if self.type() == b"none":
+ raise FstUnknownWeightTypeError(self.type())
+ if self.to_string() == b"BadNumber":
+ raise FstBadWeightError(self.to_string())
+
+ cpdef Weight copy(self):
+ """
+ copy(self)
+
+ Returns a copy of the Weight.
+ """
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new
+ fst.WeightClass(<fst.WeightClass> deref(self._weight)))
+ return result
+
+ # To get around the inability to declare cdef class methods, we define
+ # the C part out-of-class and then call it from within.
+
+ @classmethod
+ def Zero(cls, weight_type):
+ """
+ Weight.Zero(weight_type)
+ """
+ return _Weight_Zero(weight_type)
+
+ @classmethod
+ def One(cls, weight_type):
+ """
+ Weight.One(weight_type)
+ """
+ return _Weight_One(weight_type)
+
+ @classmethod
+ def NoWeight(cls, weight_type):
+ """
+ Weight.NoWeight(weight_type)
+ """
+ return _Weight_NoWeight(weight_type)
+
+ def __richcmp__(Weight x, Weight y, int op):
+ # This is useful for unit tests.
+ if op == 2: # `==`
+ return (x.type() == y.type() and x.to_string() == y.to_string())
+ elif op == 3: # `!=`
+ return not (x == y)
+ else:
+ raise NotImplementedError("Invalid operator {!r}".format(op))
+
+ cpdef string to_string(self):
+ return self._weight.get().ToString()
+
+ cpdef string type(self):
+ return self._weight.get().Type()
+
+
+cdef Weight _plus(Weight lhs, Weight rhs):
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new fst.WeightClass(fst.Plus(deref(lhs._weight),
+ deref(rhs._weight))))
+ return result
+
+
+def plus(Weight lhs, Weight rhs):
+ """
+ plus(lhs, rhs)
+
+ Computes the sum of two Weights in the same semiring.
+
+ This function computes lhs \oplus rhs, raising an exception if lhs and rhs
+ are not in the same semiring.
+
+ Args:
+ lhs: left-hand side Weight.
+ rhs: right-hand side Weight.
+
+ Returns:
+ A Weight object.
+
+ Raises:
+ FstBadWeightError: invalid weight.
+ FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ """
+ cdef Weight result = _plus(lhs, rhs)
+ result._check_weight()
+ return result
+
+
+cdef Weight _times(Weight lhs, Weight rhs):
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new fst.WeightClass(fst.Times(deref(lhs._weight),
+ deref(rhs._weight))))
+ return result
+
+
+def times(Weight lhs, Weight rhs):
+ """
+ times(lhs, rhs)
+
+ Computes the product of two Weights in the same semiring.
+
+ This function computes lhs \otimes rhs, raising an exception if lhs and rhs
+ are not in the same semiring.
+
+ Args:
+ lhs: left-hand side Weight.
+ rhs: right-hand side Weight.
+
+ Returns:
+ A Weight object.
+
+ Raises:
+ FstBadWeightError: invalid weight.
+ FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ """
+ cdef Weight result = _times(lhs, rhs)
+ result._check_weight()
+ return result
+
+
+cdef Weight _divide(Weight lhs, Weight rhs):
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new fst.WeightClass(fst.Divide(deref(lhs._weight),
+ deref(rhs._weight))))
+ return result
+
+
+def divide(Weight lhs, Weight rhs):
+ """
+ divide(lhs, rhs)
+
+ Computes the quotient of two Weights in the same semiring.
+
+ This function computes lhs \oslash rhs, raising an exception if lhs and rhs
+ are not in the same semiring. As there is no way to specify whether to use
+ left vs. right division, this assumes a commutative semiring in which these
+ are equivalent operations.
+
+ Args:
+ lhs: left-hand side Weight.
+ rhs: right-hand side Weight.
+
+ Returns:
+ A Weight object.
+
+ Raises:
+ FstBadWeightError: invalid weight.
+ FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ """
+ cdef Weight result = _divide(lhs, rhs)
+ result._check_weight()
+ return result
+
+
+cdef Weight _power(Weight w, size_t n):
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new fst.WeightClass(fst.Power(deref(w._weight), n)))
+ return result
+
+
+def power(Weight w, size_t n):
+ """
+ times(lhs, rhs)
+
+ Computes the iterated product of a weight.
+
+ Args:
+ w: The weight.
+ n: The power.
+
+ Returns:
+ A Weight object.
+
+ Raises:
+ FstBadWeightError: invalid weight.
+ FstUnknownWeightTypeError: weights are null or not in the same semiring.
+ """
+ cdef Weight result = _power(w, n)
+ result._check_weight()
+ return result
+
+
+cdef fst.WeightClass _get_WeightClass_or_Zero(const string &weight_type,
+ weight) except *:
+ """Converts weight string to a WeightClass.
+
+ This function constructs a WeightClass instance of the desired weight type.
+ If the first argument is null, the weight is set to semiring Zero.
+
+ Args:
+ weight_type: A string denoting the desired weight type.
+ weight: A object indicating the desired weight; if omitted, the weight is
+ set to semiring Zero.
+
+ Returns:
+ A WeightClass object.
+
+ This function is not visible to Python users.
+ """
+ cdef fst.WeightClass result
+ if weight is None:
+ result = fst.WeightClass.Zero(weight_type)
+ elif isinstance(weight, Weight):
+ result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ else:
+ result = fst.WeightClass(weight_type, weighttostring(weight))
+ if result.ToString() == b"BadNumber":
+ raise FstBadWeightError(weighttostring(weight))
+ return result
+
+
+cdef fst.WeightClass _get_WeightClass_or_One(const string &weight_type,
+ weight) except *:
+ """Converts weight string to a WeightClass.
+
+ This function constructs a WeightClass instance of the desired weight type.
+ If the first argument is null, the weight is set to semiring One.
+
+ Args:
+ weight_type: A string denoting the desired weight type.
+ weight: A object indicating the desired weight; if omitted, the weight is
+ set to semiring One.
+
+ Returns:
+ A WeightClass object.
+
+ This function is not visible to Python users.
+ """
+ cdef fst.WeightClass result
+ if weight is None:
+ result = fst.WeightClass.One(weight_type)
+ elif isinstance(weight, Weight):
+ result = deref(<fst.WeightClass *> (<Weight> weight)._weight.get())
+ else:
+ result = fst.WeightClass(weight_type, weighttostring(weight))
+ if result.ToString() == b"BadNumber":
+ raise FstBadWeightError(weighttostring(weight))
+ return result
+
+
+cdef Weight _Weight_Zero(weight_type):
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new fst.WeightClass(fst.WeightClass.Zero(
+ tostring(weight_type))))
+ if result._weight.get().Type() == b"none":
+ raise FstUnknownWeightTypeError(weight_type)
+ return result
+
+
+cdef Weight _Weight_One(weight_type):
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new fst.WeightClass(
+ fst.WeightClass.One(tostring(weight_type))))
+ if result._weight.get().Type() == b"none":
+ raise FstUnknownWeightTypeError(weight_type)
+ return result
+
+
+cdef Weight _Weight_NoWeight(weight_type):
+ cdef Weight result = Weight.__new__(Weight)
+ result._weight.reset(new fst.WeightClass(
+ fst.WeightClass.NoWeight(tostring(weight_type))))
+ return result
+
+
+## _SymbolTable, _MutableSymbolTable, _EncodeMapperSymbolTable, _FstSymbolTable,
+## _MutableFstSymbolTable, SymbolTable, and helpers.
+#
+# SymbolTable hierarchy:
+#
+# _SymbolTable: abstract base class; has-a SymbolTable*
+# _EncodeMapperSymbolTable(_SymbolTable): constant symbol table returned by
+# EncodeMapper.input_symbols/output_symbols
+# _FstSymbolTable(_SymbolTable): constant symbol table returned by
+# _Fst.input_symbols/output_symbols
+#
+# _MutableSymbolTable(_SymbolTable): abstract base class adding mutation methods
+# _MutableFstSymbolTable(_MutableSymbolTable): mutable symbol table returned by
+# _MutableFst.mutable_input_symbols/mutable_output_symbols
+# SymbolTable(_MutableSymbolTable): adds constructor
+
+
+cdef class _SymbolTable(object):
+
+ """
+ (No constructor.)
+
+ Base class for the symbol table hierarchy.
+
+ This class is the base class for SymbolTable. It has a "deleted" constructor
+ and implementations for the const methods of the wrapped SymbolTable.
+ """
+
+ # NB: Do not expose any non-const methods of the wrapped SymbolTable here.
+ # Doing so will allow undefined behavior.
+
+ def __init__(self):
+ raise FstDeletedConstructorError(
+ "Cannot construct {}".format(self.__class__.__name__))
+
+ def __iter__(self):
+ return SymbolTableIterator(self)
+
+ cpdef int64 available_key(self):
+ return self._table.AvailableKey()
+
+ cpdef string checksum(self):
+ return self._table.CheckSum()
+
+ cpdef SymbolTable copy(self):
+ """
+ copy(self)
+
+ Returns a mutable copy of the SymbolTable.
+ """
+ return _init_SymbolTable(self._table.Copy())
+
+ def find(self, key):
+ """
+ find(self, key)
+
+ Given a symbol or index, finds the other one.
+
+ This method returns the index associated with a symbol key, or the symbol
+ associated with a index key.
+
+ Args:
+ key: Either a string or an index.
+
+ Returns:
+ If key is a string, the associated index; if key is an integer, the
+ associated symbol.
+
+ Raises:
+ KeyError: Key not found.
+ """
+ try:
+ result = self._table.FindIndex(tostring(key))
+ if result == -1:
+ raise KeyError(key)
+ except FstArgError:
+ result = self._table.FindSymbol(key)
+ if result == b"":
+ raise KeyError(key)
+ return result
+
+ cpdef bool member(self, key):
+ """
+ member(self, key)
+
+ Given a symbol or index, returns whether it is found in the table.
+
+ This method returns a boolean indicating whether the given symbol or index
+ is present in the table. If one intends to perform subsequent lookup, it is
+ much better to simply call the find method, catching the KeyError.
+
+ Args:
+ key: Either a string or an index.
+
+ Returns:
+ Whether or not the key is present (as a string or a index) in the table.
+ """
+ try:
+ return self._table.MemberSymbol(tostring(key))
+ except FstArgError:
+ return self._table.MemberIndex(key)
+
+ def __contains__(self, key):
+ return self.member(key)
+
+ cpdef 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.
+
+ Raises:
+ KeyError: index not found.
+ """
+ cdef int64 result = self._table.GetNthKey(pos)
+ if result == -1:
+ raise KeyError(pos)
+ return result
+
+ cpdef string labeled_checksum(self):
+ return self._table.LabeledCheckSum()
+
+ cpdef string name(self):
+ return self._table.Name()
+
+ cpdef size_t num_symbols(self):
+ return self._table.NumSymbols()
+
+ cpdef void write(self, filename) except *:
+ """
+ write(self, filename)
+
+ Serializes symbol table to a file.
+
+ This methods writes the SymbolTable to a file in binary format.
+
+ Args:
+ filename: The string location of the output file.
+
+ Raises:
+ FstIOError: Write failed.
+ """
+ if not self._table.Write(tostring(filename)):
+ raise FstIOError("Write failed: {!r}".format(filename))
+
+ cpdef void write_text(self, filename) except *:
+ """
+ write_text(self, filename)
+
+ Writes symbol table to text file.
+
+ This method writes the SymbolTable to a file in human-readable format.
+
+ Args:
+ filename: The string location of the output file.
+
+ Raises:
+ FstIOError: Write failed.
+ """
+ if not self._table.WriteText(tostring(filename)):
+ raise FstIOError("Write failed: {!r}".format(filename))
+
+
+cdef class _EncodeMapperSymbolTable(_SymbolTable):
+
+ """
+ (No constructor.)
+
+ Immutable SymbolTable class for tables stored in an EncodeMapper.
+
+ This class wraps a library const SymbolTable and exposes const methods of the
+ wrapped object. It is only to be returned by method, never constructed
+ directly.
+ """
+
+ # NB: Do not expose any non-const methods of the wrapped SymbolTable here.
+ # Doing so will allow undefined behavior.
+
+ def __repr__(self):
+ return "<const EncodeMapper SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ id(self))
+
+
+cdef class _FstSymbolTable(_SymbolTable):
+
+ """
+ (No constructor.)
+
+ Mutable SymbolTable class for tables stored in a mutable FST.
+
+ This class wraps a library SymbolTable and exposes methods of the wrapped
+ object. It is only to be returned by method, never constructed directly.
+ """
+
+ # NB: Do not expose any non-const methods of the wrapped SymbolTable here.
+ # Doing so will allow undefined behavior.
+
+ def __repr__(self):
+ return "<const Fst SymbolTable {!r} at 0x{:x}>".format(self.name(),
+ id(self))
+
+
+cdef class _MutableSymbolTable(_SymbolTable):
+
+ """
+ (No constructor.)
+
+ Base class for mutable symbol tables.
+
+ This class is the base class for a mutable SymbolTable. It has a "deleted"
+ constructor and implementations of all methods of the wrapped SymbolTable.
+ """
+
+ cpdef int64 add_symbol(self, symbol, int64 key=-1):
+ """
+ add_symbol(self, symbol, key=-1)
+
+ 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 (-1 is reserved for "no symbol requested").
+
+ Returns:
+ The integer key of the new symbol.
+ """
+ cdef symbol_string = tostring(symbol)
+ if key != -1:
+ return self._table.AddSymbol(symbol_string, key)
+ else:
+ return self._table.AddSymbol(symbol_string)
+
+ cpdef void add_table(self, _SymbolTable syms):
+ """
+ add_table(self, syms)
+
+ Adds another SymbolTable to this table.
+
+ This method merges another symbol table into the current table. All key
+ values will be offset by the current available key.
+
+ Args:
+ syms: A SymbolTable to be merged with the current table.
+ """
+ self._table.AddTable(deref(syms._table))
+
+ cpdef void set_name(self, new_name) except *:
+ self._table.SetName(tostring(new_name))
+
+
+cdef class _MutableFstSymbolTable(_MutableSymbolTable):
+ """
+ (No constructor.)
+
+ Mutable SymbolTable assigned to an FST.
+
+ Attributes:
+ available_key: An integer indicating the next available key index in the
+ table.
+ checksum: A string indicating the label-agnostic MD5 checksum for the table.
+ labeled_checksum: A string indicating the label-dependent MD5 checksum for
+ the table.
+ name: A string indicating the table's name.
+ num_symbols: An integer indicating the number of symbols in the table.
+ """
+
+ def __repr__(self):
+ return "<Fst SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+
+
+cdef class SymbolTable(_MutableSymbolTable):
+
+ """
+ SymbolTable(name="<unspecified>")
+
+ 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: A string indicating the table's name
+
+ Attributes:
+ available_key: An integer indicating the next available key index in the
+ table.
+ checksum: A string indicating the label-agnostic MD5 checksum for the table.
+ labeled_checksum: A string indicating the label-dependent MD5 checksum for
+ the table.
+ name: A string indicating the table's name.
+ num_symbols: An integer indicating the number of symbols in the table.
+ """
+
+ def __repr__(self):
+ return "<SymbolTable {!r} at 0x{:x}>".format(self.name(), id(self))
+
+ def __init__(self, name=b"<unspecified>"):
+ self._table = new fst.SymbolTable(tostring(name))
+ self._smart_table.reset(self._table)
+
+ @classmethod
+ def read(cls, filename):
+ """
+ SymbolTable.read(filename)
+
+ Reads symbol table from binary file.
+
+ This class method creates a new SymbolTable from a symbol table binary file.
+
+ Args:
+ filename: The string location of the input binary file.
+
+ Returns:
+ A new SymbolTable instance.
+
+ See also: `SymbolTable.read_fst`, `SymbolTable.read_text`.
+ """
+ cdef fst.SymbolTable *tsyms = fst.SymbolTable.Read(tostring(filename))
+ if tsyms == NULL:
+ raise FstIOError("Read failed: {!r}".format(filename))
+ return _init_SymbolTable(tsyms)
+
+ @classmethod
+ def read_text(cls, filename, bool allow_negative_labels=False):
+ """
+ SymbolTable.read_text(filename)
+
+ Reads symbol table from text file.
+
+ This class method creates a new SymbolTable from a symbol table text file.
+
+ Args:
+ filename: The string location of the input text file.
+ allow_negative_labels: Should negative labels be allowed? (Not
+ recommended; may cause conflicts).
+
+ Returns:
+ A new SymbolTable instance.
+
+ See also: `SymbolTable.read`, `SymbolTable.read_fst`.
+ """
+ cdef unique_ptr[fst.SymbolTableTextOptions] opts
+ opts.reset(new fst.SymbolTableTextOptions(allow_negative_labels))
+ cdef fst.SymbolTable *tsyms = fst.SymbolTable.ReadText(tostring(filename),
+ deref(opts))
+ if tsyms == NULL:
+ raise FstIOError("Read failed: {!r}".format(filename))
+ return _init_SymbolTable(tsyms)
+
+ @classmethod
+ def read_fst(cls, filename, bool input_table):
+ """
+ SymbolTable.read_fst(filename, input_table)
+
+ Reads symbol table from an FST file without loading the corresponding FST.
+
+ This class method creates a new SymbolTable by reading either the input or
+ output symbol table from an FST file, without loading the corresponding FST.
+
+ Args:
+ filename: The string location of the input FST file.
+ input_table: Should the input table be read (True) or the output table
+ (False)?
+
+ Returns:
+ A new SymbolTable instance, or None if none can be read.
+
+ Raises:
+ FstIOError: Read failed.
+
+ See also: `SymbolTable.read`, `SymbolTable.read_text`.
+ """
+ cdef fst.SymbolTable *tsyms = fst.FstReadSymbols(filename, input_table)
+ if tsyms == NULL:
+ raise FstIOError("Read failed: {!r}".format(filename))
+ return _init_SymbolTable(tsyms)
+
+
+cdef _EncodeMapperSymbolTable _init_EncodeMapperSymbolTable(
+ fst.SymbolTable *table, shared_ptr[fst.EncodeMapperClass] encoder):
+ cdef _EncodeMapperSymbolTable result = (
+ _EncodeMapperSymbolTable.__new__(_EncodeMapperSymbolTable))
+ result._table = table
+ result._encoder = encoder
+ return result
+
+cdef _FstSymbolTable _init_FstSymbolTable(fst.SymbolTable *table,
+ shared_ptr[fst.FstClass] ifst):
+ cdef _FstSymbolTable result = _FstSymbolTable.__new__(_FstSymbolTable)
+ result._table = table
+ result._fst = ifst
+ return result
+
+
+cdef _MutableFstSymbolTable _init_MutableFstSymbolTable(fst.SymbolTable *table,
+ shared_ptr[fst.MutableFstClass] ifst):
+ cdef _MutableFstSymbolTable result = (
+ _MutableFstSymbolTable.__new__(_MutableFstSymbolTable))
+ result._table = table
+ result._mfst = ifst
+ return result
+
+
+cdef SymbolTable _init_SymbolTable(fst.SymbolTable *table):
+ cdef SymbolTable result = SymbolTable.__new__(SymbolTable)
+ result._table = table
+ return result
+
+
+# Constructive SymbolTable operations.
+
+
+cpdef SymbolTable compact_symbol_table(_SymbolTable syms):
+ """
+ compact_symbol_table(syms)
+
+ Constructively relabels a SymbolTable to make it a contiguous mapping.
+
+ Args:
+ syms: Input SymbolTable.
+
+ Returns:
+ A new compacted SymbolTable.
+ """
+ return _init_SymbolTable(fst.CompactSymbolTable(deref(syms._table)))
+
+
+cpdef SymbolTable merge_symbol_table(_SymbolTable lhs, _SymbolTable rhs):
+ """
+ merge_symbol_table(lhs, rhs)
+
+ Merges all symbols from the left table into the right.
+
+ This function creates a new SymbolTable which is the merger of the two input
+ symbol Tables. Symbols in the right-hand table that conflict with those in the
+ left-hand table will be assigned values from the left-hand table. Thus the
+ returned table will never modify symbol assignments from the left-hand side,
+ but may do so on the right.
+
+ If the left-hand table is associated with an FST, it may be necessary to
+ relabel it using the output table.
+
+ Args:
+ lhs: Left-hand side SymbolTable.
+ rhs: Left-hand side SymbolTable.
+
+ Returns:
+ A new merged SymbolTable.
+
+ See also: `relabel_symbols`.
+ """
+ return _init_SymbolTable(fst.MergeSymbolTable(deref(lhs._table),
+ deref(rhs._table), NULL))
+
+
+## SymbolTableIterator.
+
+
+cdef class SymbolTableIterator(object):
+
+ """
+ SymbolTableIterator(syms)
+
+ This class is used for iterating over a symbol table using a Pythonic API. It
+ also supports the C++ API methods, but most users should simply place a
+ SymbolTable in an iteration context and take advantage of the Pythonic API
+ that provides.
+ """
+
+ def __repr__(self):
+ return "<SymbolTableIterator at 0x{:x}>".format(id(self))
+
+ def __init__(self, _SymbolTable syms):
+ self._siter.reset(new fst.SymbolTableIterator(deref(syms._table)))
+
+ # This just registers this class as a possible iterator.
+ def __iter__(self):
+ return self
+
+ # Magic method used to get a Pythonic API out of the C++ API.
+ def __next__(self):
+ if self.done():
+ raise StopIteration
+ cdef int64 value = self.value()
+ cdef string symbol = self.symbol()
+ self.next()
+ return (value, symbol)
+
+ cpdef bool done(self):
+ """
+ done(self)
+
+ Indicates whether the iterator is exhausted or not.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ True if the iterator is exhausted, False otherwise.
+ """
+ return self._siter.get().Done()
+
+ cpdef void next(self):
+ """
+ next(self)
+
+ Advances the iterator.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._siter.get().Next()
+
+ cpdef void reset(self):
+ """
+ reset(self)
+
+ Resets the iterator to the initial position.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._siter.get().Reset()
+
+ cpdef string symbol(self):
+ """
+ symbol(self)
+
+ Returns the current symbol string.
+
+ This method returns the current symbol string at this point in the table.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ A symbol string.
+ """
+ return self._siter.get().Symbol()
+
+ cpdef int64 value(self):
+ """
+ value(self)
+
+ Returns the current integer index of the symbol.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ An integer index.
+ """
+ return self._siter.get().Value()
+
+
+## EncodeMapper.
+
+
+cdef class EncodeMapper(object):
+
+ """
+ EncodeMapper(arc_type="standard", encode_labels=False, encode_weights=False)
+
+ Arc encoder class, wrapping EncodeMapperClass.
+
+ This class provides an object which can be used to encode or decode FST arcs.
+ This is most useful to convert an FST to an unweighted acceptor, on which
+ some FST operations are more efficient, and then decoding the FST afterwards.
+
+ To use an instance of this class to encode or decode a mutable FST, pass it
+ as the first argument to the FST instance methods `encode` and `decode`.
+
+ For implementational reasons, it is not currently possible to use an encoder
+ on disk to construct this class.
+
+ Args:
+ arc_type: A string indicating the arc type.
+ encode_labels: Should labels be encoded?
+ encode_weights: Should weights be encoded?
+ """
+
+ def __repr__(self):
+ return "<EncodeMapper at 0x{:x}>".format(id(self))
+
+ def __init__(self,
+ arc_type=b"standard",
+ bool encode_labels=False,
+ bool encode_weights=False):
+ cdef uint32 flags = fst.GetEncodeFlags(encode_labels, encode_weights)
+ self._encoder.reset(new fst.EncodeMapperClass(tostring(arc_type), flags,
+ fst.ENCODE))
+ if not self._encoder:
+ raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+
+ cpdef string arc_type(self):
+ return self._encoder.get().ArcType()
+
+ # Python's equivalent to operator().
+
+ def __call__(self, Arc arc):
+ """
+ self(state, ilabel, olabel, weight, nextstate)
+
+ Uses the encoder to encode an arc.
+
+ Args:
+ ilabel: The integer index of the input label.
+ olabel: The integer index of the output label.
+ weight: A Weight or weight string indicating the desired final weight; if
+ null, it is set to semiring One.
+ nextstate: The integer index of the destination state.
+
+ Raises:
+ FstOpError: Incompatible or invalid weight.
+ """
+ return _init_Arc(self._encoder.get().__call__(deref(arc._arc)))
+
+ cpdef uint32 flags(self):
+ return self._encoder.get().Flags()
+
+ cpdef _EncodeMapperSymbolTable input_symbols(self):
+ if self._encoder.get().InputSymbols() == NULL:
+ return
+ return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ self._encoder.get().InputSymbols()), self._encoder)
+
+ cpdef _EncodeMapperSymbolTable output_symbols(self):
+ if self._encoder.get().OutputSymbols() == NULL:
+ return
+ return _init_EncodeMapperSymbolTable(const_cast[SymbolTable_ptr](
+ self._encoder.get().OutputSymbols()), self._encoder)
+
+ cpdef uint64 properties(self, uint64 mask):
+ """
+ properties(self, mask)
+
+ Provides property bits.
+
+ This method provides user access to the properties attributes for the
+ encoder. 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 encoder's properties.
+
+ Returns:
+ A 64-bit bitmask representing the requested properties.
+ """
+ return self._encoder.get().Properties(mask)
+
+ cpdef void set_input_symbols(self, _SymbolTable syms) except *:
+ """
+ set_input_symbols(self, syms)
+
+ Sets the input symbol table.
+
+ Args:
+ syms: A SymbolTable.
+
+ See also: `set_output_symbols`.
+ """
+ self._encoder.get().SetInputSymbols(syms._table)
+
+ cpdef void set_output_symbols(self, _SymbolTable syms) except *:
+ """
+ set_output_symbols(self, syms)
+
+ Sets the output symbol table.
+
+ Args:
+ syms: A SymbolTable.
+
+ See also: `set_input_symbols`.
+ """
+ self._encoder.get().SetOutputSymbols(syms._table)
+
+ cpdef string weight_type(self):
+ return self._encoder.get().WeightType()
+
+
+## _Fst, _MutableFst, Fst, and helpers.
+#
+# Fst hierarchy:
+#
+# _Fst: base class; has-a FstClass*.
+# _MutableFst(_Fst): adds mutable methods.
+# Fst(filename): pseudo-constructor.
+
+
+cdef class _Fst(object):
+
+ """
+ (No constructor.)
+
+ Immutable FST class, wrapping FstClass.
+
+ This class is the basic user-facing FST object. It does not itself support any
+ mutation operations.
+ """
+
+ # IPython notebook magic to produce an SVG of the FST.
+ def _repr_svg_(self):
+ """IPython notebook magic to produce an SVG of the FST using GraphViz.
+
+ This method produces an SVG of the internal graph. Users wishing to create
+ publication-quality graphs should instead use the method `draw`, which
+ exposes additional parameters.
+
+ Raises:
+ OSError: Cannot locate the `dot` executable.
+ subprocess.CalledProcessError: `dot` returned non-zero exit code.
+
+ See also: `draw`, `text`.
+ """
+ # Throws OSError if the dot executable is not found.
+ proc = subprocess.Popen(["dot", "-Tsvg"], stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ cdef stringstream sstrm
+ fst.DrawFst(deref(self._fst), self._fst.get().InputSymbols(),
+ self._fst.get().OutputSymbols(), NULL,
+ self._fst.get().Properties(fst.kAcceptor, True) ==
+ fst.kAcceptor,
+ b"", 8.5, 11, True, False, 0.4, 0.25, 14, 5, False,
+ addr(sstrm), b"_repr_svg")
+ (sout, serr) = proc.communicate(sstrm.str())
+ if proc.returncode != 0: # Just to be explicit.
+ raise subprocess.CalledProcessError(proc.returncode, self._DOT_TSVG)
+ return sout.decode("utf8")
+
+ def __repr__(self):
+ return "<{} Fst at 0x{:x}>".format(self.fst_type(), id(self))
+
+ def __init__(self):
+ raise FstDeletedConstructorError(
+ "Cannot construct {}".format(self.__class__.__name__))
+
+ # Other magic methods.
+
+ def __str__(self):
+ return self.text(acceptor=self._fst.get().Properties(fst.kAcceptor, True) ==
+ fst.kAcceptor,
+ show_weight_one=self._fst.get().Properties(fst.kWeighted, True) ==
+ fst.kWeighted)
+
+ cpdef string arc_type(self):
+ return self._fst.get().ArcType()
+
+ cpdef ArcIterator arcs(self, int64 state):
+ """
+ arcs(self, state)
+
+ Returns an iterator over arcs leaving some state=.
+
+ Args:
+ s: The source state ID.
+
+ Returns:
+ An ArcIterator over arcs leaving state `state`.
+
+ See also: `mutable_arcs`, `states`.
+ """
+ return ArcIterator(self, state)
+
+ cpdef _Fst copy(self):
+ """
+ copy(self)
+
+ Makes a copy of the FST.
+ """
+ return _init_XFst(new fst.FstClass(deref(self._fst)))
+
+ cpdef void draw(self,
+ filename,
+ _SymbolTable isymbols=None,
+ _SymbolTable osymbols=None,
+ SymbolTable ssymbols=None,
+ bool acceptor=False,
+ title=b"",
+ double width=8.5,
+ double height=11,
+ bool portrait=False,
+ bool vertical=False,
+ double ranksep=0.4,
+ double nodesep=0.25,
+ int32 fontsize=14,
+ int32 precision=5,
+ bool show_weight_one=False):
+ """
+ draw(self, filename, isymbols=None, osymbols=None, ssymbols=None,
+ acceptor=False, title="", width=8.5, height=11, portrait=False,
+ vertical=False, ranksep=0.4, nodesep=0.25, fontsize=14,
+ precision=5, show_weight_one=False):
+
+ Writes out the FST in Graphviz text format.
+
+ This method writes out the FST in the dot graph description language. The
+ graph can be rendered using the `dot` executable provided by Graphviz.
+
+ Args:
+ filename: The string location of the output dot/Graphviz file.
+ isymbols: An optional symbol table used to label input symbols.
+ osymbols: An optional symbol table used to label output symbols.
+ ssymbols: An optional symbol table used to label states.
+ acceptor: Should the figure be rendered in acceptor format if possible?
+ title: An optional string indicating the figure title.
+ width: The figure width, in inches.
+ height: The figure height, in inches.
+ portrait: Should the figure be rendered in portrait rather than
+ landscape?
+ vertical: Should the figure be rendered bottom-to-top rather than
+ left-to-right?
+ ranksep: The minimum separation separation between ranks, in inches.
+ nodesep: The minimum separation between nodes, in inches.
+ fontsize: Font size, in points.
+ precision: Numeric precision for floats, in number of chars.
+ show_weight_one: Should weights equivalent to semiring One be printed?
+
+ For more information about the rendering options, see `man dot`.
+
+ See also: `text`.
+ """
+ cdef string filename_string = tostring(filename)
+ cdef unique_ptr[ofstream] ostrm
+ ostrm.reset(new ofstream(filename_string.c_str()))
+ cdef fst.SymbolTable *ssymbols_ptr = NULL
+ if ssymbols is not None:
+ ssymbols_ptr = ssymbols._table
+ fst.DrawFst(deref(self._fst),
+ self._fst.get().InputSymbols() if isymbols is None
+ else isymbols._table,
+ self._fst.get().OutputSymbols() if osymbols is None
+ else osymbols._table,
+ ssymbols_ptr, acceptor, tostring(title), width, height, portrait,
+ vertical, ranksep, nodesep, fontsize, precision, show_weight_one,
+ ostrm.get(), filename_string)
+
+ cpdef Weight final(self, int64 state):
+ """
+ final(self, state)
+
+ Returns the final weight of a state.
+
+ Args:
+ state: The integer index of a state.
+
+ Returns:
+ The final Weight of that state.
+
+ Raises:
+ FstIndexError: State index out of range.
+ """
+ cdef Weight weight = Weight.__new__(Weight)
+ weight._weight.reset(new fst.WeightClass(self._fst.get().Final(state)))
+ return weight
+
+ cpdef string fst_type(self):
+ return self._fst.get().FstType()
+
+ cpdef _FstSymbolTable input_symbols(self):
+ if self._fst.get().InputSymbols() == NULL:
+ return
+ return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ self._fst.get().InputSymbols()), self._fst)
+
+ cpdef size_t num_arcs(self, int64 state) except *:
+ """
+ num_arcs(self, state)
+
+ Returns the number of arcs leaving a state.
+
+ Args:
+ state: The integer index of a state.
+
+ Returns:
+ The number of arcs leaving that state.
+
+ Raises:
+ FstIndexError: State index out of range.
+
+ See also: `num_states`.
+ """
+ cdef size_t result = self._fst.get().NumArcs(state)
+ if result == SIZE_MAX:
+ raise FstIndexError("State index out of range")
+ return result
+
+ cpdef size_t num_input_epsilons(self, int64 state) except *:
+ """
+ num_input_epsilsons(self, state)
+
+ Returns the number of arcs with epsilon input labels leaving a state.
+
+ Args:
+ state: The integer index of a state.
+
+ Returns:
+ The number of epsilon-input-labeled arcs leaving that state.
+
+ Raises:
+ FstIndexError: State index out of range.
+
+ See also: `num_output_epsilons`.
+ """
+ cdef size_t result = self._fst.get().NumInputEpsilons(state)
+ if result == SIZE_MAX:
+ raise FstIndexError("State index out of range")
+ return result
+
+ cpdef size_t num_output_epsilons(self, int64 state) except *:
+ """
+ num_output_epsilsons(self, state)
+
+ Returns the number of arcs with epsilon output labels leaving a state.
+
+ Args:
+ state: The integer index of a state.
+
+ Returns:
+ The number of epsilon-output-labeled arcs leaving that state.
+
+ Raises:
+ FstIndexError: State index out of range.
+
+ See also: `num_input_epsilons`.
+ """
+ cdef size_t result = self._fst.get().NumOutputEpsilons(state)
+ if result == SIZE_MAX:
+ raise FstIndexError("State index out of range")
+ return result
+
+ cpdef _FstSymbolTable output_symbols(self):
+ if self._fst.get().OutputSymbols() == NULL:
+ return
+ return _init_FstSymbolTable(const_cast[SymbolTable_ptr](
+ self._fst.get().OutputSymbols()), self._fst)
+
+ cpdef uint64 properties(self, uint64 mask, bool test):
+ """
+ properties(self, mask, test)
+
+ Provides property bits.
+
+ This method provides user access to the properties attributes for the FST.
+ The resulting value is a long integer, but when it is cast to a boolean,
+ it represents whether or not the FST has the `mask` property.
+
+ Args:
+ mask: The property mask to be compared to the FST's properties.
+ test: Should any unknown values be computed before comparing against
+ the mask?
+
+ Returns:
+ A 64-bit bitmask representing the requested properties.
+ """
+ return self._fst.get().Properties(mask, test)
+
+ cpdef int64 start(self):
+ return self._fst.get().Start()
+
+ cpdef StateIterator states(self):
+ """
+ states(self)
+
+ Returns an iterator over all states in the FST.
+
+ Returns:
+ A StateIterator object for the FST.
+
+ See also: `arcs`, `mutable_arcs`.
+ """
+ return StateIterator(self)
+
+ cpdef string text(self, _SymbolTable isymbols=None,
+ _SymbolTable osymbols=None, _SymbolTable ssymbols=None,
+ bool acceptor=False, bool show_weight_one=False, missing_sym=b""):
+ """
+ text(self, isymbols=None, osymbols=None, ssymbols=None, acceptor=False,
+ show_weight_one=False, missing_sym="")
+
+ Produces a human-readable string representation of the FST.
+
+ This method generates a human-readable string representation of the FST.
+ The caller may optionally specify SymbolTables used to label input labels,
+ output labels, or state labels, respectively.
+
+ Args:
+ isymbols: An optional symbol table used to label input symbols.
+ osymbols: An optional symbol table used to label output symbols.
+ ssymbols: An optional symbol table used to label states.
+ acceptor: Should the FST be rendered in acceptor format if possible?
+ show_weight_one: Should weights equivalent to semiring One be printed?
+ missing_symbol: The string to be printed when symbol table lookup fails.
+
+ Returns:
+ A formatted string representing the machine.
+ """
+ # Prints FST to stringstream, then returns resulting string.
+ cdef fst.SymbolTable *ssymbols_ptr = NULL
+ if ssymbols is not None:
+ ssymbols_ptr = ssymbols._table
+ cdef stringstream sstrm
+ fst.PrintFst(deref(self._fst), sstrm, "<pywrapfst>",
+ self._fst.get().InputSymbols() if isymbols is None
+ else isymbols._table,
+ self._fst.get().OutputSymbols() if osymbols is None
+ else osymbols._table,
+ ssymbols_ptr, acceptor, show_weight_one, tostring(missing_sym))
+ return sstrm.str()
+
+ cpdef bool verify(self):
+ """
+ verify(self)
+
+ Verifies that an FST's contents are sane.
+
+ Returns:
+ True if the contents are sane, False otherwise.
+ """
+ return fst.Verify(deref(self._fst))
+
+ cpdef string weight_type(self):
+ """
+ weight_type(self)
+
+ Provides the FST's weight type.
+
+ Returns:
+ A string representing the weight type.
+ """
+ return self._fst.get().WeightType()
+
+ cpdef void write(self, filename) except *:
+ """
+ write(self, filename)
+
+ Serializes FST to a file.
+
+ This method writes the FST to a file in a binary format.
+
+ Args:
+ filename: The string location of the output file.
+
+ Raises:
+ FstIOError: Write failed.
+ """
+ if not self._fst.get().Write(tostring(filename)):
+ raise FstIOError("Write failed: {!r}".format(filename))
+
+ cpdef string WriteToString(self):
+ return self._fst.get().WriteToString()
+
+
+cdef class _MutableFst(_Fst):
+
+ """
+ (No constructor.)
+
+ Mutable FST class, wrapping MutableFstClass.
+
+ This class extends _Fst by adding mutation operations.
+ """
+
+ cdef void _check_mutating_imethod(self) except *:
+ """Checks whether an operation mutating the FST has produced an error.
+
+ This function is not visible to Python users.
+ """
+ if self._fst.get().Properties(fst.kError, True) == fst.kError:
+ raise FstOpError("Operation failed")
+
+ cdef void _add_arc(self, int64 state, Arc arc) except *:
+ if not self._fst.get().ValidStateId(state):
+ raise FstIndexError("State index out of range")
+ if not self._mfst.get().AddArc(state, deref(arc._arc)):
+ raise FstOpError("Incompatible or invalid weight type")
+ self._check_mutating_imethod()
+
+ def add_arc(self, int64 state, Arc arc):
+ """
+ add_arc(self, state, arc)
+
+ Adds a new arc to the FST and return self.
+
+ Args:
+ state: The integer index of the source state.
+ arc: The arc to add.
+
+ Returns:
+ self.
+
+ Raises:
+ FstIndexError: State index out of range.
+ FstOpdexError: Incompatible or invalid weight type.
+
+ See also: `add_state`.
+ """
+ self._add_arc(state, arc)
+ return self
+
+ cpdef int64 add_state(self) except *:
+ """
+ add_state(self)
+
+ Adds a new state to the FST and returns the state ID.
+
+ Returns:
+ The integer index of the new state.
+
+ See also: `add_arc`, `set_start`, `set_final`.
+ """
+ cdef int64 result = self._mfst.get().AddState()
+ self._check_mutating_imethod()
+ return result
+
+ cdef void _arcsort(self, st=b"ilabel") except *:
+ cdef fst.ArcSortType sort_type
+ if not fst.GetArcSortType(tostring(st), addr(sort_type)):
+ raise FstArgError("Unknown sort type {!r}".format(sort_type))
+ fst.ArcSort(self._mfst.get(), sort_type)
+ self._check_mutating_imethod()
+
+ def arcsort(self, st=b"ilabel"):
+ """
+ arcsort(self, st="ilabel")
+
+ Sorts arcs leaving each state of the FST.
+
+ This operation destructively sorts arcs leaving each state using either
+ input or output labels.
+
+ Args:
+ st: Either "ilabel" (sort arcs according to input labels) or
+ "olabel" (sort arcs according to output labels).
+
+ Returns:
+ self.
+
+ Raises:
+ FstArgError: Unknown sort type.
+
+ See also: `topsort`.
+ """
+ self._arcsort(st)
+ return self
+
+ cdef void _closure(self, bool closure_plus=False) except *:
+ fst.Closure(self._mfst.get(), fst.GetClosureType(closure_plus))
+ self._check_mutating_imethod()
+
+ def closure(self, bool closure_plus=False):
+ """
+ closure(self, closure_plus=False)
+
+ Computes concatenative closure.
+
+ This operation destructively converts the FST to its concatenative closure.
+ If A transduces string x to y with weight a, then the closure transduces x
+ to y with weight a, xx to yy with weight a \otimes a, xxx to yyy with weight
+ a \otimes a \otimes a, and so on. The empty string is also transduced to
+ itself with semiring One if `closure_plus` is False.
+
+ Args:
+ closure_plus: If False, do not accept the empty string.
+
+ Returns:
+ self.
+ """
+ self._closure(closure_plus)
+ return self
+
+ cdef void _concat(self, _Fst ifst) except *:
+ fst.Concat(self._mfst.get(), deref(ifst._fst))
+ self._check_mutating_imethod()
+
+ def concat(self, _Fst ifst):
+ """
+ concat(self, ifst)
+
+ Computes the concatenation (product) of two FSTs.
+
+ This operation destructively concatenates the FST with a second FST. If A
+ transduces string x to y with weight a and B transduces string w to v with
+ weight b, then their concatenation transduces string xw to yv with weight a
+ \otimes b.
+
+ Args:
+ ifst: The second input FST.
+
+ Returns:
+ self.
+ """
+ self._concat(ifst)
+ return self
+
+ cdef void _connect(self) except *:
+ fst.Connect(self._mfst.get())
+ self._check_mutating_imethod()
+
+ def connect(self):
+ """
+ connect(self)
+
+ Removes unsuccessful paths.
+
+ This operation destructively trims the FST, removing states and arcs that
+ are not part of any successful path.
+
+ Returns:
+ self.
+ """
+ self._connect()
+ return self
+
+ cdef void _decode(self, EncodeMapper encoder) except *:
+ fst.Decode(self._mfst.get(), deref(encoder._encoder))
+ self._check_mutating_imethod()
+
+ def decode(self, EncodeMapper encoder):
+ """
+ decode(self, encoder)
+
+ Decodes encoded labels and/or weights.
+
+ This operation reverses the encoding performed by `encode`.
+
+ Args:
+ encoder: An EncodeMapper object used to encode the FST.
+
+ Returns:
+ self.
+
+ See also: `encode`.
+ """
+ self._decode(encoder)
+ return self
+
+ cdef void _delete_arcs(self, int64 state, size_t n=0) except *:
+ if not (self._mfst.get().DeleteArcs(state, n) if n else
+ self._mfst.get().DeleteArcs(state)):
+ raise FstIndexError("State index out of range")
+ self._check_mutating_imethod()
+
+ def delete_arcs(self, int64 state, size_t n=0):
+ """
+ delete_arcs(self, state, n=0)
+
+ Deletes arcs leaving a particular state.
+
+ Args:
+ state: The integer index of a state.
+ n: An optional argument indicating how many arcs to be deleted. If this
+ argument is omitted or passed as zero, all arcs from this state are
+ deleted.
+
+ Returns:
+ self.
+
+ Raises:
+ FstIndexError: State index out of range.
+
+ See also: `delete_states`.
+ """
+ self._delete_arcs(state, n)
+ return self
+
+ cdef void _delete_states(self, states=None) except *:
+ # Only the former signature has a possible indexing failure.
+ if states:
+ if not self._mfst.get().DeleteStates(<const vector[int64]> states):
+ raise FstIndexError("State index out of range")
+ else:
+ self._mfst.get().DeleteStates()
+ self._check_mutating_imethod()
+
+ def delete_states(self, states=None):
+ """
+ delete_states(self, states=None)
+
+ Deletes states.
+
+ Args:
+ states: An optional iterable of integer indices of the states to be
+ deleted. If this argument is omitted, all states are deleted.
+
+ Returns:
+ self.
+
+ Raises:
+ FstIndexError: State index out of range.
+
+ See also: `delete_arcs`.
+ """
+ self._delete_states(states)
+ return self
+
+ cdef void _encode(self, EncodeMapper encoder) except *:
+ fst.Encode(self._mfst.get(), encoder._encoder.get())
+ self._check_mutating_imethod()
+
+ def encode(self, EncodeMapper encoder):
+ """
+ encode(self, encoder)
+
+ Encodes labels and/or weights.
+
+ This operation allows for the representation of a weighted transducer as a
+ weighted acceptor, an unweighted transducer, or an unweighted acceptor by
+ considering the pair (input label, output label), the pair (input label,
+ weight), or the triple (input label, output label, weight) as a single
+ label. Applying this operation mutates the EncodeMapper argument, which
+ can then be used to decode.
+
+ Args:
+ encoder: An EncodeMapper object to be used as the encoder.
+
+ Returns:
+ self.
+
+ See also: `decode`.
+ """
+ self._encode(encoder)
+ return self
+
+ cdef void _invert(self) except *:
+ fst.Invert(self._mfst.get())
+ self._check_mutating_imethod()
+
+ def invert(self):
+ """
+ invert(self)
+
+ Inverts the FST's transduction.
+
+ This operation destructively inverts the FST's transduction by exchanging
+ input and output labels.
+
+ Returns:
+ self.
+ """
+ self._invert()
+ return self
+
+ cdef void _minimize(self, float delta=fst.kDelta,
+ 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.kDelta, bool allow_nondet=False):
+ """
+ minimize(self, delta=0.0009765625, 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)
+ return self
+
+ cpdef MutableArcIterator mutable_arcs(self, int64 state):
+ """
+ mutable_arcs(self, state)
+
+ Returns a iterator over arcs leaving some state which supports
+ arc mutation.
+
+ Args:
+ s: The source state ID.
+
+ Returns:
+ A MutableArcIterator over arcs leaving state `s`.
+
+ See also: `arcs`, `states`.
+ """
+ return MutableArcIterator(self, state)
+
+ def mutable_input_symbols(self):
+ cdef fst.SymbolTable *tst = self._mfst.get().MutableInputSymbols()
+ if tst == NULL:
+ return
+ return _init_MutableFstSymbolTable(tst, self._mfst)
+
+ def mutable_output_symbols(self):
+ cdef fst.SymbolTable *tst = self._mfst.get().MutableOutputSymbols()
+ if tst == NULL:
+ return
+ return _init_MutableFstSymbolTable(tst, self._mfst)
+
+ cpdef int64 num_states(self):
+ return self._mfst.get().NumStates()
+
+ cdef void _project(self, bool project_output=False) except *:
+ fst.Project(self._mfst.get(), fst.GetProjectType(project_output))
+ self._check_mutating_imethod()
+
+ def project(self, bool project_output=False):
+ """
+ project(self, project_output=False)
+
+ Converts the FST to an acceptor using input or output labels.
+
+ This operation destructively projects an FST onto its domain or range by
+ either copying each arc's input label to its output label (the default) or
+ vice versa.
+
+ Args:
+ project_output: Should the output labels be projected?
+
+ Returns:
+ self.
+
+ See also: `decode`, `encode`, `relabel_pairs`, `relabel_symbols`.
+ """
+ self._project(project_output)
+ return self
+
+ cdef void _prune(self, float delta=fst.kDelta, int64 nstate=fst.kNoStateId,
+ weight=None) except *:
+ # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ weight)
+ fst.Prune(self._mfst.get(), wc, nstate, delta)
+ self._check_mutating_imethod()
+
+ def prune(self,
+ float delta=fst.kDelta,
+ int64 nstate=fst.kNoStateId,
+ weight=None):
+ """
+ prune(self, delta=0.0009765625, nstate=-1, weight=None)
+
+ Removes paths with weights below a certain threshold.
+
+ This operation deletes states and arcs in the input FST that do not belong
+ to a successful path whose weight is no more (w.r.t the natural semiring
+ order) than the threshold t \otimes-times the weight of the shortest path in
+ the input FST. Weights must be commutative and have the path property.
+
+ Args:
+ delta: Comparison/quantization delta.
+ nstate: State number threshold.
+ weight: A Weight or weight string indicating the desired weight threshold
+ below which paths are pruned; if omitted, no paths are pruned.
+
+ Returns:
+ self.
+
+ See also: The constructive variant.
+ """
+ self._prune(delta, nstate, weight)
+ return self
+
+ cdef void _push(self,
+ float delta=fst.kDelta,
+ bool remove_total_weight=False,
+ bool to_final=False) except *:
+ fst.Push(self._mfst.get(), fst.GetReweightType(to_final), delta,
+ remove_total_weight)
+ self._check_mutating_imethod()
+
+ def push(self,
+ float delta=fst.kDelta,
+ bool remove_total_weight=False,
+ bool to_final=False):
+ """
+ push(self, delta=0.0009765625, remove_total_weight=False, to_final=False)
+
+ Pushes weights towards the initial or final states.
+
+ This operation destructively produces an equivalent transducer by pushing
+ the weights towards the initial state or toward the final states. When
+ pushing weights towards the initial state, the sum of the weight of the
+ outgoing transitions and final weight at any non-initial state is equal to
+ one in the resulting machine. When pushing weights towards the final states,
+ the sum of the weight of the incoming transitions at any state is equal to
+ one. Weights need to be left distributive when pushing towards the initial
+ state and right distributive when pushing towards the final states.
+
+ Args:
+ delta: Comparison/quantization delta.
+ remove_total_weight: If pushing weights, should the total weight be
+ removed?
+ to_final: Push towards final states?
+
+ Returns:
+ self.
+
+ See also: The constructive variant, which also supports label pushing.
+ """
+ self._push(delta, remove_total_weight, to_final)
+ return self
+
+ cdef void _relabel_pairs(self, ipairs=None, opairs=None) except *:
+ cdef unique_ptr[vector[fst.LabelPair]] _ipairs
+ _ipairs.reset(new vector[fst.LabelPair]())
+ cdef unique_ptr[vector[fst.LabelPair]] _opairs
+ _opairs.reset(new vector[fst.LabelPair]())
+ cdef int64 before
+ cdef int64 after
+ if ipairs:
+ for (before, after) in ipairs:
+ _ipairs.get().push_back(fst.LabelPair(before, after))
+ if opairs:
+ for (before, after) in opairs:
+ _opairs.get().push_back(fst.LabelPair(before, after))
+ if _ipairs.get().empty() and _opairs.get().empty():
+ raise FstArgError("No relabeling pairs specified.")
+ fst.Relabel(self._mfst.get(), deref(_ipairs), deref(_opairs))
+ self._check_mutating_imethod()
+
+ def relabel_pairs(self, ipairs=None, opairs=None):
+ """
+ relabel_pairs(self, ipairs=None, opairs=None)
+
+ Replaces input and/or output labels using pairs of labels.
+
+ This operation destructively relabels the input and/or output labels of the
+ FST using pairs of the form (old_ID, new_ID); omitted indices are
+ identity-mapped.
+
+ Args:
+ ipairs: An iterable containing (older index, newer index) integer pairs.
+ opairs: An iterable containing (older index, newer index) integer pairs.
+
+ Returns:
+ self.
+
+ Raises:
+ FstArgError: No relabeling pairs specified.
+
+ See also: `decode`, `encode`, `project`, `relabel_tables`.
+ """
+ self._relabel_pairs(ipairs, opairs)
+ return self
+
+ cdef void _relabel_tables(self,
+ _SymbolTable old_isymbols=None,
+ _SymbolTable new_isymbols=None,
+ bool attach_new_isymbols=True,
+ _SymbolTable old_osymbols=None,
+ _SymbolTable new_osymbols=None,
+ bool attach_new_osymbols=True) except *:
+ if new_isymbols is None and new_osymbols is None:
+ raise FstArgError("No new SymbolTables specified")
+ cdef fst.SymbolTable *new_isymbols_ptr = NULL
+ if new_isymbols is not None:
+ new_isymbols_ptr = new_isymbols._table
+ cdef fst.SymbolTable *new_osymbols_ptr = NULL
+ if new_osymbols is not None:
+ new_osymbols_ptr = new_osymbols._table
+ fst.Relabel(self._mfst.get(),
+ self._fst.get().InputSymbols() if old_isymbols is None else
+ old_isymbols._table, new_isymbols_ptr, attach_new_isymbols,
+ self._fst.get().OutputSymbols() if old_osymbols is None else
+ old_osymbols._table, new_osymbols_ptr, attach_new_osymbols)
+ self._check_mutating_imethod()
+
+ def relabel_tables(self,
+ _SymbolTable old_isymbols=None,
+ _SymbolTable new_isymbols=None,
+ bool attach_new_isymbols=True,
+ _SymbolTable old_osymbols=None,
+ _SymbolTable new_osymbols=None,
+ bool attach_new_osymbols=True):
+ """
+ relabel_tables(self, old_isymbols=None, new_isymbols=None,
+ attach_new_isymbols=True, old_osymbols=None,
+ new_osymbols=None, 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
+ 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.
+ attach_new_isymbols: Should new_osymbols be made the FST's output symbol
+ table?
+
+ Returns:
+ self.
+
+ Raises:
+ FstArgError: No SymbolTable specified.
+
+ See also: `decode`, `encode`, `project`, `relabel_pairs`.
+ """
+ self._relabel_tables(old_isymbols, new_isymbols, attach_new_isymbols,
+ old_osymbols, new_osymbols, attach_new_osymbols)
+ return self
+
+ cdef void _reserve_arcs(self, int64 state, size_t n) except *:
+ if not self._mfst.get().ReserveArcs(state, n):
+ raise FstIndexError("State index out of range")
+ self._check_mutating_imethod()
+
+ def reserve_arcs(self, int64 state, size_t n):
+ """
+ reserve_arcs(self, state, n)
+
+ Reserve n arcs at a particular state (best effort).
+
+ Args:
+ state: The integer index of a state.
+ n: The number of arcs to reserve.
+
+ Returns:
+ self.
+
+ Raises:
+ FstIndexError: State index out of range.
+
+ See also: `reserve_states`.
+ """
+ self._reserve_arcs(state, n)
+ return self
+
+ cdef void _reserve_states(self, int64 n) except *:
+ self._mfst.get().ReserveStates(n)
+ self._check_mutating_imethod()
+
+ def reserve_states(self, int64 n):
+ """
+ reserve_states(self, n)
+
+ Reserve n states (best effort).
+
+ Args:
+ n: The number of states to reserve.
+
+ Returns:
+ self.
+
+ See also: `reserve_arcs`.
+ """
+ self._reserve_states(n)
+ return self
+
+ cdef void _reweight(self, potentials, bool to_final=False) except *:
+ cdef unique_ptr[vector[fst.WeightClass]] _potentials
+ _potentials.reset(new vector[fst.WeightClass]())
+ cdef string weight_type = self.weight_type()
+ for weight in potentials:
+ _potentials.get().push_back(_get_WeightClass_or_One(self.weight_type(),
+ weight))
+ fst.Reweight(self._mfst.get(), deref(_potentials),
+ fst.GetReweightType(to_final))
+ self._check_mutating_imethod()
+
+ def reweight(self, potentials, bool to_final=False):
+ """
+ reweight(self, potentials, to_final=False)
+
+ Reweights an FST using an iterable of potentials.
+
+ This operation destructively reweights an FST according to the potentials
+ and in the direction specified by the user. An arc of weight w, with an
+ origin state of potential p and destination state of potential q, is
+ reweighted by p^{-1} \otimes (w \otimes q) when reweighting towards the
+ initial state, and by (p \otimes w) \otimes q^{-1} when reweighting towards
+ the final states. The weights must be left distributive when reweighting
+ towards the initial state and right distributive when reweighting towards
+ the final states (e.g., TropicalWeight and LogWeight).
+
+ Args:
+ potentials: An iterable of Weight or weight strings.
+ to_final: Push towards final states?
+
+ Returns:
+ self.
+ """
+ self._reweight(potentials, to_final)
+ return self
+
+ cdef void _rmepsilon(self,
+ bool connect=True,
+ float delta=fst.kDelta,
+ int64 nstate=fst.kNoStateId,
+ weight=None) except *:
+ # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ cdef fst.WeightClass wc = _get_WeightClass_or_Zero(self.weight_type(),
+ weight)
+ fst.RmEpsilon(self._mfst.get(), connect, wc, nstate, delta)
+ self._check_mutating_imethod()
+
+ def rmepsilon(self,
+ bool connect=True,
+ float delta=fst.kDelta,
+ int64 nstate=fst.kNoStateId,
+ weight=None):
+ """
+ rmepsilon(self, connect=True, delta=0.0009765625, nstate=-1, weight=None)
+
+ Removes epsilon transitions.
+
+ This operation destructively removes epsilon transitions, i.e., those where
+ both input and output labels are epsilon) from an FST.
+
+ Args:
+ connect: Should output be trimmed?
+ delta: Comparison/quantization delta.
+ nstate: State number threshold.
+ weight: A Weight or weight string indicating the desired weight threshold
+ below which paths are pruned; if omitted, no paths are pruned.
+
+ Returns:
+ self.
+
+ See also: The constructive variant, which also supports epsilon removal in
+ reverse (and which may be more efficient).
+ """
+ self._rmepsilon(connect, delta, nstate, weight)
+ return self
+
+ cdef void _set_final(self, int64 state, weight=None) except *:
+ if not self._mfst.get().ValidStateId(state):
+ raise FstIndexError("State index out of range")
+ cdef fst.WeightClass wc = _get_WeightClass_or_One(self.weight_type(),
+ weight)
+ if not self._mfst.get().SetFinal(state, wc):
+ raise FstOpError("incompatible or invalid weight")
+ self._check_mutating_imethod()
+
+ def set_final(self, int64 state, weight=None):
+ """
+ set_final(self, state, weight)
+
+ Sets a state to be final with a fixed cost.
+
+ 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.
+
+ Raises:
+ FstIndexError: State index out of range.
+ FstOpError: incompatible or invalid weight.
+
+ See also: `set_start`.
+ """
+ self._set_final(state, weight)
+ return self
+
+ cdef void _set_properties(self, uint64 props, uint64 mask) except *:
+ self._mfst.get().SetProperties(props, mask)
+
+ def set_properties(self, uint64 props, uint64 mask):
+ """
+ set_properties(self, props, mask)
+
+ Sets the properties bits.
+
+ Args:
+ props: The properties to be set.
+ mask: A mask to be applied to the `props` argument before
+ setting the FST's properties.
+
+ Returns:
+ self.
+ """
+ self._set_properties(props, mask)
+ return self
+
+ cdef void _set_start(self, int64 state) except *:
+ if not self._mfst.get().SetStart(state):
+ raise FstIndexError("State index out of range")
+ self._check_mutating_imethod()
+
+ def set_start(self, int64 state):
+ """
+ set_start(self, state)
+
+ Sets the initial state.
+
+ Args:
+ state: The integer index of a state.
+
+ Returns:
+ self.
+
+ Raises:
+ FstIndexError: State index out of range.
+
+ See also: `set_final`.
+ """
+ self._set_start(state)
+ return self
+
+ cdef void _set_input_symbols(self, _SymbolTable syms) except *:
+ if syms is None:
+ self._mfst.get().SetInputSymbols(NULL)
+ return
+ self._mfst.get().SetInputSymbols(syms._table)
+ self._check_mutating_imethod()
+
+ def set_input_symbols(self, _SymbolTable syms):
+ """
+ set_input_symbols(self, syms)
+
+ Sets the input symbol table.
+
+ Passing None as a value will delete the input symbol table.
+
+ Args:
+ syms: A SymbolTable.
+
+ Returns:
+ self.
+
+ See also: `set_output_symbols`.
+ """
+ self._set_input_symbols(syms)
+ return self
+
+ cdef void _set_output_symbols(self, _SymbolTable syms) except *:
+ if syms is None:
+ self._mfst.get().SetOutputSymbols(NULL)
+ return
+ self._mfst.get().SetOutputSymbols(syms._table)
+ self._check_mutating_imethod()
+
+ def set_output_symbols(self, _SymbolTable syms):
+ """
+ set_output_symbols(self, syms)
+
+ Sets the output symbol table.
+
+ Passing None as a value will delete the output symbol table.
+
+ Args:
+ syms: A SymbolTable.
+
+ Returns:
+ self.
+
+ See also: `set_input_symbols`.
+ """
+ self._set_output_symbols(syms)
+ return self
+
+ cdef void _topsort(self) except *:
+ # TopSort returns False if the FST is cyclic, and thus can't be TopSorted.
+ if not fst.TopSort(self._mfst.get()):
+ logging.warning("Cannot topsort cyclic FST.")
+ self._check_mutating_imethod()
+
+ def topsort(self):
+ """
+ topsort(self)
+
+ Sorts transitions by state IDs.
+
+ This operation destructively topologically sorts the FST, if it is acyclic;
+ otherwise it remains unchanged. Once sorted, all transitions are from lower
+ state IDs to higher state IDs
+
+ Returns:
+ self.
+
+ See also: `arcsort`.
+ """
+ self._topsort()
+ return self
+
+ cdef void _union(self, _Fst ifst) except *:
+ fst.Union(self._mfst.get(), deref(ifst._fst))
+ self._check_mutating_imethod()
+
+ def union(self, _Fst ifst):
+ """
+ union(self, ifst)
+
+ Computes the union (sum) of two FSTs.
+
+ This operation computes the union (sum) of two FSTs. If A transduces string
+ x to y with weight a and B transduces string w to v with weight b, then
+ their union transduces x to y with weight a and w to v with weight b.
+
+ Args:
+ ifst: The second input FST.
+
+ Returns:
+ self.
+ """
+ self._union(ifst)
+ return self
+
+
+# Pseudo-constructors for _Fst and _MutableFst.
+#
+# _init_Fst and _init_MutableFst use an FstClass pointer to instantiate _Fst
+# and _MutableFst objects, respectively. The latter function is only safe to
+# call when the FST being wrapped is known to be kMutable. The caller can
+# safely use it when they have either checked this bit (e.g., by using
+# _init_XFst) or have themselves constructed a mutable container for the
+# FstClass pointer they're passing (e.g., most of the constructive operations,
+# storing their results in a VectorFstClass, a derivative of MutableFstClass).
+#
+# _create_Fst constructs an empty VectorFstClass of a user-specified arc type,
+# and passes this pointer to _init_MutableFst.
+#
+# _read_Fst reads an FST from disk, performing FST conversion if requested, and
+# then passes this pointer to _init_XFst.
+#
+# The Python class Fst provides a wrapper for these two operations. The former
+# can be accessed by calling Fst(...), which acts like a class method, and the
+# latter via Fst.read(...), which acts like a static method. This is a bit
+# nasty, but totally hidden from the Python user.
+
+
+cdef _Fst _init_Fst(FstClass_ptr tfst):
+ if tfst.Properties(fst.kError, True):
+ raise FstOpError("Operation failed")
+ cdef _Fst ofst = _Fst.__new__(_Fst)
+ ofst._fst.reset(<FstClass_ptr> tfst)
+ return ofst
+
+
+cdef _MutableFst _init_MutableFst(MutableFstClass_ptr tfst):
+ if tfst.Properties(fst.kError, True):
+ raise FstOpError("Operation failed")
+ cdef _MutableFst ofst = _MutableFst.__new__(_MutableFst)
+ ofst._fst.reset(<MutableFstClass_ptr> tfst)
+ # Makes a copy of it as the derived type! Cool.
+ ofst._mfst = static_pointer_cast[fst.MutableFstClass, fst.FstClass](ofst._fst)
+ return ofst
+
+
+cdef _Fst _init_XFst(FstClass_ptr tfst):
+ if tfst.Properties(fst.kMutable, True):
+ return _init_MutableFst(static_cast[MutableFstClass_ptr](tfst))
+ else:
+ return _init_Fst(tfst)
+
+
+cdef _MutableFst _create_Fst(arc_type=b"standard"):
+ cdef fst.VectorFstClass *tfst = new fst.VectorFstClass(
+ <string> tostring(arc_type))
+ if tfst == NULL:
+ raise FstOpError("Unknown arc type: {!r}".format(arc_type))
+ return _init_MutableFst(tfst)
+
+
+cdef _Fst _read_Fst(filename, fst_type=None):
+ cdef fst.FstClass *tfst = fst.FstClass.Read(tostring(filename))
+ if tfst == NULL:
+ raise FstIOError("Read failed: {!r}".format(filename))
+ # Converts if requested.
+ cdef string fst_type_string
+ if fst_type:
+ fst_type_string = tostring(fst_type)
+ if fst_type_string != tfst.FstType():
+ tfst = fst.Convert(deref(tfst), fst_type_string)
+ if tfst == NULL:
+ raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ return _init_XFst(tfst)
+
+cdef _Fst _deserialize_Fst(fst_string, fst_type=None):
+ ofst = fst.FstClass.ReadFromString(fst_string)
+ if fst_type is not None:
+ fst_type_string = tostring(fst_type)
+ if fst_type_string != ofst.FstType():
+ ofst = fst.Convert(deref(ofst), fst_type_string)
+ if ofst == NULL:
+ raise FstOpError("Conversion to {!r} failed.".format(fst_type))
+ return _init_XFst(ofst)
+
+class Fst(object):
+
+ """
+ Fst(arc_type="standard")
+
+ Constructs an empty FST.
+
+ Args:
+ arc_type: A string indicating the arc type.
+
+ Raises:
+ FstError: Unknown arc type.
+
+ Raises:
+ FstOpError: operation failed.
+ """
+
+ def __new__(cls, arc_type=b"standard"):
+ return _create_Fst(arc_type)
+
+ @staticmethod
+ def read(filename, fst_type=None):
+ """
+ read(filename, fst_type=None)
+
+ Reads an FST from a file.
+
+ Args:
+ filename: The string location of the input file.
+ fst_type: A string indicating the FST type to convert to; no conversion
+ is performed if omitted or if the FST is already of the desired type.
+
+ Returns:
+ An FST object.
+
+ Raises:
+ FstIOError: Read failed.
+ FstOpError: Read-time conversion failed.
+ """
+ return _read_Fst(filename, fst_type)
+
+ @staticmethod
+ def read_from_string(fst_string, fst_type=None):
+ """
+ read_from_string(fst_string, fst_type=None)
+
+ Reads an FST from a string.
+
+ Args:
+ fst_string: The string containing the serialized Fst.
+ fst_type: A string indicating the FST type to convert to; no conversion
+ is performed if omitted or if the FST is already of the desired type.
+
+ Returns:
+ An FST object.
+
+ Raises:
+ FstIOError: Read failed.
+ FstOpError: Read-time conversion failed.
+ """
+ return _deserialize_Fst(fst_string, fst_type)
+
+## FST properties.
+
+
+EXPANDED = fst.kExpanded
+MUTABLE = fst.kMutable
+ERROR = fst.kError
+ACCEPTOR = fst.kAcceptor
+NOT_ACCEPTOR = fst.kNotAcceptor
+I_DETERMINISTIC = fst.kIDeterministic
+NON_I_DETERMINISTIC = fst.kNonIDeterministic
+O_DETERMINISTIC = fst.kODeterministic
+NON_O_DETERMINISTIC = fst.kNonODeterministic
+EPSILONS = fst.kEpsilons
+NO_EPSILONS = fst.kNoEpsilons
+I_EPSILONS = fst.kIEpsilons
+NO_I_EPSILONS = fst.kNoIEpsilons
+O_EPSILONS = fst.kOEpsilons
+NO_O_EPSILONS = fst.kNoOEpsilons
+I_LABEL_SORTED = fst.kILabelSorted
+NOT_I_LABEL_SORTED = fst.kNotILabelSorted
+O_LABEL_SORTED = fst.kOLabelSorted
+NOT_O_LABEL_SORTED = fst.kNotOLabelSorted
+WEIGHTED = fst.kWeighted
+UNWEIGHTED = fst.kUnweighted
+CYCLIC = fst.kCyclic
+ACYCLIC = fst.kAcyclic
+INITIAL_CYCLIC = fst.kInitialCyclic
+INITIAL_ACYCLIC = fst.kInitialAcyclic
+TOP_SORTED = fst.kTopSorted
+NOT_TOP_SORTED = fst.kNotTopSorted
+ACCESSIBLE = fst.kAccessible
+NOT_ACCESSIBLE = fst.kNotAccessible
+COACCESSIBLE = fst.kCoAccessible
+NOT_COACCESSIBLE = fst.kNotCoAccessible
+STRING = fst.kString
+NOT_STRING = fst.kNotString
+WEIGHTED_CYCLES = fst.kWeightedCycles
+UNWEIGHTED_CYCLES = fst.kUnweightedCycles
+NULL_PROPERTIES = fst.kNullProperties
+COPY_PROPERTIES = fst.kCopyProperties
+INTRINSIC_PROPERTIES = fst.kIntrinsicProperties
+EXTRINSIC_PROPERTIES = fst.kExtrinsicProperties
+SET_START_PROPERTIES = fst.kSetStartProperties
+SET_FINAL_PROPERTIES = fst.kSetFinalProperties
+ADD_STATE_PROPERTIES = fst.kAddStateProperties
+ADD_ARC_PROPERTIES = fst.kAddArcProperties
+SET_ARC_PROPERTIES = fst.kSetArcProperties
+DELETE_STATE_PROPERTIES = fst.kDeleteStatesProperties
+DELETE_ARC_PROPERTIES = fst.kDeleteArcsProperties
+STATE_SORT_PROPERTIES = fst.kStateSortProperties
+ARC_SORT_PROPERTIES = fst.kArcSortProperties
+I_LABEL_INVARIANT_PROPERTIES = fst.kILabelInvariantProperties
+O_LABEL_INVARIANT_PROPERTIES = fst.kOLabelInvariantProperties
+WEIGHT_INVARIANT_PROPERTIES = fst.kWeightInvariantProperties
+ADD_SUPERFINAL_PROPERTIES = fst.kAddSuperFinalProperties
+RM_SUPERFINAL_PROPERTIES = fst.kRmSuperFinalProperties
+BINARY_PROPERTIES = fst.kBinaryProperties
+TRINARY_PROPERTIES = fst.kTrinaryProperties
+POS_TRINARY_PROPERTIES = fst.kPosTrinaryProperties
+NEG_TRINARY_PROPERTIES = fst.kNegTrinaryProperties
+FST_PROPERTIES = fst.kFstProperties
+
+
+## Arc, ArcIterator, and MutableArcIterator.
+
+
+cdef class Arc(object):
+
+ """
+ Arc(ilabel, olabel, weight, nextstate)
+
+ This class represents an arc while remaining agnostic about the underlying arc
+ type. Attributes of the arc can be accessed or mutated, and the arc can be
+ copied.
+
+ Attributes:
+ ilabel: The input label.
+ olabel: The output label.
+ weight: The arc weight.
+ nextstate: The destination state for the arc.
+ """
+
+ def __repr__(self):
+ return "<Arc at 0x{:x}>".format(id(self))
+
+ def __init__(self, int64 ilabel, int64 olabel, weight, int64 nextstate):
+ cdef fst.WeightClass wc = _get_WeightClass_or_One(b"tropical", weight)
+ self._arc.reset(new fst.ArcClass(ilabel, olabel, wc, nextstate))
+
+ cpdef Arc copy(self):
+ return Arc(self.ilabel, self.olabel, self.weight, self.nextstate)
+
+ property ilabel:
+
+ def __get__(self):
+ return deref(self._arc).ilabel
+
+ def __set__(self, int64 value):
+ deref(self._arc).ilabel = value
+
+ property olabel:
+
+ def __get__(self):
+ return deref(self._arc).olabel
+
+ def __set__(self, int64 value):
+ deref(self._arc).olabel = value
+
+ property weight:
+
+ def __get__(self):
+ cdef Weight weight = Weight.__new__(Weight)
+ weight._weight.reset(new fst.WeightClass(deref(self._arc).weight))
+ return weight
+
+ def __set__(self, weight):
+ deref(self._arc).weight = _get_WeightClass_or_One(b"tropical", weight)
+
+ property nextstate:
+
+ def __get__(self):
+ return deref(self._arc).nextstate
+
+ def __set__(self, int64 value):
+ deref(self._arc).nextstate = value
+
+
+cdef Arc _init_Arc(const fst.ArcClass &arc):
+ cdef Weight weight = Weight.__new__(Weight)
+ weight._weight.reset(new fst.WeightClass(arc.weight))
+ return Arc(<int64> arc.ilabel, <int64> arc.olabel, weight,
+ <int64> arc.nextstate)
+
+
+cdef class ArcIterator(object):
+
+ """
+ ArcIterator(ifst, state)
+
+ This class is used for iterating over the arcs leaving some state of an FST.
+ It supports the full C++ API, but most users should just call the `arcs`
+ method of an FST object and take advantage of the Pythonic API.
+ """
+
+ def __repr__(self):
+ return "<ArcIterator at 0x{:x}>".format(id(self))
+
+ def __init__(self, _Fst ifst, int64 state):
+ if not ifst._fst.get().ValidStateId(state):
+ raise FstIndexError("State index out of range")
+ # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ self._fst = ifst._fst
+ self._aiter.reset(new fst.ArcIteratorClass(deref(self._fst), state))
+
+ # This just registers this class as a possible iterator.
+ def __iter__(self):
+ return self
+
+ # Magic method used to get a Pythonic API out of the C++ API.
+ def __next__(self):
+ if self.done():
+ raise StopIteration
+ result = self.value()
+ self.next()
+ return result
+
+ cpdef bool done(self):
+ """
+ done(self)
+
+ Indicates whether the iterator is exhausted or not.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ True if the iterator is exhausted, False otherwise.
+ """
+ return self._aiter.get().Done()
+
+ cpdef uint32 flags(self):
+ """
+ flags(self)
+
+ Returns the current iterator behavioral flags.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ The current iterator behavioral flags as an integer.
+ """
+ return self._aiter.get().Flags()
+
+ cpdef void next(self):
+ """
+ next(self)
+
+ Advances the iterator.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._aiter.get().Next()
+
+ cpdef size_t position(self):
+ """
+ next(self)
+
+ Returns the position of the iterator.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ 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.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._aiter.get().Reset()
+
+ cpdef void seek(self, size_t a):
+ """
+ seek(self, a)
+
+ Advance the iterator to a new position.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Args:
+ a: The position to seek to.
+ """
+ self._aiter.get().Seek(a)
+
+ cpdef void set_flags(self, uint32 flags, uint32 mask):
+ """
+ set_flags(self, flags, mask)
+
+ Sets the current iterator behavioral flags.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ 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, represented as a tuple.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ return _init_Arc(self._aiter.get().Value())
+
+
+cdef class MutableArcIterator(object):
+
+ """
+ MutableArcIterator(ifst, state)
+
+ This class is used for iterating over the arcs leaving some state of an FST,
+ also permitting mutation of the current arc. It supports the full C++ API,
+ but most users should just call the `mutable_arcs` method of an FST object
+ and take advantage of the Pythonic API.
+ """
+
+ def __repr__(self):
+ return "<MutableArcIterator at 0x{:x}>".format(id(self))
+
+ def __init__(self, _MutableFst ifst, int64 state):
+ if not ifst._fst.get().ValidStateId(state):
+ raise FstIndexError("State index out of range")
+ # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ self._mfst = ifst._mfst
+ self._aiter.reset(new fst.MutableArcIteratorClass(ifst._mfst.get(), state))
+
+ # 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.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ True if the iterator is exhausted, False otherwise.
+ """
+ return self._aiter.get().Done()
+
+ cpdef uint32 flags(self):
+ """
+ flags(self)
+
+ Returns the current iterator behavioral flags.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ The current iterator behavioral flags as an integer.
+ """
+ return self._aiter.get().Flags()
+
+ cpdef void next(self):
+ """
+ next(self)
+
+ Advances the iterator.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._aiter.get().Next()
+
+ cpdef size_t position(self):
+ """
+ next(self)
+
+ Returns the position of the iterator.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ 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.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._aiter.get().Reset()
+
+ cpdef void seek(self, size_t a):
+ """
+ seek(self, a)
+
+ Advance the iterator to a new position.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Args:
+ a: The position to seek to.
+ """
+ self._aiter.get().Seek(a)
+
+ cpdef void set_flags(self, uint32 flags, uint32 mask):
+ """
+ set_flags(self, flags, mask)
+
+ Sets the current iterator behavioral flags.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ 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, represented as a tuple.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ return _init_Arc(self._aiter.get().Value())
+
+
+## StateIterator.
+
+
+cdef class StateIterator(object):
+
+ """
+ StateIterator(ifst)
+
+ This class is used for iterating over the states in an FST. It supports the
+ full C++ API, but most users should just place an FST argument in an
+ iteration context and take advantage of the Pythonic API.
+ """
+
+ def __repr__(self):
+ return "<StateIterator at 0x{:x}>".format(id(self))
+
+ def __init__(self, _Fst ifst):
+ # Makes copy of the shared_ptr, potentially extending the FST's lifetime.
+ self._fst = ifst._fst
+ self._siter.reset(new fst.StateIteratorClass(deref(self._fst)))
+
+ # This just registers this class as a possible iterator.
+ def __iter__(self):
+ return self
+
+ # Magic method used to get a Pythonic API out of the C++ API.
+ def __next__(self):
+ if self.done():
+ raise StopIteration
+ cdef int64 result = self.value()
+ self.next()
+ return result
+
+ cpdef bool done(self):
+ """
+ done(self)
+
+ Indicates whether the iterator is exhausted or not.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ True if the iterator is exhausted, False otherwise.
+ """
+ return self._siter.get().Done()
+
+ cpdef void next(self):
+ """
+ next(self)
+
+ Advances the iterator.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._siter.get().Next()
+
+ cpdef void reset(self):
+ """
+ reset(self)
+
+ Resets the iterator to the initial position.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._siter.get().Reset()
+
+ cpdef int64 value(self):
+ """
+ value(self)
+
+ Returns the current state index.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ return self._siter.get().Value()
+
+
+## FST operations.
+
+
+cdef _Fst _map(_Fst ifst,
+ float delta=fst.kDelta,
+ mt=b"identity",
+ weight=None):
+ cdef fst.MapType map_type
+ if not fst.GetMapType(tostring(mt), addr(map_type)):
+ raise FstArgError("Unknown map type: {!r}".format(mt))
+ cdef fst.WeightClass wc = (_get_WeightClass_or_One(ifst.weight_type(),
+ weight) if mt == fst.TIMES_MAPPER else
+ _get_WeightClass_or_Zero(ifst.weight_type(), weight))
+ return _init_XFst(fst.Map(deref(ifst._fst), map_type, delta, wc))
+
+
+cpdef _Fst arcmap(_Fst ifst,
+ float delta=fst.kDelta,
+ mt=b"identity",
+ weight=None):
+ """
+ arcmap(ifst, delta=0.0009765625, mt="identity", weight=None)
+
+ Constructively applies a transform to all arcs and final states.
+
+ This operation transforms each arc and final state in the input FST using
+ one of the following:
+
+ * identity: maps to self.
+ * input_epsilon: replaces all input labels with epsilon.
+ * invert: reciprocates all non-Zero weights.
+ * output_epsilon: replaces all output labels with epsilon.
+ * plus: adds a constant to all weights.
+ * quantize: quantizes weights.
+ * rmweight: replaces all non-Zero weights with 1.
+ * superfinal: redirects final states to a new superfinal state.
+ * times: right-multiplies a constant to all weights.
+ * to_log: converts weights to the log semiring.
+ * to_log64: converts weights to the log64 semiring.
+ * to_standard: converts weights to the tropical ("standard") semiring.
+
+ Args:
+ ifst: The input FST.
+ delta: Comparison/quantization delta (ignored unless `mt` is `quantize`).
+ map_type: A string matching a known mapping operation (see above).
+ weight: A Weight or weight string passed to the arc-mapper; this is ignored
+ unless `mt` is `plus` (in which case it defaults to semiring Zero) or
+ `times` (in which case it defaults to semiring One).
+
+ Returns:
+ An FST with arcs and final states remapped.
+
+ Raises:
+ FstArgError: Unknown map type.
+
+ See also: `statemap`.
+ """
+ return _map(ifst, delta, mt, weight)
+
+
+cpdef _MutableFst compose(_Fst ifst1,
+ _Fst ifst2,
+ cf=b"auto",
+ bool connect=True):
+ """
+ compose(ifst1, ifst2, cf="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.
+ cf: A string matching a known composition filter; one of: "alt_sequence",
+ "auto", "match", "null", "sequence", "trivial".
+ connect: Should output be trimmed?
+
+ Returns:
+ A composed FST.
+
+ See also: `arcsort`.
+ """
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type())
+ cdef unique_ptr[fst.ComposeOptions] opts
+ opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ fst.Compose(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+cpdef _Fst convert(_Fst ifst, fst_type=b""):
+ """
+ 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 None if
+ no conversion is desired.
+
+ Returns:
+ An equivalent Fst converted to the desired FST type.
+
+ Raises:
+ FstOpError: Conversion failed.
+ """
+ cdef FstClass_ptr tfst = new fst.FstClass(deref(ifst._fst))
+ tfst = fst.Convert(deref(ifst._fst), tostring(fst_type))
+ # Script-land Convert returns the null pointer to signal failure.
+ if tfst == NULL:
+ raise FstOpError("Conversion to {!r} failed".format(fst_type))
+ return _init_XFst(tfst)
+
+
+cpdef _MutableFst determinize(_Fst ifst,
+ float delta=fst.kDelta,
+ dt=b"functional",
+ int64 nstate=fst.kNoStateId,
+ int64 subsequential_label=0,
+ weight=None,
+ bool increment_subsequential_label=False):
+ """
+ determinize(ifst, delta=0.0009765625, dt="functional", nstate=-1,
+ 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.
+ dt: Type of determinization; one of: "functional" (input transducer is
+ functional), "nonfunctional" (input transducer is not functional) and
+ disambiguate" (input transducer is not functional but only keep the min
+ of ambiguous outputs).
+ nstate: State number threshold.
+ subsequential_label: Input label of arc corresponding to residual final
+ output when producing a subsequential transducer.
+ weight: A Weight or weight string indicating the desired weight threshold
+ below which paths are pruned; if omitted, no paths are pruned.
+ increment_subsequential_label: Increment subsequential when creating
+ several arcs for the residual final output at a given state.
+
+ Returns:
+ An equivalent deterministic FST.
+
+ Raises:
+ FstArgError: Unknown determinization type.
+
+ See also: `disambiguate`, `rmepsilon`.
+ """
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ # Threshold is set to semiring Zero (no pruning) if weight unspecified.
+ cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(),
+ weight)
+ cdef fst.DeterminizeType determinize_type
+ if not fst.GetDeterminizeType(tostring(dt), addr(determinize_type)):
+ raise FstArgError("Unknown determinization type: {!r}".format(dt))
+ cdef unique_ptr[fst.DeterminizeOptions] opts
+ opts.reset(new fst.DeterminizeOptions(delta, wc, nstate, subsequential_label,
+ determinize_type,
+ increment_subsequential_label))
+ fst.Determinize(deref(ifst._fst), tfst, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+cpdef _MutableFst difference(_Fst ifst1,
+ _Fst ifst2,
+ cf=b"auto",
+ bool connect=True):
+ """
+ difference(ifst1, ifst2, cf="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.
+ cf: A string matching a known composition filter; one of: "alt_sequence",
+ "auto", "match", "null", "sequence", "trivial".
+ connect: Should the output FST be trimmed?
+
+ Returns:
+ An FST representing the difference of the two input FSTs.
+ """
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type())
+ cdef unique_ptr[fst.ComposeOptions] opts
+ opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ fst.Difference(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+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=-1, subsequential_label=0,
+ weight=None):
+
+ Constructively disambiguates a weighted transducer.
+
+ This operation disambiguates a weighted transducer. The result will be an
+ equivalent FST that has the property that no two successful paths have the
+ same input labeling. For this algorithm, epsilon transitions are treated as
+ regular symbols (cf. `rmepsilon`).
+
+ Args:
+ ifst: The input FST.
+ delta: Comparison/quantization delta.
+ nstate: State number threshold.
+ subsequential_label: Input label of arc corresponding to residual final
+ output when producing a subsequential transducer.
+ weight: A Weight or weight string indicating the desired weight threshold
+ below which paths are pruned; if omitted, no paths are pruned.
+
+ Returns:
+ An equivalent disambiguated FST.
+
+ See also: `determinize`, `rmepsilon`.
+ """
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(),
+ weight)
+ cdef unique_ptr[fst.DisambiguateOptions] opts
+ opts.reset(new fst.DisambiguateOptions(delta, wc, nstate,
+ subsequential_label))
+ fst.Disambiguate(deref(ifst._fst), tfst, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+cpdef _MutableFst epsnormalize(_Fst ifst, bool eps_norm_output=False):
+ """
+ epsnormalize(ifst, eps_norm_output=False)
+
+ Constructively epsilon-normalizes an FST.
+
+ This operation creates an equivalent FST that is epsilon-normalized. An
+ acceptor is epsilon-normalized if it it is epsilon-removed (cf. `rmepsilon`).
+ A transducer is input epsilon-normalized if, in addition, along any path, all
+ arcs with epsilon input labels follow all arcs with non-epsilon input labels.
+ Output epsilon-normalized is defined similarly. The input FST must be
+ functional.
+
+ Args:
+ ifst: The input FST.
+ eps_norm_output: Should the FST be output epsilon-normalized?
+
+ Returns:
+ An equivalent epsilon-normalized FST.
+
+ See also: `rmepsilon`.
+ """
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ fst.EpsNormalize(deref(ifst._fst), tfst, fst.EPS_NORM_OUTPUT if
+ eps_norm_output else
+ fst.EPS_NORM_INPUT)
+ return _init_MutableFst(tfst)
+
+
+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 two transducers satisfy the above condition, else False.
+
+ See also: `equivalent`, `isomorphic`, `randequivalent`.
+ """
+ return fst.Equal(deref(ifst1._fst), deref(ifst2._fst), delta)
+
+
+cpdef bool equivalent(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta) except *:
+ """
+ equivalent(ifst1, ifst2, delta=0.0009765625)
+
+ Are the two acceptors equivalent?
+
+ This operation tests whether two epsilon-free deterministic weighted
+ acceptors are equivalent, that is if they accept the same strings with the
+ same weights.
+
+ Args:
+ ifst1: The first input FST.
+ ifst2: The second input FST.
+ delta: Comparison/quantization delta.
+
+ Returns:
+ True if the two transducers satisfy the above condition, else False.
+
+ Raises:
+ FstOpError: Equivalence test encountered error.
+
+ See also: `equal`, `isomorphic`, `randequivalent`.
+ """
+ cdef bool error
+ cdef bool result = fst.Equivalent(deref(ifst1._fst), deref(ifst2._fst), delta,
+ addr(error))
+ if error:
+ raise FstOpError("Equivalence test encountered error")
+ return result
+
+
+cpdef _MutableFst intersect(_Fst ifst1,
+ _Fst ifst2,
+ cf=b"auto",
+ bool connect=True):
+ """
+ intersect(ifst1, ifst2, cf="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.
+ cf: A string matching a known composition filter; one of: "alt_sequence",
+ "auto", "match", "null", "sequence", "trivial".
+ connect: Should output be trimmed?
+
+ Returns:
+ An equivalent epsilon-normalized FST.
+ """
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst1.arc_type())
+ cdef unique_ptr[fst.ComposeOptions] opts
+ opts.reset(new fst.ComposeOptions(connect, _get_compose_filter(tostring(cf))))
+ fst.Intersect(deref(ifst1._fst), deref(ifst2._fst), tfst, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+cpdef bool isomorphic(_Fst ifst1, _Fst ifst2, float delta=fst.kDelta):
+ """
+ isomorphic(ifst1, ifst2, delta=0.0009765625)
+
+ Are the two acceptors isomorphic?
+
+ This operation determines if two transducers with a certain required
+ determinism have the same states, irrespective of numbering, and the same
+ transitions with the same labels and weights, irrespective of ordering. In
+ other words, FSTs A, B are isomorphic if and only if the states of A can be
+ renumbered and the transitions leaving each state reordered so the two are
+ equal (according to the definition given in `equal`).
+
+ Args:
+ ifst1: The first input FST.
+ ifst2: The second input FST.
+ delta: Comparison/quantization delta.
+
+ Returns:
+ True if the two transducers satisfy the above condition, else False.
+
+ See also: `equal`, `equivalent`, `randequivalent`.
+ """
+ return fst.Isomorphic(deref(ifst1._fst), deref(ifst2._fst), delta)
+
+
+cpdef _MutableFst prune(_Fst ifst,
+ float delta=fst.kDelta,
+ int64 nstate=fst.kNoStateId,
+ weight=None):
+ """
+ prune(ifst, delta=0.0009765625, nstate=-1, weight=None)
+
+ Constructively removes paths with weights below a certain threshold.
+
+ This operation deletes states and arcs in the input FST that do not belong
+ to a successful path whose weight is no more (w.r.t the natural semiring
+ order) than the threshold t \otimes-times the weight of the shortest path in
+ the input FST. Weights must be commutative and have the path property.
+
+ Args:
+ ifst: The input FST.
+ delta: Comparison/quantization delta.
+ nstate: State number threshold.
+ weight: A Weight or weight string indicating the desired weight threshold
+ below which paths are pruned; if omitted, no paths are pruned.
+
+ Returns:
+ A pruned FST.
+
+ See also: The destructive variant.
+ """
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ fst.Prune(deref(ifst._fst), tfst, wc, nstate, delta)
+ return _init_MutableFst(tfst)
+
+
+cpdef _MutableFst push(_Fst ifst,
+ float delta=fst.kDelta,
+ bool push_weights=False,
+ bool push_labels=False,
+ bool remove_common_affix=False,
+ bool remove_total_weight=False,
+ bool to_final=False):
+ """
+ push(ifst, delta=0.0009765625, push_weights=False, push_labels=False,
+ remove_common_affix=False, remove_total_weight=False, to_final=False)
+
+ Constructively pushes weights/labels towards initial or final states.
+
+ This operation produces an equivalent transducer by pushing the weights
+ and/or the labels towards the initial state or toward the final states.
+
+ When pushing weights towards the initial state, the sum of the weight of the
+ outgoing transitions and final weight at any non-initial state is equal to 1
+ in the resulting machine. When pushing weights towards the final states, the
+ sum of the weight of the incoming transitions at any state is equal to 1.
+ Weights need to be left distributive when pushing towards the initial state
+ and right distributive when pushing towards the final states.
+
+ Pushing labels towards the initial state consists in minimizing at every
+ state the length of the longest common prefix of the output labels of the
+ outgoing paths. Pushing labels towards the final states consists in
+ minimizing at every state the length of the longest common suffix of the
+ output labels of the incoming paths.
+
+ Args:
+ ifst: The input FST.
+ delta: Comparison/quantization delta.
+ push_weights: Should weights be pushed?
+ push_labels: Should labels be pushed?
+ remove_common_affix: If pushing labels, should common prefix/suffix be
+ removed?
+ remove_total_weight: If pushing weights, should total weight be removed?
+ to_final: Push towards final states?
+
+ Returns:
+ An equivalent pushed FST.
+
+ See also: The destructive variant.
+ """
+ # This is copied, almost verbatim, from ./fstpush.cc.
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ cdef uint32 flags = fst.GetPushFlags(push_weights, push_labels,
+ remove_common_affix, remove_total_weight)
+ fst.Push(deref(ifst._fst), tfst, flags, fst.GetReweightType(to_final), delta)
+ return _init_MutableFst(tfst)
+
+
+cpdef bool randequivalent(_Fst ifst1,
+ _Fst ifst2,
+ int32 npath=1,
+ float delta=fst.kDelta,
+ time_t seed=0,
+ select=b"uniform",
+ int32 max_length=INT32_MAX) except *:
+ """
+ randequivalent(ifst1, ifst2, npath=1, delta=0.0009765625, seed=0,
+ select="uniform", max_length=2147483647)
+
+ Are two acceptors stochastically equivalent?
+
+ This operation tests whether two FSTs are equivalent by randomly generating
+ paths alternatively in each of the two FSTs. For each randomly generated path,
+ the algorithm computes for each of the two FSTs the sum of the weights of all
+ the successful paths sharing the same input and output labels as the randomly
+ generated path and checks that these two values are within `delta`.
+
+ Args:
+ ifst1: The first input FST.
+ ifst2: The second input FST.
+ npath: The number of random paths to generate.
+ delta: Comparison/quantization delta.
+ seed: An optional seed value for random path generation; if zero, the
+ current time and process ID is used.
+ select: A string matching a known random arc selection type; one of:
+ "uniform", "log_prob", "fast_log_prob".
+ max_length: The maximum length of each random path.
+
+ Returns:
+ True if the two transducers satisfy the above condition, else False.
+
+ Raise:
+ FstOpError: Random equivalence test encountered error.
+
+ See also: `equal`, `equivalent`, `isomorphic`, `randgen`.
+ """
+ cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select))
+ cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts
+ # The three trailing options will be ignored by RandEquivalent.
+ opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length,
+ 1, False, False))
+ if seed == 0:
+ seed = time(NULL) + getpid()
+ cdef bool error
+ cdef bool result = fst.RandEquivalent(deref(ifst1._fst), deref(ifst2._fst),
+ npath, delta, seed, deref(opts),
+ addr(error))
+ if error:
+ raise FstOpError("Random equivalence test encountered error")
+ return result
+
+
+cpdef _MutableFst randgen(_Fst ifst,
+ int32 npath=1,
+ time_t seed=0,
+ select=b"uniform",
+ int32 max_length=INT32_MAX,
+ bool weighted=False,
+ bool remove_total_weight=False):
+ """
+ randgen(ifst, npath=1, seed=0, select="uniform", max_length=2147483647,
+ weight=False, remove_total_weight=False)
+
+ Randomly generate successful paths in an FST.
+
+ This operation randomly generates a set of successful paths in the input FST.
+ This relies on a mechanism for selecting arcs, specified using the `select`
+ argument. The default selector, "uniform", randomly selects a transition
+ using a uniform distribution. The "log_prob" selector randomly selects a
+ transition w.r.t. the weights treated as negative log probabilities after
+ normalizing for the total weight leaving the state. In all cases, finality is
+ treated as a transition to a super-final state.
+
+ Args:
+ ifst: The input FST.
+ npath: The number of random paths to generate.
+ seed: An optional seed value for random path generation; if zero, the
+ current time and process ID is used.
+ select: A string matching a known random arc selection type; one of:
+ "uniform", "log_prob", "fast_log_prob".
+ max_length: The maximum length of each random path.
+ weighted: Should the output be weighted by path count?
+ remove_total_weight: Should the total weight be removed (ignored when
+ `weighted` is False)?
+
+ Returns:
+ An Fst containing one or more random paths.
+
+ See also: `randequivalent`.
+ """
+ cdef fst.RandArcSelection ras = _get_rand_arc_selection(tostring(select))
+ cdef unique_ptr[fst.RandGenOptions[fst.RandArcSelection]] opts
+ opts.reset(new fst.RandGenOptions[fst.RandArcSelection](ras, max_length,
+ npath, weighted,
+ remove_total_weight))
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ if seed == 0:
+ seed = time(NULL) + getpid()
+ fst.RandGen(deref(ifst._fst), tfst, seed, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+cpdef _MutableFst replace(pairs,
+ call_arc_labeling=b"input",
+ return_arc_labeling=b"neither",
+ bool epsilon_on_replace=False,
+ int64 return_label=0):
+ """
+ replace(pairs, call_arc_labeling="input", return_arc_labeling="neither",
+ epsilon_on_replace=False, return_label=0)
+
+ Recursively replaces arcs in the FST with other FST(s).
+
+ This operation performs the dynamic replacement of arcs in one FST with
+ another FST, allowing the definition of FSTs analogous to RTNs. It takes as
+ input a set of pairs of a set of pairs formed by a non-terminal label and
+ its corresponding FST, and a label identifying the root FST in that set.
+ The resulting FST is obtained by taking the root FST and recursively replacing
+ each arc having a nonterminal as output label by its corresponding FST. More
+ precisely, an arc from state s to state d with (nonterminal) output label n in
+ this FST is replaced by redirecting this "call" arc to the initial state of a
+ copy F of the FST for n, and adding "return" arcs from each final state of F
+ to d. Optional arguments control how the call and return arcs are labeled; by
+ default, the only non-epsilon label is placed on the call arc.
+
+ Args:
+
+ pairs: An iterable of (nonterminal label, FST) pairs, where the former is an
+ unsigned integer and the latter is an Fst instance.
+ call_arc_labeling: A string indicating which call arc labels should be
+ non-epsilon. One of: "input" (default), "output", "both", "neither".
+ This value is set to "neither" if epsilon_on_replace is True.
+ return_arc_labeling: A string indicating which return arc labels should be
+ non-epsilon. One of: "input", "output", "both", "neither" (default).
+ This value is set to "neither" if epsilon_on_replace is True.
+ epsilon_on_replace: Should call and return arcs be epsilon arcs? If True,
+ this effectively overrides call_arc_labeling and return_arc_labeling,
+ setting both to "neither".
+ return_label: The integer label for return arcs.
+
+ Returns:
+ An FST resulting from expanding the input RTN.
+ """
+ cdef vector[fst.LabelFstClassPair] _pairs
+ cdef int64 root_label
+ cdef int64 label
+ cdef _Fst ifst
+ it = iter(pairs)
+ (root_label, ifst) = next(it)
+ _pairs.push_back(fst.LabelFstClassPair(root_label, ifst._fst.get()))
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ for (label, ifst) in it:
+ _pairs.push_back(fst.LabelFstClassPair(label, ifst._fst.get()))
+ cdef fst.ReplaceLabelType cal = _get_replace_label_type(
+ tostring(call_arc_labeling), epsilon_on_replace)
+ cdef fst.ReplaceLabelType ral = _get_replace_label_type(
+ tostring(return_arc_labeling), epsilon_on_replace)
+ cdef unique_ptr[fst.ReplaceOptions] opts
+ opts.reset(new fst.ReplaceOptions(root_label, cal, ral, return_label))
+ fst.Replace(_pairs, tfst, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+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 VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ fst.Reverse(deref(ifst._fst), tfst, require_superinitial)
+ return _init_MutableFst(tfst)
+
+
+cpdef _MutableFst rmepsilon(_Fst ifst,
+ bool connect=True,
+ float delta=fst.kDelta,
+ int64 nstate=fst.kNoStateId,
+ qt=b"auto",
+ bool reverse=False,
+ weight=None):
+ """
+ rmepsilon(ifst, connect=True, delta=0.0009765625, nstate=-1, qt="auto",
+ reverse=False, weight=None)
+
+ Constructively removes epsilon transitions from an FST.
+
+ This operation removes epsilon transitions (those where both input and output
+ labels are epsilon) from an FST.
+
+ Args:
+ ifst: The input FST.
+ connect: Should output be trimmed?
+ delta: Comparison/quantization delta.
+ nstate: State number threshold.
+ qt: A string matching a known queue type; one of: "auto", "fifo", "lifo",
+ "shortest", "state", "top".
+ reverse: Should epsilon transitions be removed in reverse order?
+ weight: A string indicating the desired weight threshold; paths with
+ weights below this threshold will be pruned.
+
+ Returns:
+ An equivalent FST with no epsilon transitions.
+ """
+ cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ cdef unique_ptr[fst.RmEpsilonOptions] opts
+ opts.reset(new fst.RmEpsilonOptions(_get_queue_type(tostring(qt)), delta,
+ connect, wc, nstate))
+ cdef VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ fst.RmEpsilon(deref(ifst._fst), tfst, reverse, deref(opts))
+ return _init_MutableFst(tfst)
+
+
+# Pure C++ helper for shortestdistance.
+
+
+cdef vector[fst.WeightClass] *_shortestdistance(_Fst ifst,
+ float delta=fst.kDelta, int64 nstate=fst.kNoStateId, qt=b"auto",
+ bool reverse=False) except *:
+ cdef vector[fst.WeightClass] *distance = new vector[fst.WeightClass]()
+ # For scoping reasons, these have to be declared here even though they may
+ # not be used in all cases.
+ cdef unique_ptr[fst.ShortestDistanceOptions] opts
+ if reverse:
+ # Only the simpler signature supports shortest distance to final states;
+ # `nstate` and `qt` arguments are ignored.
+ fst.ShortestDistance(deref(ifst._fst), distance, True, delta)
+ else:
+ opts.reset(new fst.ShortestDistanceOptions(
+ _get_queue_type(tostring(qt)), fst.ANY_ARC_FILTER, nstate, delta))
+ fst.ShortestDistance(deref(ifst._fst), distance, deref(opts))
+ return distance
+
+
+def shortestdistance(_Fst ifst,
+ float delta=fst.kDelta,
+ int64 nstate=fst.kNoStateId,
+ qt=b"auto",
+ bool reverse=False):
+ """
+ shortestdistance(ifst, delta=0.0009765625, nstate=-1, qt="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 (this is ignored if `reverse` is True).
+ qt: A string matching a known queue type; one of: "auto", "fifo", "lifo",
+ "shortest", "state", "top" (this is ignored if `reverse` is True).
+ reverse: Should the reverse distance (from each state to the final state)
+ be computed?
+
+ Returns:
+ A list of Weight objects representing the shortest distance for each state.
+ """
+ cdef unique_ptr[vector[fst.WeightClass]] distance
+ distance.reset(_shortestdistance(ifst, delta, nstate, qt, reverse))
+ # Packs the distances, as strings, into a Python list.
+ cdef string weight_type = ifst.weight_type()
+ result = []
+ # This is just the Cython version of the normal vector iteration idiom.
+ cdef vector[fst.WeightClass].iterator it = distance.get().begin()
+ while it != distance.get().end():
+ result.append(Weight(weight_type, deref(it).ToString()))
+ inc(it)
+ return result
+
+
+cpdef _MutableFst shortestpath(_Fst ifst,
+ float delta=fst.kDelta,
+ int32 nshortest=1,
+ int64 nstate=fst.kNoStateId,
+ qt=b"auto",
+ bool unique=False,
+ weight=None):
+ """
+ shortestpath(ifst, delta=0.0009765625, nshortest=1, nstate=-1, qt="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.
+ qt: 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 VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ cdef unique_ptr[vector[fst.WeightClass]] distance
+ distance.reset(new vector[fst.WeightClass]())
+ # Threshold is set to semiring Zero (no pruning) if no weight is specified.
+ cdef fst.WeightClass wc = _get_WeightClass_or_Zero(ifst.weight_type(), weight)
+ cdef unique_ptr[fst.ShortestPathOptions] opts
+ opts.reset(new fst.ShortestPathOptions(_get_queue_type(tostring(qt)),
+ nshortest, unique, False, delta,
+ False, wc, nstate))
+ fst.ShortestPath(deref(ifst._fst), tfst, distance.get(), deref(opts))
+ return _init_MutableFst(tfst)
+
+
+cpdef _Fst statemap(_Fst ifst, mt):
+ """
+ state_map(ifst, map_type)
+
+ Constructively applies a transform to all states.
+
+ This operation transforms each state according to the requested map type.
+ Note that currently, only one state-mapping operation is supported.
+
+ Args:
+ ifst: The input FST.
+ mt: A string matching a known mapping operation; one of: "arc_sum" (sum
+ weights of identically-labeled multi-arcs), "arc_unique" (deletes
+ non-unique identically-labeled multi-arcs).
+
+ Returns:
+ An FST with states remapped.
+
+ Raises:
+ FstArgError: Unknown map type.
+
+ See also: `arcmap`.
+ """
+ return _map(ifst, fst.kDelta, mt, 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 VectorFstClass_ptr tfst = new fst.VectorFstClass(ifst.arc_type())
+ fst.Synchronize(deref(ifst._fst), tfst)
+ return _init_MutableFst(tfst)
+
+
+## Compiler.
+
+
+cdef class Compiler(object):
+
+ """
+ Compiler(fst_type="vector", arc_type="standard", isymbols=None,
+ osymbols=None, ssymbols=None, acceptor=False, keep_isymbols=False,
+ keep_osymbols=False, keep_state_numbering=False,
+ allow_negative_labels=False)
+
+ Class used to compile FSTs from strings.
+
+ This class is used to compile FSTs specified using the AT&T FSM library
+ format described here:
+
+ http://web.eecs.umich.edu/~radev/NLP-fall2015/resources/fsm_archive/fsm.5.html
+
+ This is the same format used by the `fstcompile` executable.
+
+ Compiler options (symbol tables, etc.) are set at construction time.
+
+ compiler = fst.Compiler(isymbols=ascii_syms, osymbols=ascii_syms)
+
+ Once constructed, Compiler instances behave like a file handle opened for
+ writing:
+
+ # /ba+/
+ print >> compiler, "0 1 50 50"
+ print >> compiler, "1 2 49 49"
+ print >> compiler, "2 2 49 49"
+ print >> compiler, "2"
+
+ The `compile` method returns an actual FST instance:
+
+ sheep_machine = compiler.compile()
+
+ Compilation flushes the internal buffer, so the compiler instance can be
+ reused to compile new machines with the same symbol tables (etc.)
+
+ Args:
+ fst_type: A string indicating the container type for the compiled FST.
+ arc_type: A string indicating the arc type for the compiled FST.
+ isymbols: An optional SymbolTable used to label input symbols.
+ osymbols: An optional SymbolTable used to label output symbols.
+ ssymbols: An optional SymbolTable used to label states.
+ acceptor: Should the FST be rendered in acceptor format if possible?
+ keep_isymbols: Should the input symbol table be stored in the FST?
+ keep_osymbols: Should the output symbol table be stored in the FST?
+ keep_state_numbering: Should the state numbering be preserved?
+ allow_negative_labels: Should negative labels be allowed? (Not
+ recommended; may cause conflicts).
+ """
+
+ def __cinit__(self,
+ string fst_type=b"vector",
+ string arc_type=b"standard",
+ SymbolTable isymbols=None,
+ SymbolTable osymbols=None,
+ SymbolTable ssymbols=None,
+ bool acceptor=False,
+ bool keep_isymbols=False,
+ bool keep_osymbols=False,
+ bool keep_state_numbering=False,
+ bool allow_negative_labels=False):
+ self._sstrm.reset(new stringstream())
+ self._fst_type = tostring(fst_type)
+ self._arc_type = tostring(arc_type)
+ self._isymbols = NULL
+ if isymbols is not None:
+ self._isymbols = isymbols._table
+ self._osymbols = NULL
+ if osymbols is not None:
+ self._osymbols = osymbols._table
+ self._ssymbols = NULL
+ if ssymbols is not None:
+ self._ssymbols = ssymbols._table
+ self._acceptor = acceptor
+ self._keep_isymbols = keep_isymbols
+ self._keep_osymbols = keep_osymbols
+ self._keep_state_numbering = keep_state_numbering
+ self._allow_negative_labels = allow_negative_labels
+
+ cpdef _Fst compile(self):
+ """
+ compile()
+
+ Compiles the FST in the compiler string buffer.
+
+ This method compiles the FST and returns the resulting machine.
+
+ Returns:
+ The FST described by the compiler string buffer.
+
+ Raises:
+ FstOpError: Compilation failed.
+ """
+ cdef fst.FstClass *tfst = fst.CompileFstInternal(deref(self._sstrm),
+ "<pywrapfst>", 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 == NULL:
+ raise FstOpError("Compilation failed")
+ return _init_XFst(tfst)
+
+ cpdef void write(self, expression):
+ """
+ write(expression)
+
+ Writes a string into the compiler string buffer.
+
+ This method adds a line to the compiler string buffer. It is normally
+ invoked using the right shift operator, like so:
+
+ compiler = fst.Compiler()
+ print >> compiler, "0 0 49 49"
+ print >> compiler, "0"
+
+ Args:
+ expression: A string expression to add to compiler string buffer.
+ """
+ deref(self._sstrm) << tostring(expression)
+
+
+## FarReader and FarWriter.
+
+
+cdef class FarReader(object):
+
+ """
+ (No constructor.)
+
+ FAR ("Fst ARchive") reader object.
+
+ This class is used to read a FAR from disk. FARs contain one or more FSTs (of
+ the same arc type) indexed by a unique string key. To construct a FarReader
+ object, use the `open` class method. FSTs can be accessed from a FAR using the
+ familiar C++ API methods, but a user who wishes to access all FSTs in random
+ order should simply place a FarReader in an iteration context and take
+ advantage of the Pythonic API that provides.
+
+ Attributes:
+ arc_type: A string indicating the arc type.
+ far_type: A string indicating the FAR type.
+ """
+
+ def __init__(self):
+ raise FstDeletedConstructorError(
+ "Cannot construct {}".format(self.__class__.__name__))
+
+ def __repr__(self):
+ return "<{} FarReader at 0x{:x}>".format(self.far_type(), id(self))
+
+ @classmethod
+ def open(cls, *filenames):
+ """
+ FarReader.open(*filenames)
+
+ Creates a FarReader object.
+
+ This class method creates a FarReader given the string location of one or
+ more FAR files on disk.
+
+ Args:
+ *filenames: The string location of one or more input FAR files.
+
+ Returns:
+ A new FarReader instance.
+
+ Raises:
+ FstIOError: Read failed.
+ """
+ filenames = [tostring(filename) for filename in filenames]
+ cdef fst.FarReaderClass *tfar = fst.FarReaderClass.Open(filenames)
+ if tfar == NULL:
+ raise FstIOError("Read failed: {!r}".format(filenames))
+ cdef FarReader result = FarReader.__new__(FarReader)
+ result._reader.reset(tfar)
+ return result
+
+ # 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 string k = self.get_key()
+ cdef _MutableFst f = self.get_fst()
+ self.next()
+ return (k, f)
+
+ cpdef string arc_type(self):
+ return self._reader.get().ArcType()
+
+ cpdef bool done(self):
+ """
+ done(self)
+
+ Indicates whether the iterator is exhausted or not.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ 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.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ 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.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ A copy of the FST at the current position.
+ """
+ cdef fst.FstClass *tfst = new fst.FstClass(
+ deref(self._reader.get().GetFstClass()))
+ return _init_XFst(tfst)
+
+ cpdef string get_key(self):
+ """
+ get_key(self)
+
+ Returns the string key at the current position.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Returns:
+ The string key at the current position.
+ """
+ return self._reader.get().GetKey()
+
+ cpdef void next(self):
+ """
+ next(self)
+
+ Advances the iterator.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._reader.get().Next()
+
+ cpdef void reset(self):
+ """
+ reset(self)
+
+ Resets the iterator to the initial position.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+ """
+ self._reader.get().Reset()
+
+ # Dictionary-like access by combining `find` and `get_fst`.
+ def __getitem__(self, key):
+ if not self.find(key):
+ raise KeyError(key)
+ return self.get_fst()
+
+
+cdef class FarWriter(object):
+
+ """
+ (No constructor.)
+
+ FAR ("Fst ARchive") writer object.
+
+ This class is used to write FSTs (of the same arc type) to a FAR on disk. To
+ construct a FarWriter, use the `create` class method.
+
+ Note that the data is not guaranteed to flush to disk until the FarWriter
+ is garbage-collected. If a FarWriter has been assigned to only one variable,
+ then calling `del` on that variable should decrement the object's reference
+ count from 1 to 0, triggering a flush to disk on the next GC cycle.
+
+ Attributes:
+ arc_type: A string indicating the arc type.
+ far_type: A string indicating the FAR type.
+ """
+
+ def __init__(self):
+ raise FstDeletedConstructorError(
+ "Cannot construct {}".format(self.__class__.__name__))
+
+ def __repr__(self):
+ return "<{} FarWriter at 0x{:x}>".format(self.far_type(), id(self))
+
+ @classmethod
+ def create(cls, filename, arc_type=b"standard", far_type=b"default"):
+ """
+ FarWriter.
+
+ Creates a FarWriter object.
+
+ This class method creates a FarWriter given the desired output location,
+ arc type, and FAR type.
+
+ Args:
+ filename: The string location for the output FAR files.
+ arc_type: A string indicating the arc type.
+ far_type: A string indicating the FAR type; one of: "fst", "stlist",
+ "sttable", "sstable", "default".
+
+ Returns:
+ A new FarWriter instance.
+
+ Raises:
+ FstIOError: Read failed.
+ """
+ cdef fst.FarType ft = fst.GetFarType(tostring(far_type))
+ cdef fst.FarWriterClass *tfar = fst.FarWriterClass.Create(
+ tostring(filename), tostring(arc_type), ft)
+ if tfar == NULL:
+ raise FstIOError("Open failed: {!r}".format(filename))
+ cdef FarWriter result = FarWriter.__new__(FarWriter)
+ result._writer.reset(tfar)
+ return result
+
+ # NB: Invoking this method is 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.
+
+ This method is provided for compatibility with the C++ API only; most users
+ should use the Pythonic API.
+
+ Args:
+ key: The string used to key the input FST.
+ ifst: The FST to write to the FAR.
+
+ Raises:
+ FstArgError: Key out of order.
+ FstOpError: Incompatible or invalid arc type.
+ """
+ # Failure here results from passing an FST with a different arc type than
+ # used by the FAR was initialized to use.
+ if not self._writer.get().Add(tostring(key), deref(ifst._fst)):
+ raise FstOpError("Incompatible or invalid arc type")
+ # An error here usually indicates a key out of order.
+ if self._writer.get().Error():
+ raise FstArgError("Key out of order")
+
+ cpdef string arc_type(self):
+ 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):
+ return fst.GetFarTypeString(self._writer.get().Type())
+
+ # Dictionary-like assignment.
+ def __setitem__(self, key, _Fst fst):
+ self.add(key, fst)
+
+
+## Cleanup operations for module entrance and exit.
+
+
+# Masks fst_error_fatal flags while this module is running, returning to the
+# previous state upon module exit.
+
+
+_fst_error_fatal_old = fst.FLAGS_fst_error_fatal
+fst.FLAGS_fst_error_fatal = False
+
+
+@atexit.register
+def _reset_fst_error_fatal():
+ fst.FLAGS_fst_error_fatal = _fst_error_fatal_old
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+
+if HAVE_BIN
+bin_PROGRAMS = fstspecial
+
+LDADD = ../../script/libfstscript.la \
+ ../../lib/libfst.la -lm $(DL_LIBS)
+
+fstspecial_SOURCES = ../../bin/fstconvert.cc phi-fst.cc rho-fst.cc sigma-fst.cc
+fstspecial_CPPFLAGS = $(AM_CPPFLAGS)
+endif
+
+libfstdir = @libfstdir@
+libfst_LTLIBRARIES = phi-fst.la rho-fst.la sigma-fst.la
+
+lib_LTLIBRARIES = libfstspecial.la
+
+libfstspecial_la_SOURCES = phi-fst.cc rho-fst.cc sigma-fst.cc
+libfstspecial_la_LDFLAGS = -version-info 6:0:0 -lm $(DL_LIBS)
+libfstspecial_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+
+phi_fst_la_SOURCES = phi-fst.cc
+phi_fst_la_LDFLAGS = -module
+
+rho_fst_la_SOURCES = rho-fst.cc
+rho_fst_la_LDFLAGS = -module
+
+sigma_fst_la_SOURCES = sigma-fst.cc
+sigma_fst_la_LDFLAGS = -module
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+@HAVE_BIN_TRUE@bin_PROGRAMS = fstspecial$(EXEEXT)
+subdir = src/extensions/special
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" \
+ "$(DESTDIR)$(bindir)"
+LTLIBRARIES = $(lib_LTLIBRARIES) $(libfst_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+libfstspecial_la_DEPENDENCIES = ../../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+am_libfstspecial_la_OBJECTS = phi-fst.lo rho-fst.lo sigma-fst.lo
+libfstspecial_la_OBJECTS = $(am_libfstspecial_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstspecial_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstspecial_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+phi_fst_la_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 $@
+PROGRAMS = $(bin_PROGRAMS)
+am__fstspecial_SOURCES_DIST = ../../bin/fstconvert.cc phi-fst.cc \
+ rho-fst.cc sigma-fst.cc
+am__dirstamp = $(am__leading_dot)dirstamp
+@HAVE_BIN_TRUE@am_fstspecial_OBJECTS = \
+@HAVE_BIN_TRUE@ ../../bin/fstspecial-fstconvert.$(OBJEXT) \
+@HAVE_BIN_TRUE@ fstspecial-phi-fst.$(OBJEXT) \
+@HAVE_BIN_TRUE@ fstspecial-rho-fst.$(OBJEXT) \
+@HAVE_BIN_TRUE@ fstspecial-sigma-fst.$(OBJEXT)
+fstspecial_OBJECTS = $(am_fstspecial_OBJECTS)
+fstspecial_LDADD = $(LDADD)
+@HAVE_BIN_TRUE@fstspecial_DEPENDENCIES = ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstspecial_la_SOURCES) $(phi_fst_la_SOURCES) \
+ $(rho_fst_la_SOURCES) $(sigma_fst_la_SOURCES) \
+ $(fstspecial_SOURCES)
+DIST_SOURCES = $(libfstspecial_la_SOURCES) $(phi_fst_la_SOURCES) \
+ $(rho_fst_la_SOURCES) $(sigma_fst_la_SOURCES) \
+ $(am__fstspecial_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../../include $(ICU_CPPFLAGS)
+@HAVE_BIN_TRUE@LDADD = ../../script/libfstscript.la \
+@HAVE_BIN_TRUE@ ../../lib/libfst.la -lm $(DL_LIBS)
+
+@HAVE_BIN_TRUE@fstspecial_SOURCES = ../../bin/fstconvert.cc phi-fst.cc rho-fst.cc sigma-fst.cc
+@HAVE_BIN_TRUE@fstspecial_CPPFLAGS = $(AM_CPPFLAGS)
+libfst_LTLIBRARIES = phi-fst.la rho-fst.la sigma-fst.la
+lib_LTLIBRARIES = libfstspecial.la
+libfstspecial_la_SOURCES = phi-fst.cc rho-fst.cc sigma-fst.cc
+libfstspecial_la_LDFLAGS = -version-info 6:0:0 -lm $(DL_LIBS)
+libfstspecial_la_LIBADD = ../../lib/libfst.la -lm $(DL_LIBS)
+phi_fst_la_SOURCES = phi-fst.cc
+phi_fst_la_LDFLAGS = -module
+rho_fst_la_SOURCES = rho-fst.cc
+rho_fst_la_LDFLAGS = -module
+sigma_fst_la_SOURCES = sigma-fst.cc
+sigma_fst_la_LDFLAGS = -module
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/extensions/special/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/extensions/special/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+install-libfstLTLIBRARIES: $(libfst_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libfstdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libfstdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libfstdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libfstdir)"; \
+ }
+
+uninstall-libfstLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(libfst_LTLIBRARIES)'; test -n "$(libfstdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libfstdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libfstdir)/$$f"; \
+ done
+
+clean-libfstLTLIBRARIES:
+ -test -z "$(libfst_LTLIBRARIES)" || rm -f $(libfst_LTLIBRARIES)
+ @list='$(libfst_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstspecial.la: $(libfstspecial_la_OBJECTS) $(libfstspecial_la_DEPENDENCIES) $(EXTRA_libfstspecial_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstspecial_la_LINK) -rpath $(libdir) $(libfstspecial_la_OBJECTS) $(libfstspecial_la_LIBADD) $(LIBS)
+
+phi-fst.la: $(phi_fst_la_OBJECTS) $(phi_fst_la_DEPENDENCIES) $(EXTRA_phi_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(phi_fst_la_LINK) -rpath $(libfstdir) $(phi_fst_la_OBJECTS) $(phi_fst_la_LIBADD) $(LIBS)
+
+rho-fst.la: $(rho_fst_la_OBJECTS) $(rho_fst_la_DEPENDENCIES) $(EXTRA_rho_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(rho_fst_la_LINK) -rpath $(libfstdir) $(rho_fst_la_OBJECTS) $(rho_fst_la_LIBADD) $(LIBS)
+
+sigma-fst.la: $(sigma_fst_la_OBJECTS) $(sigma_fst_la_DEPENDENCIES) $(EXTRA_sigma_fst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(sigma_fst_la_LINK) -rpath $(libfstdir) $(sigma_fst_la_OBJECTS) $(sigma_fst_la_LIBADD) $(LIBS)
+install-binPROGRAMS: $(bin_PROGRAMS)
+ @$(NORMAL_INSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
+ fi; \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed 's/$(EXEEXT)$$//' | \
+ while read p p1; do if test -f $$p \
+ || test -f $$p1 \
+ ; then echo "$$p"; echo "$$p"; else :; fi; \
+ done | \
+ sed -e 'p;s,.*/,,;n;h' \
+ -e 's|.*|.|' \
+ -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+ sed 'N;N;N;s,\n, ,g' | \
+ $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+ { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+ if ($$2 == $$4) files[d] = files[d] " " $$1; \
+ else { print "f", $$3 "/" $$4, $$1; } } \
+ END { for (d in files) print "f", d, files[d] }' | \
+ while read type dir files; do \
+ if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+ test -z "$$files" || { \
+ echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+ $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+ } \
+ ; done
+
+uninstall-binPROGRAMS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+ files=`for p in $$list; do echo "$$p"; done | \
+ sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+ -e 's/$$/$(EXEEXT)/' \
+ `; \
+ test -n "$$list" || exit 0; \
+ echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+ cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+ @list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+../../bin/$(am__dirstamp):
+ @$(MKDIR_P) ../../bin
+ @: > ../../bin/$(am__dirstamp)
+../../bin/$(DEPDIR)/$(am__dirstamp):
+ @$(MKDIR_P) ../../bin/$(DEPDIR)
+ @: > ../../bin/$(DEPDIR)/$(am__dirstamp)
+../../bin/fstspecial-fstconvert.$(OBJEXT): ../../bin/$(am__dirstamp) \
+ ../../bin/$(DEPDIR)/$(am__dirstamp)
+
+fstspecial$(EXEEXT): $(fstspecial_OBJECTS) $(fstspecial_DEPENDENCIES) $(EXTRA_fstspecial_DEPENDENCIES)
+ @rm -f fstspecial$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fstspecial_OBJECTS) $(fstspecial_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+ -rm -f ../../bin/*.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@../../bin/$(DEPDIR)/fstspecial-fstconvert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-phi-fst.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-rho-fst.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fstspecial-sigma-fst.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/phi-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rho-fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sigma-fst.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+../../bin/fstspecial-fstconvert.o: ../../bin/fstconvert.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ../../bin/fstspecial-fstconvert.o -MD -MP -MF ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo -c -o ../../bin/fstspecial-fstconvert.o `test -f '../../bin/fstconvert.cc' || echo '$(srcdir)/'`../../bin/fstconvert.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo ../../bin/$(DEPDIR)/fstspecial-fstconvert.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../../bin/fstconvert.cc' object='../../bin/fstspecial-fstconvert.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ../../bin/fstspecial-fstconvert.o `test -f '../../bin/fstconvert.cc' || echo '$(srcdir)/'`../../bin/fstconvert.cc
+
+../../bin/fstspecial-fstconvert.obj: ../../bin/fstconvert.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT ../../bin/fstspecial-fstconvert.obj -MD -MP -MF ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo -c -o ../../bin/fstspecial-fstconvert.obj `if test -f '../../bin/fstconvert.cc'; then $(CYGPATH_W) '../../bin/fstconvert.cc'; else $(CYGPATH_W) '$(srcdir)/../../bin/fstconvert.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) ../../bin/$(DEPDIR)/fstspecial-fstconvert.Tpo ../../bin/$(DEPDIR)/fstspecial-fstconvert.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='../../bin/fstconvert.cc' object='../../bin/fstspecial-fstconvert.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o ../../bin/fstspecial-fstconvert.obj `if test -f '../../bin/fstconvert.cc'; then $(CYGPATH_W) '../../bin/fstconvert.cc'; else $(CYGPATH_W) '$(srcdir)/../../bin/fstconvert.cc'; fi`
+
+fstspecial-phi-fst.o: phi-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-phi-fst.o -MD -MP -MF $(DEPDIR)/fstspecial-phi-fst.Tpo -c -o fstspecial-phi-fst.o `test -f 'phi-fst.cc' || echo '$(srcdir)/'`phi-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-phi-fst.Tpo $(DEPDIR)/fstspecial-phi-fst.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='phi-fst.cc' object='fstspecial-phi-fst.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-phi-fst.o `test -f 'phi-fst.cc' || echo '$(srcdir)/'`phi-fst.cc
+
+fstspecial-phi-fst.obj: phi-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-phi-fst.obj -MD -MP -MF $(DEPDIR)/fstspecial-phi-fst.Tpo -c -o fstspecial-phi-fst.obj `if test -f 'phi-fst.cc'; then $(CYGPATH_W) 'phi-fst.cc'; else $(CYGPATH_W) '$(srcdir)/phi-fst.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-phi-fst.Tpo $(DEPDIR)/fstspecial-phi-fst.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='phi-fst.cc' object='fstspecial-phi-fst.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-phi-fst.obj `if test -f 'phi-fst.cc'; then $(CYGPATH_W) 'phi-fst.cc'; else $(CYGPATH_W) '$(srcdir)/phi-fst.cc'; fi`
+
+fstspecial-rho-fst.o: rho-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-rho-fst.o -MD -MP -MF $(DEPDIR)/fstspecial-rho-fst.Tpo -c -o fstspecial-rho-fst.o `test -f 'rho-fst.cc' || echo '$(srcdir)/'`rho-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-rho-fst.Tpo $(DEPDIR)/fstspecial-rho-fst.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='rho-fst.cc' object='fstspecial-rho-fst.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-rho-fst.o `test -f 'rho-fst.cc' || echo '$(srcdir)/'`rho-fst.cc
+
+fstspecial-rho-fst.obj: rho-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-rho-fst.obj -MD -MP -MF $(DEPDIR)/fstspecial-rho-fst.Tpo -c -o fstspecial-rho-fst.obj `if test -f 'rho-fst.cc'; then $(CYGPATH_W) 'rho-fst.cc'; else $(CYGPATH_W) '$(srcdir)/rho-fst.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-rho-fst.Tpo $(DEPDIR)/fstspecial-rho-fst.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='rho-fst.cc' object='fstspecial-rho-fst.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-rho-fst.obj `if test -f 'rho-fst.cc'; then $(CYGPATH_W) 'rho-fst.cc'; else $(CYGPATH_W) '$(srcdir)/rho-fst.cc'; fi`
+
+fstspecial-sigma-fst.o: sigma-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-sigma-fst.o -MD -MP -MF $(DEPDIR)/fstspecial-sigma-fst.Tpo -c -o fstspecial-sigma-fst.o `test -f 'sigma-fst.cc' || echo '$(srcdir)/'`sigma-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-sigma-fst.Tpo $(DEPDIR)/fstspecial-sigma-fst.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='sigma-fst.cc' object='fstspecial-sigma-fst.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-sigma-fst.o `test -f 'sigma-fst.cc' || echo '$(srcdir)/'`sigma-fst.cc
+
+fstspecial-sigma-fst.obj: sigma-fst.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT fstspecial-sigma-fst.obj -MD -MP -MF $(DEPDIR)/fstspecial-sigma-fst.Tpo -c -o fstspecial-sigma-fst.obj `if test -f 'sigma-fst.cc'; then $(CYGPATH_W) 'sigma-fst.cc'; else $(CYGPATH_W) '$(srcdir)/sigma-fst.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/fstspecial-sigma-fst.Tpo $(DEPDIR)/fstspecial-sigma-fst.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='sigma-fst.cc' object='fstspecial-sigma-fst.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(fstspecial_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o fstspecial-sigma-fst.obj `if test -f 'sigma-fst.cc'; then $(CYGPATH_W) 'sigma-fst.cc'; else $(CYGPATH_W) '$(srcdir)/sigma-fst.cc'; fi`
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(PROGRAMS)
+install-binPROGRAMS: install-libLTLIBRARIES
+
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libfstdir)" "$(DESTDIR)$(bindir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+ -rm -f ../../bin/$(DEPDIR)/$(am__dirstamp)
+ -rm -f ../../bin/$(am__dirstamp)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libfstLTLIBRARIES clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ../../bin/$(DEPDIR) ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-libfstLTLIBRARIES
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ../../bin/$(DEPDIR) ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES \
+ uninstall-libfstLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+ clean-binPROGRAMS clean-generic clean-libLTLIBRARIES \
+ clean-libfstLTLIBRARIES clean-libtool cscopelist-am ctags \
+ ctags-am distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-binPROGRAMS \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-libLTLIBRARIES \
+ install-libfstLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-binPROGRAMS \
+ uninstall-libLTLIBRARIES uninstall-libfstLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/fst.h>
+#include <fst/extensions/special/phi-fst.h>
+
+DEFINE_int64(phi_fst_phi_label, 0,
+ "Label of transitions to be interpreted as phi ('failure') "
+ "transitions");
+DEFINE_bool(phi_fst_phi_loop, true,
+ "When true, a phi self loop consumes a symbol");
+DEFINE_string(phi_fst_rewrite_mode, "auto",
+ "Rewrite both sides when matching? One of:"
+ " \"auto\" (rewrite iff acceptor), \"always\", \"never\"");
+
+namespace fst {
+
+const char phi_fst_type[] = "phi";
+const char input_phi_fst_type[] = "input_phi";
+const char output_phi_fst_type[] = "output_phi";
+
+static FstRegisterer<StdPhiFst> PhiFst_StdArc_registerer;
+static FstRegisterer<LogPhiFst> PhiFst_LogArc_registerer;
+static FstRegisterer<Log64PhiFst> PhiFst_Log64Arc_registerer;
+
+static FstRegisterer<StdInputPhiFst> InputPhiFst_StdArc_registerer;
+static FstRegisterer<LogInputPhiFst> InputPhiFst_LogArc_registerer;
+static FstRegisterer<Log64InputPhiFst> InputPhiFst_Log64Arc_registerer;
+
+static FstRegisterer<StdOutputPhiFst> OutputPhiFst_StdArc_registerer;
+static FstRegisterer<LogOutputPhiFst> OutputPhiFst_LogArc_registerer;
+static FstRegisterer<Log64OutputPhiFst> OutputPhiFst_Log64Arc_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/special/rho-fst.h>
+
+#include <fst/fst.h>
+
+DEFINE_int64(rho_fst_rho_label, 0,
+ "Label of transitions to be interpreted as rho ('rest') "
+ "transitions");
+DEFINE_string(rho_fst_rewrite_mode, "auto",
+ "Rewrite both sides when matching? One of:"
+ " \"auto\" (rewrite iff acceptor), \"always\", \"never\"");
+
+namespace fst {
+
+const char rho_fst_type[] = "rho";
+const char input_rho_fst_type[] = "input_rho";
+const char output_rho_fst_type[] = "output_rho";
+
+static FstRegisterer<StdRhoFst> RhoFst_StdArc_registerer;
+static FstRegisterer<LogRhoFst> RhoFst_LogArc_registerer;
+static FstRegisterer<Log64RhoFst> RhoFst_Log64Arc_registerer;
+
+static FstRegisterer<StdInputRhoFst> InputRhoFst_StdArc_registerer;
+static FstRegisterer<LogInputRhoFst> InputRhoFst_LogArc_registerer;
+static FstRegisterer<Log64InputRhoFst> InputRhoFst_Log64Arc_registerer;
+
+static FstRegisterer<StdOutputRhoFst> OutputRhoFst_StdArc_registerer;
+static FstRegisterer<LogOutputRhoFst> OutputRhoFst_LogArc_registerer;
+static FstRegisterer<Log64OutputRhoFst> OutputRhoFst_Log64Arc_registerer;
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/extensions/special/sigma-fst.h>
+
+#include <fst/fst.h>
+
+DEFINE_int64(sigma_fst_sigma_label, 0,
+ "Label of transitions to be interpreted as sigma ('any') "
+ "transitions");
+DEFINE_string(sigma_fst_rewrite_mode, "auto",
+ "Rewrite both sides when matching? One of:"
+ " \"auto\" (rewrite iff acceptor), \"always\", \"never\"");
+
+namespace fst {
+
+const char sigma_fst_type[] = "sigma";
+const char input_sigma_fst_type[] = "input_sigma";
+const char output_sigma_fst_type[] = "output_sigma";
+
+static FstRegisterer<StdSigmaFst> SigmaFst_StdArc_registerer;
+static FstRegisterer<LogSigmaFst> SigmaFst_LogArc_registerer;
+static FstRegisterer<Log64SigmaFst> SigmaFst_Log64Arc_registerer;
+
+static FstRegisterer<StdInputSigmaFst> InputSigmaFst_StdArc_registerer;
+static FstRegisterer<LogInputSigmaFst> InputSigmaFst_LogArc_registerer;
+static FstRegisterer<Log64InputSigmaFst> InputSigmaFst_Log64Arc_registerer;
+
+static FstRegisterer<StdOutputSigmaFst> OutputSigmaFst_StdArc_registerer;
+static FstRegisterer<LogOutputSigmaFst> OutputSigmaFst_LogArc_registerer;
+static FstRegisterer<Log64OutputSigmaFst> OutputSigmaFst_Log64Arc_registerer;
+
+} // namespace fst
--- /dev/null
+if HAVE_COMPRESS
+compress_include_headers = fst/extensions/compress/compress.h \
+fst/extensions/compress/compress-script.h fst/extensions/compress/gzfile.h \
+fst/extensions/compress/elias.h fst/extensions/compress/randmod.h
+endif
+
+if HAVE_FAR
+far_include_headers = fst/extensions/far/compile-strings.h \
+fst/extensions/far/create.h fst/extensions/far/equal.h \
+fst/extensions/far/extract.h fst/extensions/far/far.h \
+fst/extensions/far/far-class.h fst/extensions/far/farlib.h \
+fst/extensions/far/farscript.h fst/extensions/far/getters.h \
+fst/extensions/far/info.h fst/extensions/far/isomorphic.h \
+fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \
+fst/extensions/far/stlist.h fst/extensions/far/sttable.h
+endif
+
+if HAVE_LINEAR
+linear_include_headers = fst/extensions/linear/linear-fst-data-builder.h \
+fst/extensions/linear/linear-fst-data.h fst/extensions/linear/linear-fst.h \
+fst/extensions/linear/linearscript.h fst/extensions/linear/loglinear-apply.h \
+fst/extensions/linear/trie.h
+endif
+
+if HAVE_MPDT
+mpdt_include_headers = fst/extensions/mpdt/compose.h \
+fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \
+fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \
+fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \
+fst/extensions/mpdt/reverse.h
+endif
+
+if HAVE_NGRAM
+ngram_include_headers = fst/extensions/ngram/bitmap-index.h \
+fst/extensions/ngram/ngram-fst.h fst/extensions/ngram/nthbit.h
+endif
+
+if HAVE_PDT
+pdt_include_headers = fst/extensions/pdt/collection.h \
+fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \
+fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \
+fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \
+fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \
+fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \
+fst/extensions/pdt/shortest-path.h
+endif
+
+if HAVE_SPECIAL
+special_include_headers = fst/extensions/special/phi-fst.h \
+fst/extensions/special/rho-fst.h fst/extensions/special/sigma-fst.h
+endif
+
+if HAVE_GRM
+far_include_headers = fst/extensions/far/compile-strings.h \
+fst/extensions/far/create.h fst/extensions/far/equal.h \
+fst/extensions/far/extract.h fst/extensions/far/far.h \
+fst/extensions/far/far-class.h fst/extensions/far/farlib.h \
+fst/extensions/far/farscript.h fst/extensions/far/getters.h \
+fst/extensions/far/info.h fst/extensions/far/isomorphic.h \
+fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \
+fst/extensions/far/stlist.h fst/extensions/far/sttable.h
+mpdt_include_headers = fst/extensions/mpdt/compose.h \
+fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \
+fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \
+fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \
+fst/extensions/mpdt/reverse.h
+pdt_include_headers = fst/extensions/pdt/collection.h \
+fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \
+fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \
+fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \
+fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \
+fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \
+fst/extensions/pdt/shortest-path.h
+endif
+
+script_include_headers = fst/script/arc-class.h \
+fst/script/arciterator-class.h fst/script/arcsort.h \
+fst/script/arg-packs.h fst/script/closure.h fst/script/compile-impl.h \
+fst/script/compile.h fst/script/compose.h fst/script/concat.h \
+fst/script/connect.h fst/script/convert.h fst/script/decode.h \
+fst/script/determinize.h fst/script/difference.h fst/script/disambiguate.h \
+fst/script/draw-impl.h fst/script/draw.h fst/script/encode.h \
+fst/script/encodemapper-class.h fst/script/epsnormalize.h fst/script/equal.h \
+fst/script/equivalent.h fst/script/fst-class.h fst/script/fstscript.h \
+fst/script/getters.h fst/script/info-impl.h fst/script/info.h \
+fst/script/intersect.h fst/script/invert.h fst/script/isomorphic.h \
+fst/script/map.h fst/script/minimize.h fst/script/print-impl.h \
+fst/script/print.h fst/script/project.h fst/script/prune.h \
+fst/script/push.h fst/script/randequivalent.h fst/script/randgen.h \
+fst/script/register.h fst/script/relabel.h fst/script/replace.h \
+fst/script/reverse.h fst/script/reweight.h fst/script/rmepsilon.h \
+fst/script/script-impl.h fst/script/shortest-distance.h \
+fst/script/shortest-path.h fst/script/stateiterator-class.h \
+fst/script/synchronize.h fst/script/text-io.h fst/script/topsort.h \
+fst/script/union.h fst/script/weight-class.h fst/script/fstscript-decl.h \
+fst/script/verify.h
+
+nobase_include_HEADERS = fst/arc-arena.h fst/arc.h fst/determinize.h \
+fst/intersect.h fst/queue.h fst/statesort.h fst/arcfilter.h fst/dfs-visit.h \
+fst/invert.h fst/randequivalent.h fst/string-weight.h fst/difference.h \
+fst/lexicographic-weight.h fst/randgen.h fst/symbol-table.h fst/arcsort.h \
+fst/encode.h fst/lock.h fst/synchronize.h fst/epsnormalize.h fst/log.h \
+fst/rational.h fst/test-properties.h fst/cache.h fst/equal.h fst/arc-map.h \
+fst/map.h fst/register.h fst/topsort.h fst/closure.h fst/equivalent.h \
+fst/matcher.h fst/matcher-fst.h fst/relabel.h fst/union-find.h \
+fst/compact-fst.h fst/expanded-fst.h fst/minimize.h fst/replace.h \
+fst/union.h fst/compat.h fst/factor-weight.h fst/state-map.h \
+fst/mutable-fst.h fst/reverse.h fst/util.h fst/complement.h fst/flags.h \
+fst/partition.h fst/reweight.h fst/vector-fst.h fst/filter-state.h \
+fst/compose-filter.h fst/float-weight.h fst/product-weight.h fst/rmepsilon.h \
+fst/verify.h fst/compose.h fst/fst-decl.h fst/project.h fst/rmfinalepsilon.h \
+fst/visit.h fst/concat.h fst/fst.h fst/properties.h fst/shortest-distance.h \
+fst/weight.h fst/connect.h fst/fstlib.h fst/prune.h fst/shortest-path.h \
+fst/const-fst.h fst/heap.h fst/push.h fst/state-table.h fst/pair-weight.h \
+fst/config.h fst/tuple-weight.h fst/power-weight.h fst/lookahead-matcher.h \
+fst/types.h fst/add-on.h fst/label-reachable.h fst/accumulator.h \
+fst/interval-set.h fst/state-reachable.h fst/lookahead-filter.h \
+fst/generic-register.h fst/edit-fst.h fst/replace-util.h fst/icu.h \
+fst/string.h fst/signed-log-weight.h fst/sparse-tuple-weight.h \
+fst/sparse-power-weight.h fst/expectation-weight.h fst/symbol-table-ops.h \
+fst/bi-table.h fst/mapped-file.h fst/memory.h fst/filter-state.h \
+fst/disambiguate.h fst/isomorphic.h fst/union-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)
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/include
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(am__nobase_include_HEADERS_DIST)
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__nobase_include_HEADERS_DIST = fst/arc-arena.h fst/arc.h \
+ fst/determinize.h fst/intersect.h fst/queue.h fst/statesort.h \
+ fst/arcfilter.h fst/dfs-visit.h fst/invert.h \
+ fst/randequivalent.h fst/string-weight.h fst/difference.h \
+ fst/lexicographic-weight.h fst/randgen.h fst/symbol-table.h \
+ fst/arcsort.h fst/encode.h fst/lock.h fst/synchronize.h \
+ fst/epsnormalize.h fst/log.h fst/rational.h \
+ fst/test-properties.h fst/cache.h fst/equal.h fst/arc-map.h \
+ fst/map.h fst/register.h fst/topsort.h fst/closure.h \
+ fst/equivalent.h fst/matcher.h fst/matcher-fst.h fst/relabel.h \
+ fst/union-find.h fst/compact-fst.h fst/expanded-fst.h \
+ fst/minimize.h fst/replace.h fst/union.h fst/compat.h \
+ fst/factor-weight.h fst/state-map.h fst/mutable-fst.h \
+ fst/reverse.h fst/util.h fst/complement.h fst/flags.h \
+ fst/partition.h fst/reweight.h fst/vector-fst.h \
+ fst/filter-state.h fst/compose-filter.h fst/float-weight.h \
+ fst/product-weight.h fst/rmepsilon.h fst/verify.h \
+ fst/compose.h fst/fst-decl.h fst/project.h \
+ fst/rmfinalepsilon.h fst/visit.h fst/concat.h fst/fst.h \
+ fst/properties.h fst/shortest-distance.h fst/weight.h \
+ fst/connect.h fst/fstlib.h fst/prune.h fst/shortest-path.h \
+ fst/const-fst.h fst/heap.h fst/push.h fst/state-table.h \
+ fst/pair-weight.h fst/config.h fst/tuple-weight.h \
+ fst/power-weight.h fst/lookahead-matcher.h fst/types.h \
+ fst/add-on.h fst/label-reachable.h fst/accumulator.h \
+ fst/interval-set.h fst/state-reachable.h \
+ fst/lookahead-filter.h fst/generic-register.h fst/edit-fst.h \
+ fst/replace-util.h fst/icu.h fst/string.h \
+ fst/signed-log-weight.h fst/sparse-tuple-weight.h \
+ fst/sparse-power-weight.h fst/expectation-weight.h \
+ fst/symbol-table-ops.h fst/bi-table.h fst/mapped-file.h \
+ fst/memory.h fst/disambiguate.h fst/isomorphic.h \
+ fst/union-weight.h fst/extensions/compress/compress.h \
+ fst/extensions/compress/compress-script.h \
+ fst/extensions/compress/gzfile.h \
+ fst/extensions/compress/elias.h \
+ fst/extensions/compress/randmod.h \
+ fst/extensions/far/compile-strings.h \
+ fst/extensions/far/create.h fst/extensions/far/equal.h \
+ fst/extensions/far/extract.h fst/extensions/far/far.h \
+ fst/extensions/far/far-class.h fst/extensions/far/farlib.h \
+ fst/extensions/far/farscript.h fst/extensions/far/getters.h \
+ fst/extensions/far/info.h fst/extensions/far/isomorphic.h \
+ fst/extensions/far/print-strings.h \
+ fst/extensions/far/script-impl.h fst/extensions/far/stlist.h \
+ fst/extensions/far/sttable.h \
+ fst/extensions/linear/linear-fst-data-builder.h \
+ fst/extensions/linear/linear-fst-data.h \
+ fst/extensions/linear/linear-fst.h \
+ fst/extensions/linear/linearscript.h \
+ fst/extensions/linear/loglinear-apply.h \
+ fst/extensions/linear/trie.h fst/extensions/mpdt/compose.h \
+ fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \
+ fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \
+ fst/extensions/mpdt/mpdtscript.h \
+ fst/extensions/mpdt/read_write_utils.h \
+ fst/extensions/mpdt/reverse.h \
+ fst/extensions/ngram/bitmap-index.h \
+ fst/extensions/ngram/ngram-fst.h fst/extensions/ngram/nthbit.h \
+ fst/extensions/pdt/collection.h fst/extensions/pdt/compose.h \
+ fst/extensions/pdt/expand.h fst/extensions/pdt/getters.h \
+ fst/extensions/pdt/info.h fst/extensions/pdt/paren.h \
+ fst/extensions/pdt/pdt.h fst/extensions/pdt/pdtlib.h \
+ fst/extensions/pdt/pdtscript.h fst/extensions/pdt/replace.h \
+ fst/extensions/pdt/reverse.h \
+ fst/extensions/pdt/shortest-path.h fst/script/arc-class.h \
+ fst/script/arciterator-class.h fst/script/arcsort.h \
+ fst/script/arg-packs.h fst/script/closure.h \
+ fst/script/compile-impl.h fst/script/compile.h \
+ fst/script/compose.h fst/script/concat.h fst/script/connect.h \
+ fst/script/convert.h fst/script/decode.h \
+ fst/script/determinize.h fst/script/difference.h \
+ fst/script/disambiguate.h fst/script/draw-impl.h \
+ fst/script/draw.h fst/script/encode.h \
+ fst/script/encodemapper-class.h fst/script/epsnormalize.h \
+ fst/script/equal.h fst/script/equivalent.h \
+ fst/script/fst-class.h fst/script/fstscript.h \
+ fst/script/getters.h fst/script/info-impl.h fst/script/info.h \
+ fst/script/intersect.h fst/script/invert.h \
+ fst/script/isomorphic.h fst/script/map.h fst/script/minimize.h \
+ fst/script/print-impl.h fst/script/print.h \
+ fst/script/project.h fst/script/prune.h fst/script/push.h \
+ fst/script/randequivalent.h fst/script/randgen.h \
+ fst/script/register.h fst/script/relabel.h \
+ fst/script/replace.h fst/script/reverse.h \
+ fst/script/reweight.h fst/script/rmepsilon.h \
+ fst/script/script-impl.h fst/script/shortest-distance.h \
+ fst/script/shortest-path.h fst/script/stateiterator-class.h \
+ fst/script/synchronize.h fst/script/text-io.h \
+ fst/script/topsort.h fst/script/union.h \
+ fst/script/weight-class.h fst/script/fstscript-decl.h \
+ fst/script/verify.h fst/extensions/special/phi-fst.h \
+ fst/extensions/special/rho-fst.h \
+ fst/extensions/special/sigma-fst.h
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(includedir)"
+HEADERS = $(nobase_include_HEADERS)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+@HAVE_COMPRESS_TRUE@compress_include_headers = fst/extensions/compress/compress.h \
+@HAVE_COMPRESS_TRUE@fst/extensions/compress/compress-script.h fst/extensions/compress/gzfile.h \
+@HAVE_COMPRESS_TRUE@fst/extensions/compress/elias.h fst/extensions/compress/randmod.h
+
+@HAVE_FAR_TRUE@far_include_headers = fst/extensions/far/compile-strings.h \
+@HAVE_FAR_TRUE@fst/extensions/far/create.h fst/extensions/far/equal.h \
+@HAVE_FAR_TRUE@fst/extensions/far/extract.h fst/extensions/far/far.h \
+@HAVE_FAR_TRUE@fst/extensions/far/far-class.h fst/extensions/far/farlib.h \
+@HAVE_FAR_TRUE@fst/extensions/far/farscript.h fst/extensions/far/getters.h \
+@HAVE_FAR_TRUE@fst/extensions/far/info.h fst/extensions/far/isomorphic.h \
+@HAVE_FAR_TRUE@fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \
+@HAVE_FAR_TRUE@fst/extensions/far/stlist.h fst/extensions/far/sttable.h
+
+@HAVE_GRM_TRUE@far_include_headers = fst/extensions/far/compile-strings.h \
+@HAVE_GRM_TRUE@fst/extensions/far/create.h fst/extensions/far/equal.h \
+@HAVE_GRM_TRUE@fst/extensions/far/extract.h fst/extensions/far/far.h \
+@HAVE_GRM_TRUE@fst/extensions/far/far-class.h fst/extensions/far/farlib.h \
+@HAVE_GRM_TRUE@fst/extensions/far/farscript.h fst/extensions/far/getters.h \
+@HAVE_GRM_TRUE@fst/extensions/far/info.h fst/extensions/far/isomorphic.h \
+@HAVE_GRM_TRUE@fst/extensions/far/print-strings.h fst/extensions/far/script-impl.h \
+@HAVE_GRM_TRUE@fst/extensions/far/stlist.h fst/extensions/far/sttable.h
+
+@HAVE_LINEAR_TRUE@linear_include_headers = fst/extensions/linear/linear-fst-data-builder.h \
+@HAVE_LINEAR_TRUE@fst/extensions/linear/linear-fst-data.h fst/extensions/linear/linear-fst.h \
+@HAVE_LINEAR_TRUE@fst/extensions/linear/linearscript.h fst/extensions/linear/loglinear-apply.h \
+@HAVE_LINEAR_TRUE@fst/extensions/linear/trie.h
+
+@HAVE_GRM_TRUE@mpdt_include_headers = fst/extensions/mpdt/compose.h \
+@HAVE_GRM_TRUE@fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \
+@HAVE_GRM_TRUE@fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \
+@HAVE_GRM_TRUE@fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \
+@HAVE_GRM_TRUE@fst/extensions/mpdt/reverse.h
+
+@HAVE_MPDT_TRUE@mpdt_include_headers = fst/extensions/mpdt/compose.h \
+@HAVE_MPDT_TRUE@fst/extensions/mpdt/expand.h fst/extensions/mpdt/info.h \
+@HAVE_MPDT_TRUE@fst/extensions/mpdt/mpdt.h fst/extensions/mpdt/mpdtlib.h \
+@HAVE_MPDT_TRUE@fst/extensions/mpdt/mpdtscript.h fst/extensions/mpdt/read_write_utils.h \
+@HAVE_MPDT_TRUE@fst/extensions/mpdt/reverse.h
+
+@HAVE_NGRAM_TRUE@ngram_include_headers = fst/extensions/ngram/bitmap-index.h \
+@HAVE_NGRAM_TRUE@fst/extensions/ngram/ngram-fst.h fst/extensions/ngram/nthbit.h
+
+@HAVE_GRM_TRUE@pdt_include_headers = fst/extensions/pdt/collection.h \
+@HAVE_GRM_TRUE@fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \
+@HAVE_GRM_TRUE@fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \
+@HAVE_GRM_TRUE@fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \
+@HAVE_GRM_TRUE@fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \
+@HAVE_GRM_TRUE@fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \
+@HAVE_GRM_TRUE@fst/extensions/pdt/shortest-path.h
+
+@HAVE_PDT_TRUE@pdt_include_headers = fst/extensions/pdt/collection.h \
+@HAVE_PDT_TRUE@fst/extensions/pdt/compose.h fst/extensions/pdt/expand.h \
+@HAVE_PDT_TRUE@fst/extensions/pdt/getters.h fst/extensions/pdt/info.h \
+@HAVE_PDT_TRUE@fst/extensions/pdt/paren.h fst/extensions/pdt/pdt.h \
+@HAVE_PDT_TRUE@fst/extensions/pdt/pdtlib.h fst/extensions/pdt/pdtscript.h \
+@HAVE_PDT_TRUE@fst/extensions/pdt/replace.h fst/extensions/pdt/reverse.h \
+@HAVE_PDT_TRUE@fst/extensions/pdt/shortest-path.h
+
+@HAVE_SPECIAL_TRUE@special_include_headers = fst/extensions/special/phi-fst.h \
+@HAVE_SPECIAL_TRUE@fst/extensions/special/rho-fst.h fst/extensions/special/sigma-fst.h
+
+script_include_headers = fst/script/arc-class.h \
+fst/script/arciterator-class.h fst/script/arcsort.h \
+fst/script/arg-packs.h fst/script/closure.h fst/script/compile-impl.h \
+fst/script/compile.h fst/script/compose.h fst/script/concat.h \
+fst/script/connect.h fst/script/convert.h fst/script/decode.h \
+fst/script/determinize.h fst/script/difference.h fst/script/disambiguate.h \
+fst/script/draw-impl.h fst/script/draw.h fst/script/encode.h \
+fst/script/encodemapper-class.h fst/script/epsnormalize.h fst/script/equal.h \
+fst/script/equivalent.h fst/script/fst-class.h fst/script/fstscript.h \
+fst/script/getters.h fst/script/info-impl.h fst/script/info.h \
+fst/script/intersect.h fst/script/invert.h fst/script/isomorphic.h \
+fst/script/map.h fst/script/minimize.h fst/script/print-impl.h \
+fst/script/print.h fst/script/project.h fst/script/prune.h \
+fst/script/push.h fst/script/randequivalent.h fst/script/randgen.h \
+fst/script/register.h fst/script/relabel.h fst/script/replace.h \
+fst/script/reverse.h fst/script/reweight.h fst/script/rmepsilon.h \
+fst/script/script-impl.h fst/script/shortest-distance.h \
+fst/script/shortest-path.h fst/script/stateiterator-class.h \
+fst/script/synchronize.h fst/script/text-io.h fst/script/topsort.h \
+fst/script/union.h fst/script/weight-class.h fst/script/fstscript-decl.h \
+fst/script/verify.h
+
+nobase_include_HEADERS = fst/arc-arena.h fst/arc.h fst/determinize.h \
+fst/intersect.h fst/queue.h fst/statesort.h fst/arcfilter.h fst/dfs-visit.h \
+fst/invert.h fst/randequivalent.h fst/string-weight.h fst/difference.h \
+fst/lexicographic-weight.h fst/randgen.h fst/symbol-table.h fst/arcsort.h \
+fst/encode.h fst/lock.h fst/synchronize.h fst/epsnormalize.h fst/log.h \
+fst/rational.h fst/test-properties.h fst/cache.h fst/equal.h fst/arc-map.h \
+fst/map.h fst/register.h fst/topsort.h fst/closure.h fst/equivalent.h \
+fst/matcher.h fst/matcher-fst.h fst/relabel.h fst/union-find.h \
+fst/compact-fst.h fst/expanded-fst.h fst/minimize.h fst/replace.h \
+fst/union.h fst/compat.h fst/factor-weight.h fst/state-map.h \
+fst/mutable-fst.h fst/reverse.h fst/util.h fst/complement.h fst/flags.h \
+fst/partition.h fst/reweight.h fst/vector-fst.h fst/filter-state.h \
+fst/compose-filter.h fst/float-weight.h fst/product-weight.h fst/rmepsilon.h \
+fst/verify.h fst/compose.h fst/fst-decl.h fst/project.h fst/rmfinalepsilon.h \
+fst/visit.h fst/concat.h fst/fst.h fst/properties.h fst/shortest-distance.h \
+fst/weight.h fst/connect.h fst/fstlib.h fst/prune.h fst/shortest-path.h \
+fst/const-fst.h fst/heap.h fst/push.h fst/state-table.h fst/pair-weight.h \
+fst/config.h fst/tuple-weight.h fst/power-weight.h fst/lookahead-matcher.h \
+fst/types.h fst/add-on.h fst/label-reachable.h fst/accumulator.h \
+fst/interval-set.h fst/state-reachable.h fst/lookahead-filter.h \
+fst/generic-register.h fst/edit-fst.h fst/replace-util.h fst/icu.h \
+fst/string.h fst/signed-log-weight.h fst/sparse-tuple-weight.h \
+fst/sparse-power-weight.h fst/expectation-weight.h fst/symbol-table-ops.h \
+fst/bi-table.h fst/mapped-file.h fst/memory.h fst/filter-state.h \
+fst/disambiguate.h fst/isomorphic.h fst/union-weight.h \
+$(compress_include_headers) \
+$(far_include_headers) \
+$(linear_include_headers) \
+$(mpdt_include_headers) \
+$(ngram_include_headers) \
+$(pdt_include_headers) \
+$(script_include_headers) \
+$(special_include_headers)
+
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/include/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/include/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+install-nobase_includeHEADERS: $(nobase_include_HEADERS)
+ @$(NORMAL_INSTALL)
+ @list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \
+ fi; \
+ $(am__nobase_list) | while read dir files; do \
+ xfiles=; for file in $$files; do \
+ if test -f "$$file"; then xfiles="$$xfiles $$file"; \
+ else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \
+ test -z "$$xfiles" || { \
+ test "x$$dir" = x. || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(includedir)/$$dir'"; \
+ $(MKDIR_P) "$(DESTDIR)$(includedir)/$$dir"; }; \
+ echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(includedir)/$$dir'"; \
+ $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(includedir)/$$dir" || exit $$?; }; \
+ done
+
+uninstall-nobase_includeHEADERS:
+ @$(NORMAL_UNINSTALL)
+ @list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \
+ $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \
+ dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir)
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(HEADERS)
+installdirs:
+ for dir in "$(DESTDIR)$(includedir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+ -rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-nobase_includeHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-nobase_includeHEADERS
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libtool cscopelist-am ctags ctags-am distclean \
+ distclean-generic distclean-libtool distclean-tags distdir dvi \
+ dvi-am html html-am info info-am install install-am \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-man \
+ install-nobase_includeHEADERS install-pdf install-pdf-am \
+ install-ps install-ps-am install-strip installcheck \
+ installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-generic \
+ mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
+ uninstall-am uninstall-nobase_includeHEADERS
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// 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_LIB_ACCUMULATOR_H_
+#define FST_LIB_ACCUMULATOR_H_
+
+#include <algorithm>
+#include <functional>
+#include <unordered_map>
+#include <vector>
+
+#include <fst/arcfilter.h>
+#include <fst/arcsort.h>
+#include <fst/dfs-visit.h>
+#include <fst/expanded-fst.h>
+#include <fst/replace.h>
+
+namespace fst {
+
+// This class accumulates arc weights using the semiring Plus().
+template <class A>
+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<Arc> &fst, bool copy = false) {}
+
+ void SetState(StateId state) {}
+
+ Weight Sum(Weight w, Weight v) { return Plus(w, v); }
+
+ template <class ArcIter>
+ 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 = Plus(sum, aiter->Value().weight);
+ }
+ return sum;
+ }
+
+ constexpr bool Error() const { return false; }
+
+ private:
+ DefaultAccumulator &operator=(const DefaultAccumulator &) = delete;
+};
+
+// This class accumulates arc weights using the log semiring Plus() assuming an
+// arc weight has a WeightConvert specialization to and from log64 weights.
+template <class A>
+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<Arc> &fst, bool copy = false) {}
+
+ void SetState(StateId s) {}
+
+ Weight Sum(Weight w, Weight v) { return LogPlus(w, v); }
+
+ template <class ArcIter>
+ 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:
+ double LogPosExp(double x) { return log(1.0F + exp(-x)); }
+
+ Weight LogPlus(Weight w, Weight 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)));
+ }
+ }
+
+ WeightConvert<Weight, Log64Weight> to_log_weight_;
+ WeightConvert<Log64Weight, Weight> 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<double> *weights,
+ std::vector<int> *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<double> *weights,
+ std::vector<int> *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<double> weights_;
+ std::vector<int> weight_positions_;
+
+ MutableFastLogAccumulatorData(const MutableFastLogAccumulatorData &) = delete;
+ MutableFastLogAccumulatorData &operator=(
+ const MutableFastLogAccumulatorData &) = delete;
+};
+
+// This class accumulates arc weights using the log semiring Plus() assuming an
+// arc weight has a WeightConvert specialization to and from log64 weights. The
+// member function Init(fst) has to be called to setup pre-computed weight
+// information.
+template <class A>
+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<MutableFastLogAccumulatorData>(arc_limit,
+ arc_period)),
+ state_weights_(nullptr),
+ error_(false) {}
+
+ explicit FastLogAccumulator(std::shared_ptr<FastLogAccumulatorData> data)
+ : to_log_weight_(),
+ to_weight_(),
+ arc_limit_(data->ArcLimit()),
+ arc_period_(data->ArcPeriod()),
+ data_(data),
+ state_weights_(nullptr),
+ error_(false) {}
+
+ FastLogAccumulator(const FastLogAccumulator<Arc> &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 <class ArcIter>
+ 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.
+ auto index_begin = -1;
+ auto index_end = -1;
+ auto stored_begin = end;
+ auto 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 <class FST>
+ 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<double> weights;
+ std::vector<int> weight_positions;
+ weight_positions.reserve(CountStates(fst));
+ for (StateIterator<FST> siter(fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ if (fst.NumArcs(s) >= arc_limit_) {
+ auto sum = FloatLimits<double>::PosInfinity();
+ if (weight_positions.size() <= s) weight_positions.resize(s + 1, -1);
+ weight_positions[s] = weights.size();
+ weights.push_back(sum);
+ auto narcs = 0;
+ ArcIterator<FST> 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<FastLogAccumulatorData> GetData() const { return data_; }
+
+ private:
+ static double LogPosExp(double x) {
+ return x == FloatLimits<double>::PosInfinity() ? 0.0
+ : log(1.0F + exp(-x));
+ }
+
+ static double LogMinusExp(double x) {
+ return x == FloatLimits<double>::PosInfinity() ? 0.0
+ : log(1.0F - exp(-x));
+ }
+
+ Weight LogPlus(Weight w, Weight v) const {
+ 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<double>::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<double>::PosInfinity()) {
+ return to_weight_(Log64Weight(f1));
+ } else {
+ return to_weight_(Log64Weight(f1 - LogMinusExp(f2 - f1)));
+ }
+ }
+
+ const WeightConvert<Weight, Log64Weight> to_log_weight_;
+ const WeightConvert<Log64Weight, Weight> to_weight_;
+ const ssize_t arc_limit_; // Minimum # of arcs to pre-compute state.
+ const ssize_t arc_period_; // Save cumulative weights per 'arc_period_'.
+ std::shared_ptr<FastLogAccumulatorData> 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 Arc>
+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<Arc> &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<double> *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<double> *weights) {
+ if (cache_gc_ && cache_size_ >= cache_limit_) GC(false);
+ cache_.insert(std::make_pair(s, CacheState(weights, true)));
+ if (cache_gc_) cache_size_ += weights->capacity() * sizeof(double);
+ }
+
+ private:
+ // Cached information for a given state.
+ struct CacheState {
+ std::unique_ptr<std::vector<double>> weights; // Accumulated weights.
+ bool recent; // Has this state been accessed since last GC?
+
+ CacheState(std::vector<double> *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) {
+ CacheState &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<StateId, CacheState> cache_; // Cache.
+ bool cache_gc_; // Enables garbage collection.
+ size_t cache_limit_; // # of bytes cached.
+ size_t cache_size_; // # of bytes allowed before GC.
+
+ CacheLogAccumulatorData &operator=(const CacheLogAccumulatorData &) = delete;
+};
+
+// This class accumulates arc weights using the log semiring Plus() has a
+// WeightConvert specialization to and from log64 weights. It is similar to the
+// FastLogAccumator. However here, the accumulated weights are pre-computed and
+// stored only for the states that are visited. The member function Init(fst)
+// has to be called to setup this accumulator.
+template <class Arc>
+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<CacheLogAccumulatorData<Arc>>(gc, gc_limit)),
+ s_(kNoStateId),
+ error_(false) {}
+
+ CacheLogAccumulator(const CacheLogAccumulator<Arc> &acc, bool safe = false)
+ : arc_limit_(acc.arc_limit_),
+ fst_(acc.fst_ ? acc.fst_->Copy() : nullptr),
+ data_(safe ? std::make_shared<CacheLogAccumulatorData<Arc>>(*acc.data_)
+ : acc.data_),
+ s_(kNoStateId),
+ error_(acc.error_) {}
+
+ // Arg 'arc_limit' specifies minimum # of arcs to pre-compute.
+ void Init(const Fst<Arc> &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<double>;
+ weights_->reserve(fst_->NumArcs(s) + 1);
+ weights_->push_back(FloatLimits<double>::PosInfinity());
+ data_->AddWeights(s, weights_);
+ }
+ }
+
+ Weight Sum(Weight w, Weight v) { return LogPlus(w, v); }
+
+ template <class ArcIter>
+ 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 {
+ 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 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;
+ }
+ }
+ }
+
+ // Arc iterator position determines beginning point of lower bound.
+ template <class ArcIter>
+ size_t LowerBound(double w, ArcIter *aiter) {
+ if (weights_) {
+ auto pos = aiter->Position();
+ return std::lower_bound(weights_->begin() + pos + 1, weights_->end(), w,
+ std::greater<double>()) -
+ weights_->begin() - 1;
+ } else {
+ auto n = 0;
+ auto x = FloatLimits<double>::PosInfinity();
+ for (; !aiter->Done(); aiter->Next(), ++n) {
+ x = LogPlus(x, aiter->Value().weight);
+ if (x < w) break;
+ }
+ return n;
+ }
+ }
+
+ bool Error() const { return error_; }
+
+ private:
+ double LogPosExp(double x) {
+ return x == FloatLimits<double>::PosInfinity() ? 0.0
+ : log(1.0F + exp(-x));
+ }
+
+ double LogMinusExp(double x) {
+ return x == FloatLimits<double>::PosInfinity() ? 0.0
+ : log(1.0F - exp(-x));
+ }
+
+ Weight LogPlus(Weight w, Weight 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<double>::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<double>::PosInfinity()) {
+ return to_weight_(Log64Weight(f1));
+ } else {
+ return to_weight_(Log64Weight(f1 - LogMinusExp(f2 - f1)));
+ }
+ }
+
+ WeightConvert<Weight, Log64Weight> to_log_weight_;
+ WeightConvert<Log64Weight, Weight> to_weight_;
+ ssize_t arc_limit_; // Minimum # of arcs to cache a state.
+ std::vector<double> *weights_; // Accumulated weights for cur. state.
+ std::unique_ptr<const Fst<Arc>> fst_; // Input FST.
+ std::shared_ptr<CacheLogAccumulatorData<Arc>> data_; // Cache data.
+ StateId s_; // Current state.
+ bool error_;
+};
+
+// Stores shareable data for replace accumulator copies.
+template <class Accumulator, class T>
+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<Accumulator *> &accumulators)
+ : state_table_(nullptr) {
+ accumulators_.reserve(accumulators.size());
+ for (const auto accumulator : accumulators) {
+ accumulators_.emplace_back(accumulator);
+ }
+ }
+
+ void Init(const std::vector<std::pair<Label, const Fst<Arc> *>> &fst_tuples,
+ const StateTable *state_table) {
+ state_table_ = state_table;
+ accumulators_.resize(fst_tuples.size());
+ for (Label i = 0; i < accumulators_.size(); ++i) {
+ if (!accumulators_[i]) {
+ accumulators_[i].reset(new Accumulator());
+ accumulators_[i]->Init(*(fst_tuples[i].second));
+ }
+ fst_array_.emplace_back(fst_tuples[i].second->Copy());
+ }
+ }
+
+ const StateTuple &GetTuple(StateId s) const { return state_table_->Tuple(s); }
+
+ Accumulator *GetAccumulator(size_t i) { return accumulators_[i].get(); }
+
+ const Fst<Arc> *GetFst(size_t i) const { return fst_array_[i].get(); }
+
+ private:
+ const StateTable *state_table_;
+ std::vector<std::unique_ptr<Accumulator>> accumulators_;
+ std::vector<std::unique_ptr<const Fst<Arc>>> 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 Accumulator,
+ class T = DefaultReplaceStateTable<typename Accumulator::Arc>>
+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<Accumulator, StateTable>>()),
+ error_(false) {}
+
+ explicit ReplaceAccumulator(const std::vector<Accumulator *> &accumulators)
+ : init_(false),
+ data_(std::make_shared<ReplaceAccumulatorData<Accumulator, StateTable>>(
+ accumulators)),
+ error_(false) {}
+
+ ReplaceAccumulator(const ReplaceAccumulator<Accumulator, StateTable> &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<std::pair<Label, const Fst<Arc> *>> &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<A, T, C>&, bool) and using friendship to get access
+ // to the innards of ReplaceFst.
+ void Init(const Fst<Arc> &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<Fst<Arc>>(*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 <class ArcIter>
+ 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<ReplaceAccumulatorData<Accumulator, StateTable>> data_;
+ Label fst_id_;
+ size_t offset_;
+ Weight offset_weight_;
+ std::unique_ptr<ArcIterator<Fst<Arc>>> aiter_;
+ bool error_;
+};
+
+// SafeReplaceAccumulator accumulates weights in a ReplaceFst and copies of it
+// are always thread-safe copies.
+template <class Accumulator, class T>
+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<Accumulator> &accumulators) {
+ for (const auto &accumulator : accumulators) {
+ accumulators_.emplace_back(accumulator, true);
+ }
+ }
+
+ void Init(const std::vector<std::pair<Label, const Fst<Arc> *>> &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<Arc> &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 <class ArcIter>
+ 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<Arc> &fst, StateId state_id) {
+ ptr_.reset(new ArcIterator<Fst<Arc>>(fst, state_id));
+ }
+
+ ArcIterator<Fst<Arc>> *get() { return ptr_.get(); }
+
+ private:
+ std::unique_ptr<ArcIterator<Fst<Arc>>> ptr_;
+ };
+
+ Accumulator *GetAccumulator(size_t i) { return &accumulators_[i]; }
+
+ const Fst<Arc> *GetFst(size_t i) const { return fst_array_[i].get(); }
+
+ const StateTable *state_table_;
+ std::vector<Accumulator> accumulators_;
+ std::vector<std::shared_ptr<Fst<Arc>>> fst_array_;
+ ArcIteratorPtr aiter_;
+ bool init_ = false;
+ bool error_ = false;
+ Label fst_id_;
+ size_t offset_;
+ Weight offset_weight_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_ACCUMULATOR_H_
--- /dev/null
+// 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_LIB_ADD_ON_H_
+#define FST_LIB_ADD_ON_H_
+
+#include <stddef.h>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <fst/fst.h>
+
+
+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 A1, class A2>
+class AddOnPair {
+ public:
+ // Argument reference count incremented.
+ AddOnPair(std::shared_ptr<A1> a1, std::shared_ptr<A2> 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<A1> SharedFirst() const { return a1_; }
+
+ std::shared_ptr<A2> SharedSecond() const { return a2_; }
+
+ static AddOnPair<A1, A2> *Read(std::istream &istrm,
+ const FstReadOptions &opts) {
+ A1 *a1 = nullptr;
+ bool have_addon1 = false;
+ ReadType(istrm, &have_addon1);
+ if (have_addon1) a1 = A1::Read(istrm, opts);
+
+ A2 *a2 = nullptr;
+ bool have_addon2 = false;
+ ReadType(istrm, &have_addon2);
+ if (have_addon2) a2 = A2::Read(istrm, opts);
+
+ return new AddOnPair<A1, A2>(std::shared_ptr<A1>(a1),
+ std::shared_ptr<A2>(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> a1_;
+ std::shared_ptr<A2> 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 FST, class T>
+class AddOnImpl : public FstImpl<typename FST::Arc> {
+ public:
+ using Arc = typename FST::Arc;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::WriteHeader;
+
+ // We make a thread-safe copy of the FST by default since an FST
+ // implementation is expected to not share mutable data between objects.
+ AddOnImpl(const FST &fst, const string &type,
+ std::shared_ptr<T> t = std::shared_ptr<T>())
+ : fst_(fst, true), t_(std::move(t)) {
+ SetType(type);
+ SetProperties(fst_.Properties(kFstProperties, false));
+ SetInputSymbols(fst_.InputSymbols());
+ SetOutputSymbols(fst_.OutputSymbols());
+ }
+
+ // Conversion from const Fst<Arc> & to F always copies the underlying
+ // implementation.
+ AddOnImpl(const Fst<Arc> &fst, const string &type,
+ std::shared_ptr<T> t = std::shared_ptr<T>())
+ : 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<FST, T> &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<FST, T> *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<AddOnImpl<FST, T>> impl(
+ new AddOnImpl<FST, T>(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(FST::Read(strm, fopts));
+ if (!fst) return nullptr;
+ std::shared_ptr<T> t;
+ bool have_addon = false;
+ ReadType(strm, &have_addon);
+ if (have_addon) { // Reads add-on object if present.
+ t = std::shared_ptr<T>(T::Read(strm, fopts));
+ if (!t) return nullptr;
+ }
+ return new AddOnImpl<FST, T>(*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<Arc> *data) const {
+ fst_.InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *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<T> GetSharedAddOn() const { return t_; }
+
+ void SetAddOn(std::shared_ptr<T> t) { t_ = t; }
+
+ private:
+ explicit AddOnImpl(const string &type) : t_() {
+ SetType(type);
+ SetProperties(kExpanded);
+ }
+
+ // Current file format version.
+ static constexpr int kFileVersion = 1;
+ // Minimum file format version supported.
+ static constexpr int kMinFileVersion = 1;
+
+ FST fst_;
+ std::shared_ptr<T> t_;
+
+ AddOnImpl &operator=(const AddOnImpl &) = delete;
+};
+
+template <class FST, class T>
+constexpr int AddOnImpl<FST, T>::kFileVersion;
+
+template <class FST, class T>
+constexpr int AddOnImpl<FST, T>::kMinFileVersion;
+
+} // namespace internal
+} // namespace fst
+
+#endif // FST_LIB_ADD_ON_H_
--- /dev/null
+#ifndef FST_LIB_ARC_ARENA_H_
+#define FST_LIB_ARC_ARENA_H_
+
+#include <deque>
+#include <memory>
+#include <utility>
+#include <fst/fst.h>
+#include <fst/memory.h>
+#include <unordered_map>
+
+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 <typename Arc>
+class ArcArena {
+ public:
+ explicit ArcArena(size_t block_size = 256,
+ size_t max_retained_size = 1e6)
+ : block_size_(block_size),
+ max_retained_size_(max_retained_size) {
+ blocks_.emplace_back(MakeSharedBlock(block_size_));
+ first_block_size_ = block_size_;
+ total_size_ = block_size_;
+ arcs_ = blocks_.back().get();
+ end_ = arcs_ + block_size_;
+ next_ = arcs_;
+ }
+
+ ArcArena(const ArcArena& copy)
+ : arcs_(copy.arcs_), next_(copy.next_), end_(copy.end_),
+ block_size_(copy.block_size_),
+ first_block_size_(copy.first_block_size_),
+ total_size_(copy.total_size_),
+ max_retained_size_(copy.max_retained_size_),
+ blocks_(copy.blocks_) {
+ NewBlock(block_size_);
+ }
+
+ void ReserveArcs(size_t n) {
+ if (next_ + n < end_) return;
+ NewBlock(n);
+ }
+
+ void PushArc(const Arc& arc) {
+ if (next_ == end_) {
+ size_t length = next_ - arcs_;
+ NewBlock(length * 2);
+ }
+ *next_ = arc;
+ ++next_;
+ }
+
+ const Arc* GetArcs() {
+ const Arc* 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) {
+ size_t length = next_ - arcs_;
+ size_t 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<Arc> MakeSharedBlock(size_t size) {
+ return std::shared_ptr<Arc>(new Arc[size], std::default_delete<Arc[]>());
+ }
+
+ 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<std::shared_ptr<Arc>> 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 A>
+class ArcArenaStateStore {
+ public:
+ using Arc = A;
+ using Weight = typename Arc::Weight;
+ using StateId = typename Arc::StateId;
+
+ ArcArenaStateStore() : arena_(64 * 1024) {
+ }
+
+ class State {
+ public:
+ Weight Final() const { return final_; }
+
+ size_t NumInputEpsilons() const { return niepsilons_; }
+
+ size_t NumOutputEpsilons() const { return noepsilons_; }
+
+ size_t NumArcs() const { return narcs_; }
+
+ const Arc &GetArc(size_t n) const { return arcs_[n]; }
+
+ const Arc *Arcs() const { return arcs_; }
+
+ int* MutableRefCount() const { return nullptr; }
+
+ private:
+ State(Weight final, int32 niepsilons, int32 noepsilons, int32 narcs,
+ const Arc *arcs)
+ : final_(std::move(final)),
+ niepsilons_(niepsilons),
+ noepsilons_(noepsilons),
+ narcs_(narcs),
+ arcs_(arcs) {}
+
+ Weight final_ = Weight::Zero;
+ int32 niepsilons_ = 0;
+ int32 noepsilons_ = 0;
+ int32 narcs_ = 0;
+ const Arc* arcs_ = nullptr;
+ friend class ArcArenaStateStore<Arc>;
+ };
+
+ template <class Expander>
+ State *FindOrExpand(Expander &expander, StateId state_id) { // NOLINT
+ auto it = cache_.insert(std::pair<StateId, State*>(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();
+ int32 narcs = builder.narcs_;
+ int32 niepsilons = 0;
+ int32 noepsilons = 0;
+ for (auto i = 0; i < narcs; ++i) {
+ if (arcs[i].ilabel == 0) ++niepsilons;
+ if (arcs[i].olabel == 0) ++noepsilons;
+ }
+ states_.emplace_back(
+ State(builder.final_, niepsilons, noepsilons, narcs, arcs));
+ // Places it in the cache.
+ auto state = &states_.back();
+ it.first->second = state;
+ return state;
+ }
+
+ State *Find(StateId state_id) const {
+ auto it = cache_.find(state_id);
+ return (it == cache_.end()) ? nullptr : it->second;
+ }
+
+ private:
+ class StateBuilder {
+ public:
+ explicit StateBuilder(ArcArena<Arc>* arena)
+ : arena_(arena) {}
+
+ void SetFinal(Weight final) { final_ = final; }
+
+ void ReserveArcs(size_t n) { arena_->ReserveArcs(n); }
+
+ void AddArc(const Arc& arc) {
+ ++narcs_;
+ arena_->PushArc(arc);
+ }
+
+ private:
+ ArcArena<Arc> *arena_;
+ Weight final_ = Weight::Zero();
+ int narcs_ = 0;
+
+ friend class ArcArenaStateStore<Arc>;
+ };
+
+ std::unordered_map<StateId, State *> cache_;
+ std::deque<State> states_;
+ ArcArena<Arc> arena_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_ARC_ARENA_H_
--- /dev/null
+// 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_LIB_ARC_MAP_H_
+#define FST_LIB_ARC_MAP_H_
+
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#include <fst/cache.h>
+#include <fst/mutable-fst.h>
+
+
+namespace fst {
+
+// Determines how final weights are mapped.
+enum MapFinalAction {
+ // A final weight is mapped into a final weight. An error is raised if this
+ // is not possible.
+ MAP_NO_SUPERFINAL,
+ // A final weight is mapped to an arc to the superfinal state when the result
+ // cannot be represented as a final weight. The superfinal state will be
+ // added only if it is needed.
+ MAP_ALLOW_SUPERFINAL,
+ // A final weight is mapped to an arc to the superfinal state unless the
+ // result can be represented as a final weight of weight Zero(). The
+ // superfinal state is always added (if the input is not the empty FST).
+ MAP_REQUIRE_SUPERFINAL
+};
+
+// Determines how symbol tables are mapped.
+enum MapSymbolsAction {
+ // Symbols should be cleared in the result by the map.
+ MAP_CLEAR_SYMBOLS,
+ // Symbols should be copied from the input FST by the map.
+ MAP_COPY_SYMBOLS,
+ // Symbols should not be modified in the result by the map itself.
+ // (They may set by the mapper).
+ MAP_NOOP_SYMBOLS
+};
+
+// The ArcMapper interfaces defines how arcs and final weights are mapped.
+// This is useful for implementing operations that do not change the number of
+// arcs (expect possibly superfinal arcs).
+//
+// template <class A, class B>
+// 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 <class A, class C>
+void ArcMap(MutableFst<A> *fst, C *mapper) {
+ using FromArc = A;
+ using ToArc = A;
+ using StateId = typename FromArc::StateId;
+ using Weight = typename FromArc::Weight;
+ if (mapper->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) {
+ fst->SetInputSymbols(nullptr);
+ }
+ if (mapper->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) {
+ fst->SetOutputSymbols(nullptr);
+ }
+ if (fst->Start() == kNoStateId) return;
+ const auto props = fst->Properties(kFstProperties, false);
+ const auto final_action = mapper->FinalAction();
+ auto superfinal = kNoStateId;
+ if (final_action == MAP_REQUIRE_SUPERFINAL) {
+ superfinal = fst->AddState();
+ fst->SetFinal(superfinal, Weight::One());
+ }
+ for (StateIterator<MutableFst<FromArc>> siter(*fst); !siter.Done();
+ siter.Next()) {
+ const auto state = siter.Value();
+ for (MutableArcIterator<MutableFst<FromArc>> aiter(fst, state);
+ !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ aiter.SetValue((*mapper)(arc));
+ }
+ switch (final_action) {
+ case MAP_NO_SUPERFINAL:
+ default: {
+ const FromArc arc(0, 0, fst->Final(state), kNoStateId);
+ const auto final_arc = (*mapper)(arc);
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0) {
+ FSTERROR() << "ArcMap: Non-zero arc labels for superfinal arc";
+ fst->SetProperties(kError, kError);
+ }
+ fst->SetFinal(state, final_arc.weight);
+ break;
+ }
+ case MAP_ALLOW_SUPERFINAL: {
+ if (state != superfinal) {
+ const FromArc arc(0, 0, fst->Final(state), kNoStateId);
+ auto final_arc = (*mapper)(arc);
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0) {
+ // Add a superfinal state if not already done.
+ if (superfinal == kNoStateId) {
+ superfinal = fst->AddState();
+ fst->SetFinal(superfinal, Weight::One());
+ }
+ final_arc.nextstate = superfinal;
+ fst->AddArc(state, final_arc);
+ fst->SetFinal(state, Weight::Zero());
+ } else {
+ fst->SetFinal(state, final_arc.weight);
+ }
+ }
+ break;
+ }
+ case MAP_REQUIRE_SUPERFINAL: {
+ if (state != superfinal) {
+ const FromArc arc(0, 0, fst->Final(state), kNoStateId);
+ const auto final_arc = (*mapper)(arc);
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0 ||
+ final_arc.weight != Weight::Zero()) {
+ fst->AddArc(state, ToArc(final_arc.ilabel, final_arc.olabel,
+ final_arc.weight, superfinal));
+ }
+ fst->SetFinal(state, Weight::Zero());
+ }
+ break;
+ }
+ }
+ }
+ fst->SetProperties(mapper->Properties(props), kFstProperties);
+}
+
+// Maps an arc type A using a mapper function object C, passed by value. This
+// version modifies its FST input.
+template <class A, class C>
+void ArcMap(MutableFst<A> *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 <class A, class B, class C>
+void ArcMap(const Fst<A> &ifst, MutableFst<B> *ofst, C *mapper) {
+ using FromArc = A;
+ using StateId = typename FromArc::StateId;
+ using Weight = typename FromArc::Weight;
+ ofst->DeleteStates();
+ if (mapper->InputSymbolsAction() == MAP_COPY_SYMBOLS) {
+ ofst->SetInputSymbols(ifst.InputSymbols());
+ } else if (mapper->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) {
+ ofst->SetInputSymbols(nullptr);
+ }
+ if (mapper->OutputSymbolsAction() == MAP_COPY_SYMBOLS) {
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ } else if (mapper->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) {
+ ofst->SetOutputSymbols(nullptr);
+ }
+ const auto iprops = ifst.Properties(kCopyProperties, false);
+ if (ifst.Start() == kNoStateId) {
+ if (iprops & kError) ofst->SetProperties(kError, kError);
+ return;
+ }
+ const auto final_action = mapper->FinalAction();
+ if (ifst.Properties(kExpanded, false)) {
+ ofst->ReserveStates(
+ CountStates(ifst) + final_action == MAP_NO_SUPERFINAL ? 0 : 1);
+ }
+ // Adds all states.
+ for (StateIterator<Fst<A>> siter(ifst); !siter.Done(); siter.Next()) {
+ ofst->AddState();
+ }
+ StateId superfinal = kNoStateId;
+ if (final_action == MAP_REQUIRE_SUPERFINAL) {
+ superfinal = ofst->AddState();
+ ofst->SetFinal(superfinal, B::Weight::One());
+ }
+ for (StateIterator<Fst<A>> siter(ifst); !siter.Done(); siter.Next()) {
+ StateId s = siter.Value();
+ if (s == ifst.Start()) ofst->SetStart(s);
+ ofst->ReserveArcs(s, ifst.NumArcs(s));
+ for (ArcIterator<Fst<A>> aiter(ifst, s); !aiter.Done(); aiter.Next()) {
+ ofst->AddArc(s, (*mapper)(aiter.Value()));
+ }
+ switch (final_action) {
+ case MAP_NO_SUPERFINAL:
+ default: {
+ B final_arc = (*mapper)(A(0, 0, ifst.Final(s), kNoStateId));
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0) {
+ FSTERROR() << "ArcMap: Non-zero arc labels for superfinal arc";
+ ofst->SetProperties(kError, kError);
+ }
+ ofst->SetFinal(s, final_arc.weight);
+ break;
+ }
+ case MAP_ALLOW_SUPERFINAL: {
+ B final_arc = (*mapper)(A(0, 0, ifst.Final(s), kNoStateId));
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0) {
+ // Add a superfinal state if not already done.
+ if (superfinal == kNoStateId) {
+ superfinal = ofst->AddState();
+ ofst->SetFinal(superfinal, B::Weight::One());
+ }
+ final_arc.nextstate = superfinal;
+ ofst->AddArc(s, final_arc);
+ ofst->SetFinal(s, B::Weight::Zero());
+ } else {
+ ofst->SetFinal(s, final_arc.weight);
+ }
+ break;
+ }
+ case MAP_REQUIRE_SUPERFINAL: {
+ B final_arc = (*mapper)(A(0, 0, ifst.Final(s), kNoStateId));
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0 ||
+ final_arc.weight != B::Weight::Zero()) {
+ ofst->AddArc(s, B(final_arc.ilabel, final_arc.olabel,
+ final_arc.weight, superfinal));
+ }
+ ofst->SetFinal(s, B::Weight::Zero());
+ break;
+ }
+ }
+ }
+ const auto oprops = ofst->Properties(kFstProperties, false);
+ ofst->SetProperties(mapper->Properties(iprops) | oprops, kFstProperties);
+}
+
+// Maps an arc type A to an arc type B using mapper function
+// object C, passed by value. This version writes the mapped input
+// Fst to an output MutableFst.
+template <class A, class B, class C>
+void ArcMap(const Fst<A> &ifst, MutableFst<B> *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 A, class B, class C>
+class ArcMapFst;
+
+namespace internal {
+
+// Implementation of delayed ArcMapFst.
+template <class A, class B, class C>
+class ArcMapFstImpl : public CacheImpl<B> {
+ public:
+ using Arc = B;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<B>::SetType;
+ using FstImpl<B>::SetProperties;
+ using FstImpl<B>::SetInputSymbols;
+ using FstImpl<B>::SetOutputSymbols;
+
+ using CacheImpl<B>::PushArc;
+ using CacheImpl<B>::HasArcs;
+ using CacheImpl<B>::HasFinal;
+ using CacheImpl<B>::HasStart;
+ using CacheImpl<B>::SetArcs;
+ using CacheImpl<B>::SetFinal;
+ using CacheImpl<B>::SetStart;
+
+ friend class StateIterator<ArcMapFst<A, B, C>>;
+
+ ArcMapFstImpl(const Fst<A> &fst, const C &mapper,
+ const ArcMapFstOptions &opts)
+ : CacheImpl<B>(opts),
+ fst_(fst.Copy()),
+ mapper_(new C(mapper)),
+ own_mapper_(true),
+ superfinal_(kNoStateId),
+ nstates_(0) {
+ Init();
+ }
+
+ ArcMapFstImpl(const Fst<A> &fst, C *mapper, const ArcMapFstOptions &opts)
+ : CacheImpl<B>(opts),
+ fst_(fst.Copy()),
+ mapper_(mapper),
+ own_mapper_(false),
+ superfinal_(kNoStateId),
+ nstates_(0) {
+ Init();
+ }
+
+ ArcMapFstImpl(const ArcMapFstImpl<A, B, C> &impl)
+ : CacheImpl<B>(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<B>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) {
+ switch (final_action_) {
+ case MAP_NO_SUPERFINAL:
+ default: {
+ const auto final_arc =
+ (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId));
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0) {
+ FSTERROR() << "ArcMapFst: Non-zero arc labels for superfinal arc";
+ SetProperties(kError, kError);
+ }
+ SetFinal(s, final_arc.weight);
+ break;
+ }
+ case MAP_ALLOW_SUPERFINAL: {
+ if (s == superfinal_) {
+ SetFinal(s, Weight::One());
+ } else {
+ const auto final_arc =
+ (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId));
+ if (final_arc.ilabel == 0 && final_arc.olabel == 0) {
+ SetFinal(s, final_arc.weight);
+ } else {
+ SetFinal(s, Weight::Zero());
+ }
+ }
+ break;
+ }
+ case MAP_REQUIRE_SUPERFINAL: {
+ SetFinal(s, s == superfinal_ ? Weight::One() : Weight::Zero());
+ break;
+ }
+ }
+ }
+ return CacheImpl<B>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<B>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<B>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<B>::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<Arc>::Properties(mask);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<B> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<B>::InitArcIterator(s, data);
+ }
+
+ void Expand(StateId s) {
+ // Add exiting arcs.
+ if (s == superfinal_) {
+ SetArcs(s);
+ return;
+ }
+ for (ArcIterator<Fst<A>> aiter(*fst_, FindIState(s)); !aiter.Done();
+ aiter.Next()) {
+ auto aarc = aiter.Value();
+ aarc.nextstate = FindOState(aarc.nextstate);
+ const auto &barc = (*mapper_)(aarc);
+ PushArc(s, barc);
+ }
+
+ // Check for superfinal arcs.
+ if (!HasFinal(s) || Final(s) == Weight::Zero()) {
+ switch (final_action_) {
+ case MAP_NO_SUPERFINAL:
+ default:
+ break;
+ case MAP_ALLOW_SUPERFINAL: {
+ auto final_arc =
+ (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId));
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0) {
+ if (superfinal_ == kNoStateId) superfinal_ = nstates_++;
+ final_arc.nextstate = superfinal_;
+ PushArc(s, final_arc);
+ }
+ break;
+ }
+ case MAP_REQUIRE_SUPERFINAL: {
+ const auto final_arc =
+ (*mapper_)(A(0, 0, fst_->Final(FindIState(s)), kNoStateId));
+ if (final_arc.ilabel != 0 || final_arc.olabel != 0 ||
+ final_arc.weight != B::Weight::Zero()) {
+ PushArc(s, B(final_arc.ilabel, final_arc.olabel, final_arc.weight,
+ superfinal_));
+ }
+ break;
+ }
+ }
+ }
+ SetArcs(s);
+ }
+
+ private:
+ void Init() {
+ SetType("map");
+ if (mapper_->InputSymbolsAction() == MAP_COPY_SYMBOLS) {
+ SetInputSymbols(fst_->InputSymbols());
+ } else if (mapper_->InputSymbolsAction() == MAP_CLEAR_SYMBOLS) {
+ SetInputSymbols(nullptr);
+ }
+ if (mapper_->OutputSymbolsAction() == MAP_COPY_SYMBOLS) {
+ SetOutputSymbols(fst_->OutputSymbols());
+ } else if (mapper_->OutputSymbolsAction() == MAP_CLEAR_SYMBOLS) {
+ SetOutputSymbols(nullptr);
+ }
+ if (fst_->Start() == kNoStateId) {
+ final_action_ = MAP_NO_SUPERFINAL;
+ SetProperties(kNullProperties);
+ } else {
+ final_action_ = mapper_->FinalAction();
+ uint64 props = fst_->Properties(kCopyProperties, false);
+ SetProperties(mapper_->Properties(props));
+ if (final_action_ == MAP_REQUIRE_SUPERFINAL) superfinal_ = 0;
+ }
+ }
+
+ // Maps from output state to input state.
+ StateId FindIState(StateId s) {
+ if (superfinal_ == kNoStateId || s < superfinal_) {
+ return s;
+ } else {
+ return s - 1;
+ }
+ }
+
+ // Maps from input state to output state.
+ StateId FindOState(StateId is) {
+ auto os = is;
+ if (!(superfinal_ == kNoStateId || is < superfinal_)) ++os;
+ if (os >= nstates_) nstates_ = os + 1;
+ return os;
+ }
+
+ std::unique_ptr<const Fst<A>> 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 A, class B, class C>
+class ArcMapFst : public ImplToFst<internal::ArcMapFstImpl<A, B, C>> {
+ public:
+ using Arc = B;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<B>;
+ using State = typename Store::State;
+ using Impl = internal::ArcMapFstImpl<A, B, C>;
+
+ friend class ArcIterator<ArcMapFst<A, B, C>>;
+ friend class StateIterator<ArcMapFst<A, B, C>>;
+
+ ArcMapFst(const Fst<A> &fst, const C &mapper, const ArcMapFstOptions &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, mapper, opts)) {}
+
+ ArcMapFst(const Fst<A> &fst, C *mapper, const ArcMapFstOptions &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, mapper, opts)) {}
+
+ ArcMapFst(const Fst<A> &fst, const C &mapper)
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, mapper, ArcMapFstOptions())) {}
+
+ ArcMapFst(const Fst<A> &fst, C *mapper)
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, mapper, ArcMapFstOptions())) {}
+
+ // See Fst<>::Copy() for doc.
+ ArcMapFst(const ArcMapFst<A, B, C> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this ArcMapFst. See Fst<>::Copy() for further doc.
+ ArcMapFst<A, B, C> *Copy(bool safe = false) const override {
+ return new ArcMapFst<A, B, C>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<B> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<B> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ protected:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ private:
+ ArcMapFst &operator=(const ArcMapFst &) = delete;
+};
+
+// Specialization for ArcMapFst.
+//
+// This may be derived from.
+template <class A, class B, class C>
+class StateIterator<ArcMapFst<A, B, C>> : public StateIteratorBase<B> {
+ public:
+ using StateId = typename B::StateId;
+
+ explicit StateIterator(const ArcMapFst<A, B, C> &fst)
+ : impl_(fst.GetImpl()),
+ siter_(*impl_->fst_),
+ s_(0),
+ superfinal_(impl_->final_action_ == MAP_REQUIRE_SUPERFINAL) {
+ CheckSuperfinal();
+ }
+
+ bool Done() const override { return siter_.Done() && !superfinal_; }
+
+ StateId Value() const override { return s_; }
+
+ void Next() override {
+ ++s_;
+ if (!siter_.Done()) {
+ siter_.Next();
+ CheckSuperfinal();
+ } else if (superfinal_) {
+ superfinal_ = false;
+ }
+ }
+
+ void Reset() override {
+ 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<A, B, C> *impl_;
+ StateIterator<Fst<A>> siter_;
+ StateId s_;
+ bool superfinal_; // True if there is a superfinal state and not done.
+};
+
+// Specialization for ArcMapFst.
+template <class A, class B, class C>
+class ArcIterator<ArcMapFst<A, B, C>>
+ : public CacheArcIterator<ArcMapFst<A, B, C>> {
+ public:
+ using StateId = typename A::StateId;
+
+ ArcIterator(const ArcMapFst<A, B, C> &fst, StateId s)
+ : CacheArcIterator<ArcMapFst<A, B, C>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class A, class B, class C>
+inline void ArcMapFst<A, B, C>::InitStateIterator(
+ StateIteratorData<B> *data) const {
+ data->base = new StateIterator<ArcMapFst<A, B, C>>(*this);
+}
+
+// Utility Mappers.
+
+// Mapper that returns its input.
+template <class A>
+class IdentityArcMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+
+ ToArc operator()(const FromArc &arc) const { return arc; }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const { return props; }
+};
+
+// Mapper that converts all input symbols to epsilon.
+template <class A>
+class InputEpsilonMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+
+ ToArc operator()(const FromArc &arc) const {
+ return ToArc(0, arc.olabel, arc.weight, arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_CLEAR_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return (props & kSetArcProperties) | kIEpsilons;
+ }
+};
+
+// Mapper that converts all output symbols to epsilon.
+template <class A>
+class OutputEpsilonMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+
+ ToArc operator()(const FromArc &arc) const {
+ return ToArc(arc.ilabel, 0, arc.weight, arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_CLEAR_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return (props & kSetArcProperties) | kOEpsilons;
+ }
+};
+
+// Mapper that returns its input with final states redirected to a single
+// super-final state.
+template <class A>
+class SuperFinalMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+
+ ToArc operator()(const FromArc &arc) const { 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 {
+ return props & kAddSuperFinalProperties;
+ }
+};
+
+// Mapper that leaves labels and nextstate unchanged and constructs a new weight
+// from the underlying value of the arc weight. Requires that there is a
+// WeightConvert class specialization that converts the weights.
+template <class A, class B>
+class WeightConvertMapper {
+ 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, convert_weight_(arc.weight),
+ arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const { return props; }
+
+ private:
+ WeightConvert<FromWeight, ToWeight> convert_weight_;
+};
+
+// Non-precision-changing weight conversions; consider using more efficient
+// Cast method instead.
+
+using StdToLogMapper = WeightConvertMapper<StdArc, LogArc>;
+
+using LogToStdMapper = WeightConvertMapper<LogArc, StdArc>;
+
+// Precision-changing weight conversions.
+
+using StdToLog64Mapper = WeightConvertMapper<StdArc, Log64Arc>;
+
+using LogToLog64Mapper = WeightConvertMapper<LogArc, Log64Arc>;
+
+using Log64ToStdMapper = WeightConvertMapper<Log64Arc, StdArc>;
+
+using Log64ToLogMapper = WeightConvertMapper<Log64Arc, LogArc>;
+
+// Mapper from A to GallicArc<A>.
+template <class A, GallicType G = GALLIC_LEFT>
+class ToGallicMapper {
+ public:
+ using FromArc = A;
+ using ToArc = GallicArc<A, G>;
+
+ using SW = StringWeight<typename A::Label, GALLIC_STRING_TYPE(G)>;
+ 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<A> to A.
+template <class A, GallicType G = GALLIC_LEFT>
+class FromGallicMapper {
+ public:
+ using FromArc = GallicArc<A, G>;
+ using ToArc = A;
+
+ using Label = typename ToArc::Label;
+ using AW = typename ToArc::Weight;
+ using GW = typename FromArc::Weight;
+
+ explicit FromGallicMapper(Label superfinal_label = 0)
+ : superfinal_label_(superfinal_label), error_(false) {}
+
+ ToArc operator()(const FromArc &arc) const {
+ // 'Super-non-final' arc.
+ if (arc.nextstate == kNoStateId && arc.weight == GW::Zero()) {
+ return A(arc.ilabel, 0, AW::Zero(), kNoStateId);
+ }
+ Label l = kNoLabel;
+ AW weight;
+ if (!Extract(arc.weight, &weight, &l) || arc.ilabel != arc.olabel) {
+ FSTERROR() << "FromGallicMapper: Unrepresentable weight: " << arc.weight
+ << " for arc with ilabel = " << arc.ilabel
+ << ", olabel = " << arc.olabel
+ << ", nextstate = " << arc.nextstate;
+ error_ = true;
+ }
+ if (arc.ilabel == 0 && l != 0 && arc.nextstate == kNoStateId) {
+ return ToArc(superfinal_label_, l, weight, arc.nextstate);
+ } else {
+ return ToArc(arc.ilabel, l, weight, arc.nextstate);
+ }
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_ALLOW_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_CLEAR_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 inprops) const {
+ uint64 outprops = inprops & kOLabelInvariantProperties &
+ kWeightInvariantProperties & kAddSuperFinalProperties;
+ if (error_) outprops |= kError;
+ return outprops;
+ }
+
+ private:
+ template <GallicType GT>
+ static bool Extract(const GallicWeight<Label, AW, GT> &gallic_weight,
+ typename A::Weight *weight, typename A::Label *label) {
+ const StringWeight<Label, GALLIC_STRING_TYPE(GT)> &w1 =
+ gallic_weight.Value1();
+ const AW &w2 = gallic_weight.Value2();
+ StringWeightIterator<Label, GALLIC_STRING_TYPE(GT)> 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<Label, AW, GALLIC> &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_RESTRICT>(gallic_weight.Back(), weight, label);
+ }
+
+ const Label superfinal_label_;
+ mutable bool error_;
+};
+
+// Mapper from GallicArc<A> to A.
+template <class A, GallicType G = GALLIC_LEFT>
+class GallicToNewSymbolsMapper {
+ public:
+ using FromArc = GallicArc<A, G>;
+ 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<Label, GALLIC_STRING_TYPE(G)>;
+
+ explicit GallicToNewSymbolsMapper(MutableFst<ToArc> *fst)
+ : fst_(fst),
+ lmax_(0),
+ osymbols_(fst->OutputSymbols()),
+ isymbols_(nullptr),
+ error_(false) {
+ fst_->DeleteStates();
+ state_ = fst_->AddState();
+ fst_->SetStart(state_);
+ fst_->SetFinal(state_, AW::One());
+ if (osymbols_) {
+ string name = osymbols_->Name() + "_from_gallic";
+ fst_->SetInputSymbols(new SymbolTable(name));
+ isymbols_ = fst_->MutableInputSymbols();
+ const int64 zero = 0;
+ isymbols_->AddSymbol(osymbols_->Find(zero), 0);
+ } else {
+ fst_->SetInputSymbols(nullptr);
+ }
+ }
+
+ ToArc operator()(const FromArc &arc) {
+ // Super-non-final arc.
+ if (arc.nextstate == kNoStateId && arc.weight == GW::Zero()) {
+ return ToArc(arc.ilabel, 0, AW::Zero(), kNoStateId);
+ }
+ SW w1 = arc.weight.Value1();
+ AW w2 = arc.weight.Value2();
+ Label l;
+ if (w1.Size() == 0) {
+ l = 0;
+ } else {
+ auto insert_result = map_.insert(std::make_pair(w1, kNoLabel));
+ if (!insert_result.second) {
+ l = insert_result.first->second;
+ } else {
+ l = ++lmax_;
+ insert_result.first->second = l;
+ StringWeightIterator<Label, GALLIC_STRING_TYPE(G)> iter1(w1);
+ StateId n;
+ string s;
+ for (auto i = 0, p = state_; i < w1.Size();
+ ++i, iter1.Next(), p = n) {
+ n = i == w1.Size() - 1 ? state_ : fst_->AddState();
+ fst_->AddArc(p, ToArc(i ? 0 : l, iter1.Value(), AW::One(), n));
+ if (isymbols_) {
+ if (i) s = s + "_";
+ s = s + osymbols_->Find(iter1.Value());
+ }
+ }
+ if (isymbols_) isymbols_->AddSymbol(s, l);
+ }
+ }
+ if (l == kStringInfinity || l == kStringBad || arc.ilabel != arc.olabel) {
+ FSTERROR() << "GallicToNewSymbolMapper: Unrepresentable weight: " << l;
+ error_ = true;
+ }
+ return ToArc(arc.ilabel, l, w2, arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_ALLOW_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_CLEAR_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 inprops) const {
+ uint64 outprops = inprops & kOLabelInvariantProperties &
+ kWeightInvariantProperties & kAddSuperFinalProperties;
+ if (error_) outprops |= kError;
+ return outprops;
+ }
+
+ private:
+ class StringKey {
+ public:
+ size_t operator()(const SW &x) const { return x.Hash(); }
+ };
+
+ using Map = std::unordered_map<SW, Label, StringKey>;
+
+ MutableFst<ToArc> *fst_;
+ Map map_;
+ Label lmax_;
+ StateId state_;
+ const SymbolTable *osymbols_;
+ SymbolTable *isymbols_;
+ mutable bool error_;
+};
+
+// Mapper to add a constant to all weights.
+template <class A>
+class PlusMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+ using Weight = typename FromArc::Weight;
+
+ explicit PlusMapper(Weight weight) : weight_(std::move(weight)) {}
+
+ ToArc operator()(const FromArc &arc) const {
+ if (arc.weight == Weight::Zero()) return arc;
+ return ToArc(arc.ilabel, arc.olabel, Plus(arc.weight, weight_),
+ arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return props & kWeightInvariantProperties;
+ }
+
+ private:
+ const Weight weight_;
+};
+
+// Mapper to (right) multiply a constant to all weights.
+template <class A>
+class TimesMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+ using Weight = typename FromArc::Weight;
+
+ explicit TimesMapper(Weight weight) : weight_(std::move(weight)) {}
+
+ ToArc operator()(const FromArc &arc) const {
+ if (arc.weight == Weight::Zero()) return arc;
+ return ToArc(arc.ilabel, arc.olabel, Times(arc.weight, weight_),
+ arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return props & kWeightInvariantProperties;
+ }
+
+ private:
+ const Weight weight_;
+};
+
+// Mapper to take all arc-weights to a fixed power.
+template <class A>
+class PowerMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+ using Weight = typename FromArc::Weight;
+
+ explicit PowerMapper(size_t power) : power_(power) {}
+
+ ToArc operator()(const FromArc &arc) const {
+ return ToArc(arc.ilabel, arc.olabel, Power(arc.weight, power_),
+ arc.nextstate);
+ }
+
+ MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ MapSymbolsAction InputSymbolsAction() const { return MAP_COPY_SYMBOLS; }
+
+ MapSymbolsAction OutputSymbolsAction() const { return MAP_COPY_SYMBOLS; }
+
+ uint64 Properties(uint64 props) const {
+ return props & kWeightInvariantProperties;
+ }
+
+ private:
+ size_t power_;
+};
+
+// Mapper to reciprocate all non-Zero() weights.
+template <class A>
+class InvertWeightMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+ using Weight = typename FromArc::Weight;
+
+ ToArc operator()(const FromArc &arc) const {
+ if (arc.weight == Weight::Zero()) return arc;
+ return ToArc(arc.ilabel, arc.olabel, Divide(Weight::One(), arc.weight),
+ arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return props & kWeightInvariantProperties;
+ }
+};
+
+// Mapper to map all non-Zero() weights to One().
+template <class A, class B = A>
+class RmWeightMapper {
+ public:
+ using FromArc = A;
+ using ToArc = B;
+ using FromWeight = typename FromArc::Weight;
+ using ToWeight = typename ToArc::Weight;
+
+ ToArc operator()(const FromArc &arc) const {
+ return ToArc(arc.ilabel, arc.olabel,
+ arc.weight != FromWeight::Zero() ?
+ ToWeight::One() : ToWeight::Zero(),
+ arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return (props & kWeightInvariantProperties) | kUnweighted;
+ }
+};
+
+// Mapper to quantize all weights.
+template <class A, class B = A>
+class QuantizeMapper {
+ public:
+ using FromArc = A;
+ using ToArc = B;
+ using FromWeight = typename FromArc::Weight;
+ using ToWeight = typename ToArc::Weight;
+
+ QuantizeMapper() : delta_(kDelta) {}
+
+ explicit QuantizeMapper(float d) : delta_(d) {}
+
+ ToArc operator()(const FromArc &arc) const {
+ return ToArc(arc.ilabel, arc.olabel, arc.weight.Quantize(delta_),
+ arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return props & kWeightInvariantProperties;
+ }
+
+ private:
+ const float delta_;
+};
+
+// Mapper from A to B under the assumption:
+//
+// B::Weight = A::Weight::ReverseWeight
+// B::Label == A::Label
+// B::StateId == A::StateId
+//
+// The weight is reversed, while the label and nextstate are preserved.
+template <class A, class B>
+class ReverseWeightMapper {
+ public:
+ using FromArc = A;
+ using ToArc = B;
+
+ ToArc operator()(const FromArc &arc) const {
+ return ToArc(arc.ilabel, arc.olabel, arc.weight.Reverse(), arc.nextstate);
+ }
+
+ constexpr MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_COPY_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) const { return props; }
+};
+
+} // namespace fst
+
+#endif // FST_LIB_ARC_MAP_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Commonly used FST arc types.
+
+#ifndef FST_LIB_ARC_H_
+#define FST_LIB_ARC_H_
+
+#include <string>
+#include <utility>
+
+
+#include <fst/expectation-weight.h>
+#include <fst/float-weight.h>
+#include <fst/lexicographic-weight.h>
+#include <fst/power-weight.h>
+#include <fst/product-weight.h>
+#include <fst/signed-log-weight.h>
+#include <fst/sparse-power-weight.h>
+#include <fst/string-weight.h>
+
+
+namespace fst {
+
+template <class W>
+struct ArcTpl {
+ public:
+ using Weight = W;
+ using Label = int;
+ using StateId = int;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ ArcTpl() {}
+
+ ArcTpl(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static const string type =
+ (Weight::Type() == "tropical") ? "standard" : Weight::Type();
+ return type;
+ }
+};
+
+using StdArc = ArcTpl<TropicalWeight>;
+using LogArc = ArcTpl<LogWeight>;
+using Log64Arc = ArcTpl<Log64Weight>;
+using SignedLogArc = ArcTpl<SignedLogWeight>;
+using SignedLog64Arc = ArcTpl<SignedLog64Weight>;
+using MinMaxArc = ArcTpl<MinMaxWeight>;
+
+// Arc with integer labels and state IDs and string weights.
+template <StringType S = STRING_LEFT>
+struct StringArc {
+ public:
+ using Label = int;
+ using Weight = StringWeight<int, S>;
+ using StateId = int;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ StringArc() = default;
+
+ StringArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static const string type =
+ 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 <class A, GallicType G = GALLIC_LEFT>
+struct GallicArc {
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = GallicWeight<Label, typename Arc::Weight, G>;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ GallicArc() = default;
+
+ GallicArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ explicit GallicArc(const Arc &arc)
+ : ilabel(arc.ilabel), olabel(arc.ilabel), weight(arc.olabel, arc.weight),
+ nextstate(arc.nextstate) {}
+
+ static const string &Type() {
+ static const string type =
+ (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 <class A>
+struct ReverseArc {
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using AWeight = typename Arc::Weight;
+ using Weight = typename AWeight::ReverseWeight;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ ReverseArc() = default;
+
+ ReverseArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static const string type = "reverse_" + Arc::Type();
+ return type;
+ }
+};
+
+// Arc with integer labels and state IDs and lexicographic weights.
+template <class Weight1, class Weight2>
+struct LexicographicArc {
+ using Label = int;
+ using StateId = int;
+ using Weight = LexicographicWeight<Weight1, Weight2>;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ LexicographicArc() = default;
+
+ LexicographicArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static const string type = Weight::Type();
+ return type;
+ }
+};
+
+// Arc with integer labels and state IDs and product weights.
+template <class Weight1, class Weight2>
+struct ProductArc {
+ using Label = int;
+ using StateId = int;
+ using Weight = ProductWeight<Weight1, Weight2>;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ ProductArc() = default;
+
+ ProductArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static const string type = 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 <class A, unsigned int N>
+struct PowerArc {
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = PowerWeight<typename Arc::Weight, N>;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ PowerArc() = default;
+
+ PowerArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static string type;
+ if (!type.empty()) return type;
+ string power;
+ Int64ToStr(N, &power);
+ type = Arc::Type() + "_^" + power;
+ 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 <class A, class K = int>
+struct SparsePowerArc {
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::Label;
+ using Weight = SparsePowerWeight<typename Arc::Weight, K>;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ SparsePowerArc() = default;
+
+ SparsePowerArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static string type;
+ if (!type.empty()) return type;
+ type = Arc::Type() + "_^n";
+ if (sizeof(K) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(K), &size);
+ type += "_" + size;
+ }
+ 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 <class A, class X2>
+struct ExpectationArc {
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using X1 = typename Arc::Weight;
+ using Weight = ExpectationWeight<X1, X2>;
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ StateId nextstate;
+
+ ExpectationArc() = default;
+
+ ExpectationArc(Label ilabel, Label olabel, Weight weight, StateId nextstate)
+ : ilabel(ilabel),
+ olabel(olabel),
+ weight(std::move(weight)),
+ nextstate(nextstate) {}
+
+ static const string &Type() {
+ static string type;
+ if (!type.empty()) return type;
+ type = "expectation_" + Arc::Type() + "_" + X2::Type();
+ return type;
+ }
+};
+
+} // namespace fst
+
+#endif // FST_LIB_ARC_H_
--- /dev/null
+// 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_LIB_ARCFILTER_H_
+#define FST_LIB_ARCFILTER_H_
+
+
+#include <fst/fst.h>
+#include <fst/util.h>
+
+
+namespace fst {
+
+// True for all arcs.
+template <class Arc>
+class AnyArcFilter {
+ public:
+ bool operator()(const Arc &arc) const { return true; }
+};
+
+// True for (input/output) epsilon arcs.
+template <class Arc>
+class EpsilonArcFilter {
+ public:
+ bool operator()(const Arc &arc) const {
+ return arc.ilabel == 0 && arc.olabel == 0;
+ }
+};
+
+// True for input epsilon arcs.
+template <class Arc>
+class InputEpsilonArcFilter {
+ public:
+ bool operator()(const Arc &arc) const { return arc.ilabel == 0; }
+};
+
+// True for output epsilon arcs.
+template <class Arc>
+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 Arc>
+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 Arc>
+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<Label, kNoLabel> labels_;
+ const bool match_input_;
+ const bool keep_match_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_ARCFILTER_H_
--- /dev/null
+// 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_LIB_ARCSORT_H_
+#define FST_LIB_ARCSORT_H_
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/state-map.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+template <class Arc, class Compare>
+class ArcSortMapper {
+ public:
+ using FromArc = Arc;
+ using ToArc = Arc;
+
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ ArcSortMapper(const Fst<Arc> &fst, const Compare &comp)
+ : fst_(fst), comp_(comp), i_(0) {}
+
+ // Allows updating Fst argument; pass only if changed.
+ ArcSortMapper(const ArcSortMapper<Arc, Compare> &mapper,
+ const Fst<Arc> *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<Fst<Arc>> 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<Arc> &fst_;
+ const Compare &comp_;
+ std::vector<Arc> 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 <class Arc, class Compare>
+void ArcSort(MutableFst<Arc> *fst, Compare comp) {
+ ArcSortMapper<Arc, Compare> 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 Arc, class Compare>
+class ArcSortFst : public StateMapFst<Arc, Arc, ArcSortMapper<Arc, Compare>> {
+ using StateMapFst<Arc, Arc, ArcSortMapper<Arc, Compare>>::GetImpl;
+
+ public:
+ using StateId = typename Arc::StateId;
+ using Mapper = ArcSortMapper<Arc, Compare>;
+
+ ArcSortFst(const Fst<Arc> &fst, const Compare &comp)
+ : StateMapFst<Arc, Arc, Mapper>(fst,
+ ArcSortMapper<Arc, Compare>(fst, comp)) {}
+
+ ArcSortFst(const Fst<Arc> &fst, const Compare &comp,
+ const ArcSortFstOptions &opts)
+ : StateMapFst<Arc, Arc, Mapper>(fst, Mapper(fst, comp), opts) {}
+
+ // See Fst<>::Copy() for doc.
+ ArcSortFst(const ArcSortFst<Arc, Compare> &fst, bool safe = false)
+ : StateMapFst<Arc, Arc, Mapper>(fst, safe) {}
+
+ // Gets a copy of this ArcSortFst. See Fst<>::Copy() for further doc.
+ ArcSortFst<Arc, Compare> *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 Arc, class Compare>
+class StateIterator<ArcSortFst<Arc, Compare>>
+ : public StateIterator<StateMapFst<Arc, Arc, ArcSortMapper<Arc, Compare>>> {
+ public:
+ explicit StateIterator(const ArcSortFst<Arc, Compare> &fst)
+ : StateIterator<StateMapFst<Arc, Arc, ArcSortMapper<Arc, Compare>>>(fst) {
+ }
+};
+
+// Specialization for ArcSortFst.
+template <class Arc, class Compare>
+class ArcIterator<ArcSortFst<Arc, Compare>>
+ : public ArcIterator<StateMapFst<Arc, Arc, ArcSortMapper<Arc, Compare>>> {
+ public:
+ ArcIterator(const ArcSortFst<Arc, Compare> &fst, typename Arc::StateId s)
+ : ArcIterator<StateMapFst<Arc, Arc, ArcSortMapper<Arc, Compare>>>(fst,
+ s) {}
+};
+
+// Compare class for comparing input labels of arcs.
+template <class Arc>
+class ILabelCompare {
+ public:
+ ILabelCompare() {}
+
+ bool operator()(const Arc &arc1, const Arc &arc2) const {
+ return arc1.ilabel < arc2.ilabel;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return (props & kArcSortProperties) | kILabelSorted |
+ (props & kAcceptor ? kOLabelSorted : 0);
+ }
+};
+
+// Compare class for comparing output labels of arcs.
+template <class Arc>
+class OLabelCompare {
+ public:
+ OLabelCompare() {}
+
+ bool operator()(const Arc &arc1, const Arc &arc2) const {
+ return arc1.olabel < arc2.olabel;
+ }
+
+ uint64 Properties(uint64 props) const {
+ return (props & kArcSortProperties) | kOLabelSorted |
+ (props & kAcceptor ? kILabelSorted : 0);
+ }
+};
+
+// Useful aliases when using StdArc.
+
+template <class Compare>
+using StdArcSortFst = ArcSortFst<StdArc, Compare>;
+
+using StdILabelCompare = ILabelCompare<StdArc>;
+
+using StdOLabelCompare = OLabelCompare<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_ARCSORT_H_
--- /dev/null
+// 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_LIB_BI_TABLE_H_
+#define FST_LIB_BI_TABLE_H_
+
+#include <deque>
+#include <memory>
+#include <functional>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <fst/memory.h>
+
+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 I, class T>
+// class BiTable {
+// public:
+//
+// // Required constructors.
+// BiTable();
+//
+// // Looks up integer ID from entry. If it doesn't exist and insert
+// / is true, adds it; otherwise, returns -1.
+// I FindId(const T &entry, bool insert = true);
+//
+// // Looks up entry from integer ID.
+// const T &FindEntry(I) const;
+//
+// // Returns number of stored entries.
+// I Size() const;
+// };
+
+// An implementation using a hash map for the entry to ID mapping. H is the
+// hash function and E is the equality function. If passed to the
+// constructor, ownership is given to this class.
+template <class I, class T, class H, class E = std::equal_to<T>>
+class HashBiTable {
+ public:
+ // Reserves space for 'table_size' elements. If passing H and E to the
+ // constructor, this class owns them.
+ explicit HashBiTable(size_t table_size = 0, H *h = nullptr, E *e = nullptr) :
+ hash_func_(h ? h : new H()), hash_equal_(e ? e : new E()),
+ entry2id_(table_size, *h, *e) {
+ if (table_size) id2entry_.reserve(table_size);
+ }
+
+ HashBiTable(const HashBiTable<I, T, H, E> &table)
+ : hash_func_(new H(*table.hash_func_)),
+ hash_equal_(new E(*table.hash_equal_)),
+ entry2id_(table.entry2id_.begin(), table.entry2id_.end(),
+ table.entry2id_.size(), *hash_func_, *hash_equal_),
+ id2entry_(table.id2entry_) {}
+
+ I FindId(const T &entry, bool insert = true) {
+ if (!insert) {
+ const auto it = entry2id_.find(entry);
+ return it == entry2id_.end() ? -1 : it->second - 1;
+ }
+ I &id_ref = entry2id_[entry];
+ if (id_ref == 0) { // T not found; stores and assigns a new ID.
+ id2entry_.push_back(entry);
+ id_ref = id2entry_.size();
+ }
+ return id_ref - 1; // NB: id_ref = ID + 1.
+ }
+
+ const T &FindEntry(I s) const { return id2entry_[s]; }
+
+ I Size() const { return id2entry_.size(); }
+
+ // TODO(riley): Add fancy clear-to-size, as in CompactHashBiTable.
+ void Clear() {
+ entry2id_.clear();
+ id2entry_.clear();
+ }
+
+ private:
+ std::unique_ptr<H> hash_func_;
+ std::unique_ptr<E> hash_equal_;
+ std::unordered_map<T, I, H, E> entry2id_;
+ std::vector<T> id2entry_;
+};
+
+// Enables alternative hash set representations below.
+enum HSType { HS_STL = 0, HS_DENSE = 1, HS_SPARSE = 2 };
+
+// Default hash set is STL hash_set.
+template <class K, class H, class E, HSType HS>
+struct HashSet : public std::unordered_set<K, H, E, PoolAllocator<K>> {
+ explicit HashSet(size_t n = 0, const H &h = H(), const E &e = E())
+ : std::unordered_set<K, H, E, PoolAllocator<K>>(n, h, e) {}
+
+ void rehash(size_t n) {}
+};
+
+// An implementation using a hash set for the entry to ID mapping. The hash set
+// holds keys which are either the ID or kCurrentKey. These keys can be mapped
+// to entries either by looking up in the entry vector or, if kCurrentKey, in
+// current_entry_. The hash and key equality functions map to entries first. H
+// is the hash function and E is the equality function. If passed to the
+// constructor, ownership is given to this class.
+template <class I, class T, class H, class E = std::equal_to<T>,
+ HSType HS = HS_DENSE>
+class CompactHashBiTable {
+ public:
+ friend class HashFunc;
+ friend class HashEqual;
+
+ // Reserves space for 'table_size' elements. If passing H and E to the
+ // constructor, this class owns them.
+ explicit CompactHashBiTable(size_t table_size = 0, H *h = nullptr,
+ E *e = nullptr) :
+ hash_func_(h ? h : new H()), hash_equal_(e ? e : new E()),
+ compact_hash_func_(*this), compact_hash_equal_(*this),
+ keys_(table_size, compact_hash_func_, compact_hash_equal_) {
+ if (table_size) id2entry_.reserve(table_size);
+ }
+
+ CompactHashBiTable(const CompactHashBiTable<I, T, H, E, HS> &table)
+ : hash_func_(new H(*table.hash_func_)),
+ hash_equal_(new E(*table.hash_equal_)),
+ compact_hash_func_(*this), compact_hash_equal_(*this),
+ keys_(table.keys_.size(), compact_hash_func_, compact_hash_equal_),
+ id2entry_(table.id2entry_) {
+ keys_.insert(table.keys_.begin(), table.keys_.end());
+ }
+
+ I FindId(const T &entry, bool insert = true) {
+ current_entry_ = &entry;
+ const auto it = keys_.find(kCurrentKey);
+ if (it == keys_.end()) { // T not found.
+ if (insert) { // Stores and assigns a new ID.
+ 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(); }
+
+ // 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 const I kCurrentKey; // -1.
+ static const I kEmptyKey; // -2.
+ static const I kDeletedKey; // -3.
+
+ class HashFunc {
+ public:
+ explicit HashFunc(const CompactHashBiTable &ht) : ht_(&ht) {}
+
+ size_t operator()(I k) const {
+ if (k >= kCurrentKey) {
+ return (*ht_->hash_func_)(ht_->Key2Entry(k));
+ } else {
+ return 0;
+ }
+ }
+
+ private:
+ const CompactHashBiTable *ht_;
+ };
+
+ class HashEqual {
+ public:
+ explicit HashEqual(const CompactHashBiTable &ht) : ht_(&ht) {}
+
+ bool operator()(I k1, I k2) const {
+ if (k1 >= kCurrentKey && k2 >= kCurrentKey) {
+ return (*ht_->hash_equal_)(ht_->Key2Entry(k1), ht_->Key2Entry(k2));
+ } else {
+ return k1 == k2;
+ }
+ }
+
+ private:
+ const CompactHashBiTable *ht_;
+ };
+
+ using KeyHashSet = HashSet<I, HashFunc, HashEqual, HS>;
+
+ const T &Key2Entry(I k) const {
+ if (k == kCurrentKey) {
+ return *current_entry_;
+ } else {
+ return id2entry_[k];
+ }
+ }
+
+ std::unique_ptr<H> hash_func_;
+ std::unique_ptr<E> hash_equal_;
+ HashFunc compact_hash_func_;
+ HashEqual compact_hash_equal_;
+ KeyHashSet keys_;
+ std::vector<T> id2entry_;
+ const T *current_entry_;
+};
+
+template <class I, class T, class H, class E, HSType HS>
+const I CompactHashBiTable<I, T, H, E, HS>::kCurrentKey = -1;
+
+template <class I, class T, class H, class E, HSType HS>
+const I CompactHashBiTable<I, T, H, E, HS>::kEmptyKey = -2;
+
+template <class I, class T, class H, class E, HSType HS>
+const I CompactHashBiTable<I, T, H, E, HS>::kDeletedKey = -3;
+
+// An implementation using a vector for the entry to ID mapping. It is passed a
+// function object FP that should fingerprint entries uniquely to an integer
+// that can used as a vector index. Normally, VectorBiTable constructs the FP
+// object. The user can instead pass in this object; in that case, VectorBiTable
+// takes its ownership.
+template <class I, class T, class FP>
+class VectorBiTable {
+ public:
+ // Reserves table_size cells of space. If passing FP argument to the
+ // constructor, this class owns it.
+ explicit VectorBiTable(FP *fp = nullptr, size_t table_size = 0) :
+ fp_(fp ? fp : new FP()) {
+ if (table_size) id2entry_.reserve(table_size);
+ }
+
+ VectorBiTable(const VectorBiTable<I, T, FP> &table)
+ : fp_(new FP(*table.fp_)), fp2id_(table.fp2id_),
+ id2entry_(table.id2entry_) {}
+
+ I FindId(const T &entry, bool insert = true) {
+ ssize_t fp = (*fp_)(entry);
+ if (fp >= fp2id_.size()) fp2id_.resize(fp + 1);
+ I &id_ref = fp2id_[fp];
+ if (id_ref == 0) { // T not found.
+ if (insert) { // Stores and assigns a new ID.
+ id2entry_.push_back(entry);
+ id_ref = id2entry_.size();
+ } else {
+ return -1;
+ }
+ }
+ return id_ref - 1; // NB: id_ref = ID + 1.
+ }
+
+ const T &FindEntry(I s) const { return id2entry_[s]; }
+
+ I Size() const { return id2entry_.size(); }
+
+ const FP &Fingerprint() const { return *fp_; }
+
+ private:
+ std::unique_ptr<FP> fp_;
+ std::vector<I> fp2id_;
+ std::vector<T> id2entry_;
+};
+
+// An implementation using a vector and a compact hash table. The selecting
+// functor S returns true for entries to be hashed in the vector. The
+// fingerprinting functor FP returns a unique fingerprint for each entry to be
+// hashed in the vector (these need to be suitable for indexing in a vector).
+// The hash functor H is used when hashing entry into the compact hash table.
+// If passed to the constructor, ownership is given to this class.
+template <class I, class T, class S, class FP, class H, HSType HS = HS_DENSE>
+class VectorHashBiTable {
+ public:
+ friend class HashFunc;
+ friend class HashEqual;
+
+ explicit VectorHashBiTable(S *s, FP *fp, H *h, size_t vector_size = 0,
+ size_t entry_size = 0)
+ : selector_(s), fp_(fp), h_(h), hash_func_(*this), hash_equal_(*this),
+ keys_(0, hash_func_, hash_equal_) {
+ if (vector_size) fp2id_.reserve(vector_size);
+ if (entry_size) id2entry_.reserve(entry_size);
+ }
+
+ VectorHashBiTable(const VectorHashBiTable<I, T, S, FP, H, HS> &table)
+ : selector_(new S(table.s_)), fp_(new FP(*table.fp_)),
+ h_(new H(*table.h_)), id2entry_(table.id2entry_),
+ fp2id_(table.fp2id_), hash_func_(*this), hash_equal_(*this),
+ keys_(table.keys_.size(), hash_func_, hash_equal_) {
+ keys_.insert(table.keys_.begin(), table.keys_.end());
+ }
+
+ I FindId(const T &entry, bool insert = true) {
+ if ((*selector_)(entry)) { // Uses the vector if selector_(entry) == true.
+ uint64 fp = (*fp_)(entry);
+ if (fp2id_.size() <= fp) fp2id_.resize(fp + 1, 0);
+ if (fp2id_[fp] == 0) { // T not found.
+ if (insert) { // Stores and assigns a new ID.
+ id2entry_.push_back(entry);
+ fp2id_[fp] = id2entry_.size();
+ } else {
+ return -1;
+ }
+ }
+ return fp2id_[fp] - 1; // NB: assoc_value = ID + 1.
+ } else { // Uses the hash table otherwise.
+ current_entry_ = &entry;
+ const auto it = keys_.find(kCurrentKey);
+ if (it == keys_.end()) {
+ if (insert) {
+ I key = id2entry_.size();
+ id2entry_.push_back(entry);
+ keys_.insert(key);
+ return key;
+ } else {
+ return -1;
+ }
+ } else {
+ return *it;
+ }
+ }
+ }
+
+ const T &FindEntry(I s) const { return id2entry_[s]; }
+
+ I Size() const { return id2entry_.size(); }
+
+ const S &Selector() const { return *selector_; }
+
+ const FP &Fingerprint() const { return *fp_; }
+
+ const H &Hash() const { return *h_; }
+
+ private:
+ static const I kCurrentKey; // -1.
+ static const 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<I, HashFunc, HashEqual, HS>;
+
+ const T &Key2Entry(I k) const {
+ if (k == kCurrentKey) {
+ return *current_entry_;
+ } else {
+ return id2entry_[k];
+ }
+ }
+
+ std::unique_ptr<S> selector_; // True if entry hashed into vector.
+ std::unique_ptr<FP> fp_; // Fingerprint used when hashing into vector.
+ std::unique_ptr<H> h_; // Hash fnc used when hashing into hash_set.
+
+ std::vector<T> id2entry_; // Maps state IDs to entry.
+ std::vector<I> 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 <class I, class T, class S, class FP, class H, HSType HS>
+const I VectorHashBiTable<I, T, S, FP, H, HS>::kCurrentKey = -1;
+
+template <class I, class T, class S, class FP, class H, HSType HS>
+const I VectorHashBiTable<I, T, S, FP, H, HS>::kEmptyKey = -3;
+
+// 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 I, class T, class F>
+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<T, I, F> entry2id_;
+ std::deque<T> id2entry_;
+ const T empty_entry_;
+ I first_; // I of first element in the deque.
+};
+
+} // namespace fst
+
+#endif // FST_LIB_BI_TABLE_H_
--- /dev/null
+// 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_LIB_CACHE_H_
+#define FST_LIB_CACHE_H_
+
+#include <functional>
+#include <unordered_map>
+using std::unordered_map;
+using std::unordered_multimap;
+#include <list>
+#include <vector>
+
+#include <fst/vector-fst.h>
+
+
+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 <class CacheStore>
+struct CacheImplOptions {
+ bool gc; // Enables GC.
+ size_t gc_limit; // Number of bytes allowed before GC.
+ CacheStore *store; // Cache store.
+ bool own_store; // Should CacheImpl takes ownership of the store?
+
+ explicit CacheImplOptions(bool gc = FLAGS_fst_default_cache_gc,
+ size_t gc_limit = FLAGS_fst_default_cache_gc_limit,
+ CacheStore *store = nullptr)
+ : gc(gc), gc_limit(gc_limit), store(store), own_store(true) {}
+
+ explicit CacheImplOptions(const CacheOptions &opts)
+ : gc(opts.gc), gc_limit(opts.gc_limit), store(nullptr), own_store(true) {}
+};
+
+// Cache flags.
+constexpr uint32 kCacheFinal = 0x0001; // Final weight has been cached.
+constexpr uint32 kCacheArcs = 0x0002; // Arcs have been cached.
+constexpr uint32 kCacheInit = 0x0004; // Initialized by GC.
+constexpr uint32 kCacheRecent = 0x0008; // Visited since GC.
+constexpr uint32 kCacheFlags =
+ kCacheFinal | kCacheArcs | kCacheInit | kCacheRecent;
+
+// Cache state, with arcs stored in a per-state std::vector.
+template <class A, class M = PoolAllocator<A>>
+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<CacheState<A, M>>::other;
+
+ // Provides STL allocator for arcs.
+ explicit CacheState(const ArcAllocator &alloc)
+ : final_(Weight::Zero()),
+ niepsilons_(0),
+ noepsilons_(0),
+ arcs_(alloc),
+ flags_(0),
+ ref_count_(0) {}
+
+ CacheState(const CacheState<A> &state, const ArcAllocator &alloc)
+ : final_(state.Final()),
+ niepsilons_(state.NumInputEpsilons()),
+ noepsilons_(state.NumOutputEpsilons()),
+ arcs_(state.arcs_.begin(), state.arcs_.end(), alloc),
+ flags_(state.Flags()),
+ ref_count_(0) {}
+
+ void Reset() {
+ final_ = Weight::Zero();
+ niepsilons_ = 0;
+ noepsilons_ = 0;
+ ref_count_ = 0;
+ flags_ = 0;
+ arcs_.clear();
+ }
+
+ Weight Final() const { return final_; }
+
+ size_t NumInputEpsilons() const { return niepsilons_; }
+
+ size_t NumOutputEpsilons() const { return noepsilons_; }
+
+ size_t NumArcs() const { return arcs_.size(); }
+
+ const Arc &GetArc(size_t n) const { return arcs_[n]; }
+
+ // Used by the ArcIterator<Fst<Arc>> efficient implementation.
+ const Arc *Arcs() const { return !arcs_.empty() ? &arcs_[0] : nullptr; }
+
+ // Accesses flags; used by the caller.
+ uint32 Flags() const { return flags_; }
+
+ // Accesses ref count; used by the caller.
+ int RefCount() const { return ref_count_; }
+
+ void SetFinal(Weight weight) { final_ = std::move(weight); }
+
+ void ReserveArcs(size_t n) { arcs_.reserve(n); }
+
+ // Adds one arc at a time with all needed book-keeping; use PushArc and
+ // SetArcs for a more efficient alternative.
+ void AddArc(const Arc &arc) {
+ arcs_.push_back(arc);
+ if (arc.ilabel == 0) ++niepsilons_;
+ if (arc.olabel == 0) ++noepsilons_;
+ }
+
+ // Adds one arc at a time with delayed book-keeping; finalize with SetArcs().
+ void PushArc(const Arc &arc) { arcs_.push_back(arc); }
+
+ // Finalizes arcs book-keeping; call only once.
+ void SetArcs() {
+ for (const auto &arc : arcs_) {
+ if (arc.ilabel == 0) ++niepsilons_;
+ if (arc.olabel == 0) ++noepsilons_;
+ }
+ }
+
+ // Modifies nth arc.
+ void SetArc(const Arc &arc, size_t n) {
+ if (arcs_[n].ilabel == 0) --niepsilons_;
+ if (arcs_[n].olabel == 0) --noepsilons_;
+ if (arc.ilabel == 0) ++niepsilons_;
+ if (arc.olabel == 0) ++noepsilons_;
+ arcs_[n] = arc;
+ }
+
+ // Deletes all arcs.
+ void DeleteArcs() {
+ niepsilons_ = 0;
+ noepsilons_ = 0;
+ arcs_.clear();
+ }
+
+ void DeleteArcs(size_t n) {
+ for (size_t i = 0; i < n; ++i) {
+ if (arcs_.back().ilabel == 0) --niepsilons_;
+ if (arcs_.back().olabel == 0) --noepsilons_;
+ arcs_.pop_back();
+ }
+ }
+
+ // Sets status flags; used by the caller.
+ void SetFlags(uint32 flags, uint32 mask) const {
+ flags_ &= ~mask;
+ flags_ |= flags;
+ }
+
+ // Mutates reference counts; used by the caller.
+
+ int IncrRefCount() const { return ++ref_count_; }
+
+ int DecrRefCount() const { return --ref_count_; }
+
+ // Used by the ArcIterator<Fst<Arc>> 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<Arc> *state, StateAllocator *alloc) {
+ if (state) {
+ state->~CacheState<Arc>();
+ alloc->deallocate(state, 1);
+ }
+ }
+
+ private:
+ Weight final_; // Final weight.
+ size_t niepsilons_; // # of input epsilons.
+ size_t noepsilons_; // # of output epsilons.
+ std::vector<Arc, ArcAllocator> arcs_; // Arcs representation.
+ mutable uint32 flags_;
+ mutable int ref_count_; // If 0, available for GC.
+};
+
+// Cache store, allocating and storing states, providing a mapping from state
+// IDs to cached states, and an iterator over these states. The state template
+// argument must implement the CacheState interface. The state for a StateId s
+// is constructed when requested by GetMutableState(s) if it is not yet stored.
+// Initially, a state has a reference count of zero, but the user may increment
+// or decrement this to control the time of destruction. In particular, a state
+// is destroyed when:
+//
+// 1. This instance is destroyed, or
+// 2. Clear() or Delete() is called, or
+// 3. Possibly (implementation-dependently) when:
+// - Garbage collection is enabled (as defined by opts.gc),
+// - The cache store size exceeds the limits (as defined by opts.gc_limits),
+// - The state's reference count is zero, and
+// - The state is not the most recently requested state.
+//
+// template <class S>
+// class CacheStore {
+// public:
+// using State = S;
+// using Arc = typename State::Arc;
+// using StateId = typename Arc::StateId;
+//
+// // Required constructors/assignment operators.
+// explicit CacheStore(const CacheOptions &opts);
+//
+// // Returns nullptr if state is not stored.
+// const State *GetState(StateId s);
+//
+// // Creates state if state is not stored.
+// State *GetMutableState(StateId s);
+//
+// // Similar to State::AddArc() but updates cache store book-keeping.
+// void AddArc(State *state, const Arc &arc);
+//
+// // Similar to State::SetArcs() but updates cache store book-keeping; call
+// // only once.
+// void SetArcs(State *state);
+//
+// // Similar to State::DeleteArcs() but updates cache store book-keeping.
+//
+// void DeleteArcs(State *state);
+//
+// void DeleteArcs(State *state, size_t n);
+//
+// // Deletes all cached states.
+// void Clear();
+//
+// // Iterates over cached states (in an arbitrary order); only needed if
+// // opts.gc is true.
+// bool Done() const; // End of iteration.
+// StateId Value() const; // Current state.
+// void Next(); // Advances to next state (when !Done).
+// void Reset(); // Returns to initial condition.
+// void Delete(); // Deletes current state and advances to next.
+// };
+
+// Container cache stores.
+
+// This class uses a vector of pointers to states to store cached states.
+template <class S>
+class VectorCacheStore {
+ public:
+ using State = S;
+ using Arc = typename State::Arc;
+ using StateId = typename Arc::StateId;
+ using StateList = std::list<StateId, PoolAllocator<StateId>>;
+
+ // Required constructors/assignment operators.
+ explicit VectorCacheStore(const CacheOptions &opts) : cache_gc_(opts.gc) {
+ Clear();
+ Reset();
+ }
+
+ VectorCacheStore(const VectorCacheStore<S> &store)
+ : cache_gc_(store.cache_gc_) {
+ CopyStates(store);
+ Reset();
+ }
+
+ ~VectorCacheStore() { Clear(); }
+
+ VectorCacheStore<State> &operator=(const VectorCacheStore<State> &store) {
+ if (this != &store) {
+ CopyStates(store);
+ Reset();
+ }
+ return *this;
+ }
+
+ // Returns nullptr if state is not stored.
+ const State *GetState(StateId s) const {
+ return s < state_vec_.size() ? state_vec_[s] : nullptr;
+ }
+
+ // Creates state if state is not stored.
+ State *GetMutableState(StateId s) {
+ State *state = nullptr;
+ if (s >= state_vec_.size()) {
+ state_vec_.resize(s + 1, nullptr);
+ } else {
+ state = state_vec_[s];
+ }
+ if (!state) {
+ state = new (&state_alloc_) State(arc_alloc_);
+ state_vec_[s] = state;
+ if (cache_gc_) state_list_.push_back(s);
+ }
+ return state;
+ }
+
+ // Similar to State::AddArc() but updates cache store book-keeping
+ void AddArc(State *state, const Arc &arc) { state->AddArc(arc); }
+
+ // Similar to State::SetArcs() but updates cache store book-keeping; call
+ // only once.
+ void SetArcs(State *state) { state->SetArcs(); }
+
+ // Deletes all arcs.
+ void DeleteArcs(State *state) { state->DeleteArcs(); }
+
+ // Deletes some arcs.
+ void DeleteArcs(State *state, size_t n) { state->DeleteArcs(n); }
+
+ // Deletes all cached states.
+ void Clear() {
+ for (StateId s = 0; s < state_vec_.size(); ++s) {
+ State::Destroy(state_vec_[s], &state_alloc_);
+ }
+ state_vec_.clear();
+ state_list_.clear();
+ }
+
+ // Iterates over cached states (in an arbitrary order); only works if GC is
+ // enabled (o.w. avoiding state_list_ overhead).
+ bool Done() const { return iter_ == state_list_.end(); }
+
+ StateId Value() const { return *iter_; }
+
+ void Next() { ++iter_; }
+
+ void Reset() { iter_ = state_list_.begin(); }
+
+ // Deletes current state and advances to next.
+ void Delete() {
+ State::Destroy(state_vec_[*iter_], &state_alloc_);
+ state_vec_[*iter_] = nullptr;
+ state_list_.erase(iter_++);
+ }
+
+ private:
+ void CopyStates(const VectorCacheStore<State> &store) {
+ Clear();
+ state_vec_.reserve(store.state_vec_.size());
+ for (StateId s = 0; s < store.state_vec_.size(); ++s) {
+ State *state = nullptr;
+ const auto *store_state = store.state_vec_[s];
+ if (store_state) {
+ state = new (&state_alloc_) State(*store_state, arc_alloc_);
+ if (cache_gc_) state_list_.push_back(s);
+ }
+ state_vec_.push_back(state);
+ }
+ }
+
+ bool cache_gc_; // Supports iteration when true.
+ std::vector<State *> 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 S>
+class HashCacheStore {
+ public:
+ using State = S;
+ using Arc = typename State::Arc;
+ using StateId = typename Arc::StateId;
+
+ using StateMap =
+ std::unordered_map<StateId, State *, std::hash<StateId>,
+ std::equal_to<StateId>,
+ PoolAllocator<std::pair<const StateId, State *>>>;
+
+ // Required constructors/assignment operators.
+ explicit HashCacheStore(const CacheOptions &opts) {
+ Clear();
+ Reset();
+ }
+
+ HashCacheStore(const HashCacheStore<S> &store) {
+ CopyStates(store);
+ Reset();
+ }
+
+ ~HashCacheStore() { Clear(); }
+
+ HashCacheStore<State> &operator=(const HashCacheStore<State> &store) {
+ if (this != &store) {
+ CopyStates(store);
+ Reset();
+ }
+ return *this;
+ }
+
+ // Returns nullptr if state is not stored.
+ const State *GetState(StateId s) const {
+ const auto it = state_map_.find(s);
+ return it != state_map_.end() ? it->second : nullptr;
+ }
+
+ // Creates state if state is not stored.
+ State *GetMutableState(StateId s) {
+ auto *&state = state_map_[s];
+ if (!state) state = new (&state_alloc_) State(arc_alloc_);
+ return state;
+ }
+
+ // Similar to State::AddArc() but updates cache store book-keeping.
+ void AddArc(State *state, const Arc &arc) { state->AddArc(arc); }
+
+ // Similar to State::SetArcs() but updates internal cache size; call only
+ // once.
+ void SetArcs(State *state) { state->SetArcs(); }
+
+ // Deletes all arcs.
+ void DeleteArcs(State *state) { state->DeleteArcs(); }
+
+ // Deletes some arcs.
+ void DeleteArcs(State *state, size_t n) { state->DeleteArcs(n); }
+
+ // Deletes all cached states.
+ void Clear() {
+ for (auto it = state_map_.begin(); it != state_map_.end(); ++it) {
+ State::Destroy(it->second, &state_alloc_);
+ }
+ state_map_.clear();
+ }
+
+ // Iterates over cached states (in an arbitrary order).
+ bool Done() const { return iter_ == state_map_.end(); }
+
+ StateId Value() const { return iter_->first; }
+
+ void Next() { ++iter_; }
+
+ void Reset() { iter_ = state_map_.begin(); }
+
+ // Deletes current state and advances to next.
+ void Delete() {
+ State::Destroy(iter_->second, &state_alloc_);
+ state_map_.erase(iter_++);
+ }
+
+ private:
+ void CopyStates(const HashCacheStore<State> &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 CacheStore>
+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<CacheStore> &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<CacheStore> &operator=(
+ const FirstCacheStore<CacheStore> &store) {
+ if (this != &store) {
+ store_ = store.store_;
+ cache_gc_ = store.cache_gc_;
+ cache_first_state_id_ = store.cache_first_state_id_;
+ cache_first_state_ = store.cache_first_state_id_ != kNoStateId
+ ? store_.GetMutableState(0)
+ : nullptr;
+ }
+ return *this;
+ }
+
+ // Returns nullptr if state is not stored.
+ const State *GetState(StateId s) const {
+ // store_ state 0 may hold first cached state; the rest are shifted by 1.
+ return s == cache_first_state_id_ ? cache_first_state_
+ : store_.GetState(s + 1);
+ }
+
+ // Creates state if state is not stored.
+ State *GetMutableState(StateId s) {
+ // store_ state 0 used to hold first cached state; the rest are shifted by
+ // 1.
+ if (cache_first_state_id_ == s) {
+ return cache_first_state_; // Request for first cached state.
+ }
+ if (cache_gc_) {
+ if (cache_first_state_id_ == kNoStateId) {
+ cache_first_state_id_ = s; // Sets first cached state.
+ cache_first_state_ = store_.GetMutableState(0);
+ cache_first_state_->SetFlags(kCacheInit, kCacheInit);
+ cache_first_state_->ReserveArcs(2 * kAllocSize);
+ return cache_first_state_;
+ } else if (cache_first_state_->RefCount() == 0) {
+ cache_first_state_id_ = s; // Updates first cached state.
+ cache_first_state_->Reset();
+ cache_first_state_->SetFlags(kCacheInit, kCacheInit);
+ return cache_first_state_;
+ } else { // Keeps first cached state.
+ cache_first_state_->SetFlags(0, kCacheInit); // Clears initialized bit.
+ cache_gc_ = false; // Disables GC.
+ }
+ }
+ auto *state = store_.GetMutableState(s + 1);
+ return state;
+ }
+
+ // Similar to State::AddArc() but updates cache store book-keeping.
+ void AddArc(State *state, const Arc &arc) { store_.AddArc(state, arc); }
+
+ // Similar to State::SetArcs() but updates internal cache size; call only
+ // once.
+ void SetArcs(State *state) { store_.SetArcs(state); }
+
+ // Deletes all arcs
+ void DeleteArcs(State *state) { store_.DeleteArcs(state); }
+
+ // Deletes some arcs
+ void DeleteArcs(State *state, size_t n) { store_.DeleteArcs(state, n); }
+
+ // Deletes all cached states
+ void Clear() {
+ store_.Clear();
+ cache_first_state_id_ = kNoStateId;
+ cache_first_state_ = nullptr;
+ }
+
+ // Iterates over cached states (in an arbitrary order). Only needed if GC is
+ // enabled.
+ bool Done() const { return store_.Done(); }
+
+ StateId Value() const {
+ // store_ state 0 may hold first cached state; rest shifted + 1.
+ const auto s = store_.Value();
+ return s ? s - 1 : cache_first_state_id_;
+ }
+
+ void Next() { store_.Next(); }
+
+ void Reset() { store_.Reset(); }
+
+ // Deletes current state and advances to next.
+ void Delete() {
+ if (Value() == cache_first_state_id_) {
+ cache_first_state_id_ = kNoStateId;
+ cache_first_state_ = nullptr;
+ }
+ store_.Delete();
+ }
+
+ private:
+ CacheStore store_; // Underlying store.
+ bool cache_gc_; // GC enabled.
+ StateId cache_first_state_id_; // First cached state ID.
+ State *cache_first_state_; // First cached state.
+};
+
+// This class implements mark-sweep garbage collection on an underlying cache
+// store. If GC is enabled, garbage collection of states is performed in a
+// rough approximation of LRU order once when 'gc_limit' bytes is reached. The
+// caller can increment the reference count to inhibit the GC of in-use state
+// (e.g., in an ArcIterator). With GC enabled, the 'gc_limit' parameter allows
+// the caller to trade-off time vs. space.
+template <class CacheStore>
+class GCCacheStore {
+ public:
+ using State = typename CacheStore::State;
+ using Arc = typename State::Arc;
+ using StateId = typename Arc::StateId;
+
+ // Required constructors/assignment operators.
+ explicit GCCacheStore(const CacheOptions &opts)
+ : store_(opts),
+ cache_gc_request_(opts.gc),
+ cache_limit_(opts.gc_limit > kMinCacheLimit ? opts.gc_limit
+ : kMinCacheLimit),
+ cache_gc_(false),
+ cache_size_(0) {}
+
+ // Returns 0 if state is not stored.
+ const State *GetState(StateId s) const { return store_.GetState(s); }
+
+ // Creates state if state is not stored
+ State *GetMutableState(StateId s) {
+ auto *state = store_.GetMutableState(s);
+ if (cache_gc_request_ && !(state->Flags() & kCacheInit)) {
+ state->SetFlags(kCacheInit, kCacheInit);
+ cache_size_ += sizeof(State) + state->NumArcs() * sizeof(Arc);
+ // GC is enabled once an uninited state (from underlying store) is seen.
+ cache_gc_ = true;
+ if (cache_size_ > cache_limit_) GC(state, false);
+ }
+ return state;
+ }
+
+ // Similar to State::AddArc() but updates cache store book-keeping.
+ void AddArc(State *state, const Arc &arc) {
+ store_.AddArc(state, arc);
+ if (cache_gc_ && (state->Flags() & kCacheInit)) {
+ cache_size_ += sizeof(Arc);
+ if (cache_size_ > cache_limit_) GC(state, false);
+ }
+ }
+
+ // Similar to State::SetArcs() but updates internal cache size; call only
+ // once.
+ void SetArcs(State *state) {
+ store_.SetArcs(state);
+ if (cache_gc_ && (state->Flags() & kCacheInit)) {
+ cache_size_ += state->NumArcs() * sizeof(Arc);
+ if (cache_size_ > cache_limit_) GC(state, false);
+ }
+ }
+
+ // Deletes all arcs.
+ void DeleteArcs(State *state) {
+ if (cache_gc_ && (state->Flags() & kCacheInit)) {
+ cache_size_ -= state->NumArcs() * sizeof(Arc);
+ }
+ store_.DeleteArcs(state);
+ }
+
+ // Deletes some arcs.
+ void DeleteArcs(State *state, size_t n) {
+ if (cache_gc_ && (state->Flags() & kCacheInit)) {
+ cache_size_ -= n * sizeof(Arc);
+ }
+ store_.DeleteArcs(state, n);
+ }
+
+ // Deletes all cached states.
+ void Clear() {
+ store_.Clear();
+ cache_size_ = 0;
+ }
+
+ // Iterates over cached states (in an arbitrary order); only needed if GC is
+ // enabled.
+ bool Done() const { return store_.Done(); }
+
+ StateId Value() const { return store_.Value(); }
+
+ void Next() { store_.Next(); }
+
+ void Reset() { store_.Reset(); }
+
+ // Deletes current state and advances to next.
+ void Delete() {
+ if (cache_gc_) {
+ const auto *state = store_.GetState(Value());
+ if (state->Flags() & kCacheInit) {
+ cache_size_ -= sizeof(State) + state->NumArcs() * sizeof(Arc);
+ }
+ }
+ store_.Delete();
+ }
+
+ // Removes from the cache store (not referenced-counted and not the current)
+ // states that have not been accessed since the last GC until at most
+ // cache_fraction * cache_limit_ bytes are cached. If that fails to free
+ // enough, attempts to uncaching recently visited states as well. If still
+ // unable to free enough memory, then widens cache_limit_.
+ void GC(const State *current, bool free_recent, float cache_fraction = 0.666);
+
+ // Returns the current cache size in bytes or 0 if GC is disabled.
+ size_t CacheSize() const { return cache_size_; }
+
+ // Returns the cache limit in bytes.
+ size_t CacheLimit() const { return cache_limit_; }
+
+ private:
+ static constexpr size_t kMinCacheLimit = 8096; // Minimum cache limit.
+
+ CacheStore store_; // Underlying store.
+ bool cache_gc_request_; // GC requested but possibly not yet enabled.
+ size_t cache_limit_; // Number of bytes allowed before GC.
+ bool cache_gc_; // GC enabled
+ size_t cache_size_; // Number of bytes cached.
+};
+
+template <class CacheStore>
+void GCCacheStore<CacheStore>::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);
+ CHECK_LE(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 <class CacheStore>
+constexpr size_t GCCacheStore<CacheStore>::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 Arc>
+class DefaultCacheStore
+ : public GCCacheStore<FirstCacheStore<VectorCacheStore<CacheState<Arc>>>> {
+ public:
+ explicit DefaultCacheStore(const CacheOptions &opts)
+ : GCCacheStore<FirstCacheStore<VectorCacheStore<CacheState<Arc>>>>(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 State,
+ class CacheStore = DefaultCacheStore<typename State::Arc>>
+class CacheBaseImpl : public FstImpl<typename State::Arc> {
+ public:
+ using Arc = typename State::Arc;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = CacheStore;
+
+ using FstImpl<Arc>::Type;
+ using FstImpl<Arc>::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<CacheStore> &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<State, CacheStore> &impl,
+ bool preserve_cache = false)
+ : FstImpl<Arc>(),
+ has_start_(false),
+ cache_start_(kNoStateId),
+ nknown_states_(0),
+ min_unexpanded_state_id_(0),
+ max_expanded_state_id_(-1),
+ cache_gc_(impl.cache_gc_),
+ cache_limit_(impl.cache_limit_),
+ cache_store_(new CacheStore(CacheOptions(cache_gc_, cache_limit_))),
+ new_cache_store_(impl.new_cache_store_ || !preserve_cache),
+ own_cache_store_(true) {
+ if (preserve_cache) {
+ *cache_store_ = *impl.cache_store_;
+ has_start_ = impl.has_start_;
+ cache_start_ = impl.cache_start_;
+ nknown_states_ = impl.nknown_states_;
+ expanded_states_ = impl.expanded_states_;
+ min_unexpanded_state_id_ = impl.min_unexpanded_state_id_;
+ max_expanded_state_id_ = impl.max_expanded_state_id_;
+ }
+ }
+
+ ~CacheBaseImpl() override { if (own_cache_store_) delete cache_store_; }
+
+ void SetStart(StateId s) {
+ cache_start_ = s;
+ has_start_ = true;
+ if (s >= nknown_states_) nknown_states_ = s + 1;
+ }
+
+ void SetFinal(StateId s, Weight weight) {
+ auto *state = cache_store_->GetMutableState(s);
+ state->SetFinal(std::move(weight));
+ static constexpr auto flags = kCacheFinal | kCacheRecent;
+ state->SetFlags(flags, flags);
+ }
+
+// Disabled to ensure PushArc not AddArc is used in existing code
+// TODO(sorenj): re-enable for backing store
+#if 0
+ // AddArc adds a single arc to a state and does incremental cache
+ // book-keeping. For efficiency, prefer PushArc and SetArcs below
+ // when possible.
+ void AddArc(StateId s, const Arc &arc) {
+ auto *state = cache_store_->GetMutableState(s);
+ cache_store_->AddArc(state, arc);
+ if (arc.nextstate >= nknown_states_)
+ nknown_states_ = arc.nextstate + 1;
+ SetExpandedState(s);
+ static constexpr auto flags = kCacheArcs | kCacheRecent;
+ state->SetFlags(flags, flags);
+ }
+#endif
+
+ // Adds a single arc to a state but delays cache book-keeping. SetArcs must
+ // be called when all PushArc calls at a state are complete. Do not mix with
+ // calls to AddArc.
+ void PushArc(StateId s, const Arc &arc) {
+ auto *state = cache_store_->GetMutableState(s);
+ state->PushArc(arc);
+ }
+
+ // Marks arcs of a state as cached and does cache book-keeping after all
+ // calls to PushArc have been completed. Do not mix with calls to AddArc.
+ void SetArcs(StateId s) {
+ auto *state = cache_store_->GetMutableState(s);
+ cache_store_->SetArcs(state);
+ const auto narcs = state->NumArcs();
+ for (size_t a = 0; a < narcs; ++a) {
+ const auto &arc = state->GetArc(a);
+ if (arc.nextstate >= nknown_states_) nknown_states_ = arc.nextstate + 1;
+ }
+ SetExpandedState(s);
+ static constexpr auto flags = kCacheArcs | kCacheRecent;
+ state->SetFlags(flags, flags);
+ }
+
+ void ReserveArcs(StateId s, size_t n) {
+ auto *state = cache_store_->GetMutableState(s);
+ state->ReserveArcs(n);
+ }
+
+ void DeleteArcs(StateId s) {
+ auto *state = cache_store_->GetMutableState(s);
+ cache_store_->DeleteArcs(state);
+ }
+
+ void DeleteArcs(StateId s, size_t n) {
+ auto *state = cache_store_->GetMutableState(s);
+ cache_store_->DeleteArcs(state, n);
+ }
+
+ void Clear() {
+ nknown_states_ = 0;
+ min_unexpanded_state_id_ = 0;
+ max_expanded_state_id_ = -1;
+ has_start_ = false;
+ cache_start_ = kNoStateId;
+ cache_store_->Clear();
+ }
+
+ // Is the start state cached?
+ bool HasStart() const {
+ if (!has_start_ && Properties(kError)) has_start_ = true;
+ return has_start_;
+ }
+
+ // Is the final weight of the state cached?
+ bool HasFinal(StateId s) const {
+ const auto *state = cache_store_->GetState(s);
+ if (state && state->Flags() & kCacheFinal) {
+ state->SetFlags(kCacheRecent, kCacheRecent);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ // Are arcs of the state cached?
+ bool HasArcs(StateId s) const {
+ const auto *state = cache_store_->GetState(s);
+ if (state && state->Flags() & kCacheArcs) {
+ state->SetFlags(kCacheRecent, kCacheRecent);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ StateId Start() const { return cache_start_; }
+
+ Weight Final(StateId s) const {
+ const auto *state = cache_store_->GetState(s);
+ return state->Final();
+ }
+
+ size_t NumArcs(StateId s) const {
+ const auto *state = cache_store_->GetState(s);
+ return state->NumArcs();
+ }
+
+ size_t NumInputEpsilons(StateId s) const {
+ const auto *state = cache_store_->GetState(s);
+ return state->NumInputEpsilons();
+ }
+
+ size_t NumOutputEpsilons(StateId s) const {
+ const auto *state = cache_store_->GetState(s);
+ return state->NumOutputEpsilons();
+ }
+
+ // Provides information needed for generic arc iterator.
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *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) {
+ while (expanded_states_.size() <= s) expanded_states_.push_back(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<bool> 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 Arc>
+class CacheImpl : public CacheBaseImpl<CacheState<Arc>> {
+ public:
+ using State = CacheState<Arc>;
+
+ CacheImpl() {}
+
+ explicit CacheImpl(const CacheOptions &opts)
+ : CacheBaseImpl<CacheState<Arc>>(opts) {}
+
+ CacheImpl(const CacheImpl<Arc> &impl, bool preserve_cache = false)
+ : CacheBaseImpl<State>(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 FST>
+class CacheStateIterator : public StateIteratorBase<typename FST::Arc> {
+ 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<State, Store>;
+
+ CacheStateIterator(const FST &fst, Impl *impl)
+ : fst_(fst), impl_(impl), s_(0) {
+ fst_.Start(); // Forces start state.
+ }
+
+ bool Done() const override {
+ if (s_ < impl_->NumKnownStates()) return false;
+ for (StateId u = impl_->MinUnexpandedState(); u < impl_->NumKnownStates();
+ u = impl_->MinUnexpandedState()) {
+ // Forces state expansion.
+ ArcIterator<FST> 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 override { return s_; }
+
+ void Next() override { ++s_; }
+
+ void Reset() override { 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 FST>
+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<State, Store>;
+
+ CacheArcIterator(Impl *impl, StateId s) : i_(0) {
+ state_ = impl->GetCacheStore()->GetMutableState(s);
+ state_->IncrRefCount();
+ }
+
+ ~CacheArcIterator() { state_->DecrRefCount(); }
+
+ bool Done() const { return i_ >= state_->NumArcs(); }
+
+ const Arc &Value() const { return state_->GetArc(i_); }
+
+ void Next() { ++i_; }
+
+ size_t Position() const { return i_; }
+
+ void Reset() { i_ = 0; }
+
+ void Seek(size_t a) { i_ = a; }
+
+ constexpr uint32 Flags() const { return kArcValueFlags; }
+
+ void SetFlags(uint32 flags, uint32 mask) {}
+
+ private:
+ const State *state_;
+ size_t i_;
+
+ CacheArcIterator(const CacheArcIterator &) = delete;
+ CacheArcIterator &operator=(const CacheArcIterator &) = delete;
+};
+
+// Use this to make a mutable arc iterator for a CacheBaseImpl-derived FST,
+// which must have types 'Arc' and 'Store' defined.
+template <class FST>
+class CacheMutableArcIterator
+ : public MutableArcIteratorBase<typename FST::Arc> {
+ 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<State, Store>;
+
+ // 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 override { return i_ >= state_->NumArcs(); }
+
+ const Arc &Value() const override { return state_->GetArc(i_); }
+
+ void Next() override { ++i_; }
+
+ size_t Position() const override { return i_; }
+
+ void Reset() override { i_ = 0; }
+
+ void Seek(size_t a) override { i_ = a; }
+
+ void SetValue(const Arc &arc) override { state_->SetArc(arc, i_); }
+
+ constexpr uint32 Flags() const override { return kArcValueFlags; }
+
+ void SetFlags(uint32, uint32) override {}
+
+ 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 CacheStore>
+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 <class Expander>
+ State *FindOrExpand(Expander &expander, StateId s) { // NOLINT
+ auto *state = store_.GetMutableState(s);
+ if (state->Flags()) {
+ state->SetFlags(kCacheRecent, kCacheRecent);
+ } else {
+ StateBuilder builder(state);
+ expander.Expand(s, &builder);
+ state->SetFlags(kCacheFlags, kCacheFlags);
+ store_.SetArcs(state);
+ }
+ return state;
+ }
+
+ private:
+ CacheStore store_;
+
+ struct StateBuilder {
+ State *state;
+
+ explicit StateBuilder(State *state_) : state(state_) {}
+
+ void AddArc(const Arc &arc) { state->PushArc(arc); }
+
+ void SetFinal(Weight weight) { state->SetFinal(std::move(weight)); }
+ };
+};
+
+} // namespace fst
+
+#endif // FST_LIB_CACHE_H_
--- /dev/null
+// 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_LIB_CLOSURE_H_
+#define FST_LIB_CLOSURE_H_
+
+#include <algorithm>
+#include <vector>
+
+#include <fst/mutable-fst.h>
+#include <fst/rational.h>
+
+
+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 <class Arc>
+void Closure(MutableFst<Arc> *fst, ClosureType closure_type) {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ const auto props = fst->Properties(kFstProperties, false);
+ const auto start = fst->Start();
+ for (StateIterator<MutableFst<Arc>> siter(*fst); !siter.Done();
+ siter.Next()) {
+ const auto s = siter.Value();
+ const auto weight = fst->Final(s);
+ if (weight != Weight::Zero()) fst->AddArc(s, Arc(0, 0, weight, start));
+ }
+ if (closure_type == CLOSURE_STAR) {
+ fst->ReserveStates(fst->NumStates() + 1);
+ const auto nstart = fst->AddState();
+ fst->SetStart(nstart);
+ fst->SetFinal(nstart, Weight::One());
+ if (start != kNoLabel) fst->AddArc(nstart, Arc(0, 0, Weight::One(), start));
+ }
+ fst->SetProperties(ClosureProperties(props, closure_type == CLOSURE_STAR),
+ kFstProperties);
+}
+
+// Computes the concatenative closure. This version modifies its
+// RationalFst input.
+template <class Arc>
+void Closure(RationalFst<Arc> *fst, ClosureType closure_type) {
+ fst->GetMutableImpl()->AddClosure(closure_type);
+}
+
+struct ClosureFstOptions : RationalFstOptions {
+ ClosureType type;
+
+ ClosureFstOptions(const RationalFstOptions &opts,
+ ClosureType type = CLOSURE_STAR)
+ : RationalFstOptions(opts), type(type) {}
+
+ explicit ClosureFstOptions(ClosureType type = CLOSURE_STAR) : type(type) {}
+};
+
+// Computes the concatenative closure. This version is a delayed FST. If an FST
+// transduces string x to y with weight a, then its closure transduces x to y
+// with weight a, xx to yy with weight Times(a, a), xxx to yyy with weight
+// Times(Times(a, a), a), etc. If closure_type == CLOSURE_STAR, then the empty
+// string is transduced to itself with weight Weight::One() as well.
+//
+// Complexity:
+//
+// Time: O(v)
+// Space: O(v)
+//
+// where v is the number of states visited. Constant time and space to visit an
+// input state or arc is assumed and exclusive of caching.
+template <class A>
+class ClosureFst : public RationalFst<A> {
+ public:
+ using Arc = A;
+
+ ClosureFst(const Fst<Arc> &fst, ClosureType closure_type) {
+ GetMutableImpl()->InitClosure(fst, closure_type);
+ }
+
+ ClosureFst(const Fst<Arc> &fst, const ClosureFstOptions &opts)
+ : RationalFst<A>(opts) {
+ GetMutableImpl()->InitClosure(fst, opts.type);
+ }
+
+ // See Fst<>::Copy() for doc.
+ ClosureFst(const ClosureFst<Arc> &fst, bool safe = false)
+ : RationalFst<A>(fst, safe) {}
+
+ // Gets a copy of this ClosureFst. See Fst<>::Copy() for further doc.
+ ClosureFst<A> *Copy(bool safe = false) const override {
+ return new ClosureFst<A>(*this, safe);
+ }
+
+ private:
+ using ImplToFst<internal::RationalFstImpl<Arc>>::GetImpl;
+ using ImplToFst<internal::RationalFstImpl<Arc>>::GetMutableImpl;
+};
+
+// Specialization for ClosureFst.
+template <class Arc>
+class StateIterator<ClosureFst<Arc>> : public StateIterator<RationalFst<Arc>> {
+ public:
+ explicit StateIterator(const ClosureFst<Arc> &fst)
+ : StateIterator<RationalFst<Arc>>(fst) {}
+};
+
+// Specialization for ClosureFst.
+template <class Arc>
+class ArcIterator<ClosureFst<Arc>> : public ArcIterator<RationalFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const ClosureFst<Arc> &fst, StateId s)
+ : ArcIterator<RationalFst<Arc>>(fst, s) {}
+};
+
+// Useful alias when using StdArc.
+using StdClosureFst = ClosureFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_CLOSURE_H_
--- /dev/null
+// 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_LIB_COMPACT_FST_H_
+#define FST_LIB_COMPACT_FST_H_
+
+#include <iterator>
+#include <utility>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/expanded-fst.h>
+#include <fst/fst-decl.h> // For optional argument declarations
+#include <fst/mapped-file.h>
+#include <fst/matcher.h>
+#include <fst/test-properties.h>
+#include <fst/util.h>
+
+
+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) {}
+};
+
+// The Compactor 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 Compactor {
+// public:
+// // Element is the type of the compacted transitions.
+// using Element = ...
+//
+// // Returns the compacted representation of a transition 'arc'
+// // at a state 's'.
+// Element Compact(StateId s, const Arc &arc);
+//
+// // Returns the transition at state 's' represented by the compacted
+// // transition 'e'.
+// Arc Expand(StateId s, const Element &e) const;
+//
+// // Returns -1 for variable out-degree compactors, and the mandatory
+// // out-degree otherwise.
+// ssize_t Size() const;
+//
+// // Tests whether an FST can be compacted by this compactor.
+// bool Compatible(const Fst<A> &fst) const;
+//
+// // Returns the properties that are always true for an FST compacted using
+// // this compactor
+// uint64 Properties() const;
+//
+// // Returns a string identifying the type of compactor.
+// static const string &Type();
+//
+// // Writes a compactor to a file.
+// bool Write(std::ostream &strm) const;
+//
+// // Reads a compactor from a file.
+// static Compactor *Read(std::istream &strm);
+//
+// // Default constructor (optional, see comment below).
+// Compactor();
+// };
+//
+// The default constructor is only required for FST_REGISTER to work (i.e.,
+// enabling Convert() and the command-line utilities to work with this new
+// compactor). However, a default constructor always needs to be specified for
+// this code to compile, but one can have it simply raise an error when called,
+// like so:
+//
+// Compactor::Compactor() {
+// FSTERROR() << "Compactor: No default constructor";
+// }
+
+// Default implementation data for CompactFst, which can shared between
+// otherwise independent copies.
+//
+// The implementation contains two arrays: 'states_' and 'compacts_'.
+//
+// For fixed out-degree compactors, the 'states_' array is unallocated. The
+// 'compacts_' contains the compacted transitions. Its size is 'ncompacts_'.
+// The outgoing transitions at a given state are stored consecutively. For a
+// given state 's', its 'compactor.Size()' outgoing transitions (including
+// superfinal transition when 's' is final), are stored in position
+// ['s*compactor.Size()', '(s+1)*compactor.Size()').
+//
+// For variable out-degree compactors, the states_ array has size
+// 'nstates_ + 1' and contains pointers to positions into 'compacts_'. For a
+// given state 's', the compacted transitions of 's' are stored in positions
+// ['states_[s]', 'states_[s + 1]') in 'compacts_'. By convention,
+// 'states_[nstates_] == ncompacts_'.
+//
+// In both cases, the superfinal transitions (when 's' is final, i.e.,
+// 'Final(s) != Weight::Zero()') are stored first.
+//
+// The unsigned type U is used to represent indices into the compacts_ array.
+template <class Element, class Unsigned>
+class DefaultCompactStore {
+ public:
+ DefaultCompactStore()
+ : states_(nullptr),
+ compacts_(nullptr),
+ nstates_(0),
+ ncompacts_(0),
+ narcs_(0),
+ start_(kNoStateId),
+ error_(false) {}
+
+ template <class Arc, class Compactor>
+ DefaultCompactStore(const Fst<Arc> &fst, const Compactor &compactor);
+
+ template <class Iterator, class Compactor>
+ DefaultCompactStore(const Iterator &begin, const Iterator &end,
+ const Compactor &compactor);
+
+ ~DefaultCompactStore() {
+ if (!states_region_) delete[] states_;
+ if (!compacts_region_) delete[] compacts_;
+ }
+
+ template <class Compactor>
+ static DefaultCompactStore<Element, Unsigned> *Read(
+ std::istream &strm, const FstReadOptions &opts, const FstHeader &hdr,
+ const Compactor &compactor);
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const;
+
+ Unsigned States(ssize_t i) const { return states_[i]; }
+
+ const Element &Compacts(size_t i) const { return compacts_[i]; }
+
+ size_t NumStates() const { return nstates_; }
+
+ size_t NumCompacts() const { return ncompacts_; }
+
+ size_t NumArcs() const { return narcs_; }
+
+ ssize_t Start() const { return start_; }
+
+ bool Error() const { return error_; }
+
+ // Returns a string identifying the type of data storage container.
+ static const string &Type();
+
+ private:
+ std::unique_ptr<MappedFile> states_region_;
+ std::unique_ptr<MappedFile> compacts_region_;
+ Unsigned *states_;
+ Element *compacts_;
+ size_t nstates_;
+ size_t ncompacts_;
+ size_t narcs_;
+ ssize_t start_;
+ bool error_;
+};
+
+template <class Element, class Unsigned>
+template <class Arc, class Compactor>
+DefaultCompactStore<Element, Unsigned>::DefaultCompactStore(
+ const Fst<Arc> &fst, const Compactor &compactor)
+ : states_(nullptr),
+ compacts_(nullptr),
+ nstates_(0),
+ ncompacts_(0),
+ narcs_(0),
+ start_(kNoStateId),
+ error_(false) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ start_ = fst.Start();
+ // Counts # of states and arcs.
+ StateId nfinals = 0;
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ ++nstates_;
+ const auto s = siter.Value();
+ for (ArcIterator<Fst<Arc>> aiter(fst, s); !aiter.Done(); aiter.Next()) {
+ ++narcs_;
+ }
+ if (fst.Final(s) != Weight::Zero()) ++nfinals;
+ }
+ if (compactor.Size() == -1) {
+ states_ = new Unsigned[nstates_ + 1];
+ ncompacts_ = narcs_ + nfinals;
+ compacts_ = new Element[ncompacts_];
+ states_[nstates_] = ncompacts_;
+ } else {
+ states_ = nullptr;
+ ncompacts_ = nstates_ * compactor.Size();
+ if ((narcs_ + nfinals) != ncompacts_) {
+ FSTERROR() << "DefaultCompactStore: Compactor incompatible with FST";
+ error_ = true;
+ return;
+ }
+ compacts_ = new Element[ncompacts_];
+ }
+ size_t pos = 0;
+ size_t fpos = 0;
+ for (auto s = 0; s < nstates_; ++s) {
+ fpos = pos;
+ if (compactor.Size() == -1) states_[s] = pos;
+ if (fst.Final(s) != Weight::Zero()) {
+ compacts_[pos++] = compactor.Compact(
+ s, Arc(kNoLabel, kNoLabel, fst.Final(s), kNoStateId));
+ }
+ for (ArcIterator<Fst<Arc>> aiter(fst, s); !aiter.Done(); aiter.Next()) {
+ compacts_[pos++] = compactor.Compact(s, aiter.Value());
+ }
+ if ((compactor.Size() != -1) && ((pos - fpos) != compactor.Size())) {
+ FSTERROR() << "DefaultCompactStore: Compactor incompatible with FST";
+ error_ = true;
+ return;
+ }
+ }
+ if (pos != ncompacts_) {
+ FSTERROR() << "DefaultCompactStore: Compactor incompatible with FST";
+ error_ = true;
+ return;
+ }
+}
+
+template <class Element, class Unsigned>
+template <class Iterator, class Compactor>
+DefaultCompactStore<Element, Unsigned>::DefaultCompactStore(
+ const Iterator &begin, const Iterator &end, const Compactor &compactor)
+ : states_(nullptr),
+ compacts_(nullptr),
+ nstates_(0),
+ ncompacts_(0),
+ narcs_(0),
+ start_(kNoStateId),
+ error_(false) {
+ using Arc = typename Compactor::Arc;
+ using Weight = typename Arc::Weight;
+ if (compactor.Size() != -1) {
+ ncompacts_ = std::distance(begin, end);
+ if (compactor.Size() == 1) {
+ // For strings, allows implicit final weight. Empty input is the empty
+ // string.
+ if (ncompacts_ == 0) {
+ ++ncompacts_;
+ } else {
+ const auto arc =
+ compactor.Expand(ncompacts_ - 1, *(begin + (ncompacts_ - 1)));
+ if (arc.ilabel != kNoLabel) ++ncompacts_;
+ }
+ }
+ if (ncompacts_ % compactor.Size()) {
+ FSTERROR() << "DefaultCompactStore: Size of input container incompatible"
+ << " with compactor";
+ error_ = true;
+ return;
+ }
+ if (ncompacts_ == 0) return;
+ start_ = 0;
+ nstates_ = ncompacts_ / compactor.Size();
+ compacts_ = new Element[ncompacts_];
+ size_t i = 0;
+ Iterator it = begin;
+ for (; it != end; ++it, ++i) {
+ compacts_[i] = *it;
+ if (compactor.Expand(i, *it).ilabel != kNoLabel) ++narcs_;
+ }
+ if (i < ncompacts_) {
+ compacts_[i] = compactor.Compact(
+ i, Arc(kNoLabel, kNoLabel, Weight::One(), kNoStateId));
+ }
+ } else {
+ if (std::distance(begin, end) == 0) return;
+ // Count # of states, arcs and compacts.
+ auto it = begin;
+ for (size_t i = 0; it != end; ++it, ++i) {
+ const auto arc = compactor.Expand(i, *it);
+ if (arc.ilabel != kNoLabel) {
+ ++narcs_;
+ ++ncompacts_;
+ } else {
+ ++nstates_;
+ if (arc.weight != Weight::Zero()) ++ncompacts_;
+ }
+ }
+ start_ = 0;
+ compacts_ = new Element[ncompacts_];
+ states_ = new Unsigned[nstates_ + 1];
+ states_[nstates_] = ncompacts_;
+ size_t i = 0;
+ size_t s = 0;
+ for (it = begin; it != end; ++it) {
+ const auto arc = compactor.Expand(i, *it);
+ if (arc.ilabel != kNoLabel) {
+ compacts_[i++] = *it;
+ } else {
+ states_[s++] = i;
+ if (arc.weight != Weight::Zero()) compacts_[i++] = *it;
+ }
+ }
+ if ((s != nstates_) || (i != ncompacts_)) {
+ FSTERROR() << "DefaultCompactStore: Ill-formed input container";
+ error_ = true;
+ return;
+ }
+ }
+}
+
+template <class Element, class Unsigned>
+template <class Compactor>
+DefaultCompactStore<Element, Unsigned>
+ *DefaultCompactStore<Element, Unsigned>::Read(std::istream &strm,
+ const FstReadOptions &opts,
+ const FstHeader &hdr,
+ const Compactor &compactor) {
+ std::unique_ptr<DefaultCompactStore<Element, Unsigned>> data(
+ new DefaultCompactStore<Element, Unsigned>());
+ data->start_ = hdr.Start();
+ data->nstates_ = hdr.NumStates();
+ data->narcs_ = hdr.NumArcs();
+ if (compactor.Size() == -1) {
+ if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) {
+ LOG(ERROR) << "DefaultCompactStore::Read: Alignment failed: "
+ << opts.source;
+ return nullptr;
+ }
+ auto b = (data->nstates_ + 1) * sizeof(Unsigned);
+ data->states_region_.reset(MappedFile::Map(
+ &strm, opts.mode == FstReadOptions::MAP, opts.source, b));
+ if (!strm || !data->states_region_) {
+ LOG(ERROR) << "DefaultCompactStore::Read: Read failed: " << opts.source;
+ return nullptr;
+ }
+ data->states_ =
+ static_cast<Unsigned *>(data->states_region_->mutable_data());
+ } else {
+ data->states_ = nullptr;
+ }
+ data->ncompacts_ = compactor.Size() == -1 ? data->states_[data->nstates_]
+ : data->nstates_ * compactor.Size();
+ if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) {
+ LOG(ERROR) << "DefaultCompactStore::Read: Alignment failed: "
+ << opts.source;
+ return nullptr;
+ }
+ size_t b = data->ncompacts_ * sizeof(Element);
+ data->compacts_region_.reset(
+ MappedFile::Map(&strm, opts.mode == FstReadOptions::MAP, opts.source, b));
+ if (!strm || !data->compacts_region_) {
+ LOG(ERROR) << "DefaultCompactStore::Read: Read failed: " << opts.source;
+ return nullptr;
+ }
+ data->compacts_ =
+ static_cast<Element *>(data->compacts_region_->mutable_data());
+ return data.release();
+}
+
+template <class Element, class Unsigned>
+bool DefaultCompactStore<Element, Unsigned>::Write(
+ std::ostream &strm, const FstWriteOptions &opts) const {
+ if (states_) {
+ if (opts.align && !AlignOutput(strm)) {
+ LOG(ERROR) << "DefaultCompactStore::Write: Alignment failed: "
+ << opts.source;
+ return false;
+ }
+ strm.write(reinterpret_cast<char *>(states_),
+ (nstates_ + 1) * sizeof(Unsigned));
+ }
+ if (opts.align && !AlignOutput(strm)) {
+ LOG(ERROR) << "DefaultCompactStore::Write: Alignment failed: "
+ << opts.source;
+ return false;
+ }
+ strm.write(reinterpret_cast<char *>(compacts_), ncompacts_ * sizeof(Element));
+ strm.flush();
+ if (!strm) {
+ LOG(ERROR) << "DefaultCompactStore::Write: Write failed: " << opts.source;
+ return false;
+ }
+ return true;
+}
+
+template <class Element, class Unsigned>
+const string &DefaultCompactStore<Element, Unsigned>::Type() {
+ static const string type = "compact";
+ return type;
+}
+
+template <class Arc, class Element, class Unsigned, class CompactStore,
+ class CacheStore>
+class CompactFst;
+
+template <class F, class G>
+void Cast(const F &, G *);
+
+namespace internal {
+
+// Implementation class for CompactFst, which contains parametrizeable
+// Fst data storage (DefaultCompactStore by default) and Fst cache.
+template <class Arc, class Compactor, class Unsigned,
+ class CompactStore =
+ DefaultCompactStore<typename Compactor::Element, Unsigned>,
+ class CacheStore = DefaultCacheStore<Arc>>
+class CompactFstImpl
+ : public CacheBaseImpl<typename CacheStore::State, CacheStore> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using DataStorage = CompactStore;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::Properties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+ using FstImpl<Arc>::WriteHeader;
+
+ using ImplBase = CacheBaseImpl<typename CacheStore::State, CacheStore>;
+ using ImplBase::PushArc;
+ using ImplBase::HasArcs;
+ using ImplBase::HasFinal;
+ using ImplBase::HasStart;
+ using ImplBase::SetArcs;
+ using ImplBase::SetFinal;
+ using ImplBase::SetStart;
+
+ CompactFstImpl()
+ : ImplBase(CompactFstOptions()),
+ compactor_(),
+ data_() {
+ string type = "compact";
+ if (sizeof(Unsigned) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(Unsigned), &size);
+ type += size;
+ }
+ type += "_";
+ type += Compactor::Type();
+ if (CompactStore::Type() != "compact") {
+ type += "_";
+ type += CompactStore::Type();
+ }
+ SetType(type);
+ SetProperties(kNullProperties | kStaticProperties);
+ }
+
+ CompactFstImpl(const Fst<Arc> &fst, std::shared_ptr<Compactor> compactor,
+ const CompactFstOptions &opts,
+ std::shared_ptr<CompactStore> data)
+ : ImplBase(opts), compactor_(std::move(compactor)) {
+ Init(fst, data);
+ }
+
+ template <class Iterator>
+ CompactFstImpl(const Iterator &b, const Iterator &e,
+ std::shared_ptr<Compactor> compactor,
+ const CompactFstOptions &opts)
+ : ImplBase(opts), compactor_(std::move(compactor)) {
+ Init(b, e);
+ }
+
+ CompactFstImpl(const CompactFstImpl<Arc, Compactor, Unsigned, CompactStore,
+ CacheStore> &impl)
+ : ImplBase(impl),
+ compactor_(impl.compactor_ == nullptr
+ ? nullptr
+ : std::make_shared<Compactor>(*impl.compactor_)),
+ data_(impl.data_) {
+ SetType(impl.Type());
+ SetProperties(impl.Properties());
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ // Allows to change the cache store from OtherI to I.
+ template <class OtherCacheStore>
+ explicit CompactFstImpl(
+ const CompactFstImpl<Arc, Compactor, Unsigned, CompactStore,
+ OtherCacheStore> &impl)
+ : ImplBase(CacheOptions(impl.GetCacheGc(), impl.GetCacheLimit())),
+ compactor_(impl.compactor_ == nullptr
+ ? nullptr
+ : std::make_shared<Compactor>(*impl.compactor_)),
+ data_(impl.data_) {
+ SetType(impl.Type());
+ SetProperties(impl.Properties());
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ StateId Start() {
+ if (!HasStart()) SetStart(data_->Start());
+ return ImplBase::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (HasFinal(s)) return ImplBase::Final(s);
+ Arc arc(kNoLabel, kNoLabel, Weight::Zero(), kNoStateId);
+ if ((compactor_->Size() != -1) ||
+ (data_->States(s) != data_->States(s + 1))) {
+ arc = ComputeArc(s, compactor_->Size() == -1 ? data_->States(s) :
+ s * compactor_->Size());
+ }
+ return arc.ilabel == kNoLabel ? arc.weight : Weight::Zero();
+ }
+
+ StateId NumStates() const {
+ if (Properties(kError)) return 0;
+ return data_->NumStates();
+ }
+
+ size_t NumArcs(StateId s) {
+ if (HasArcs(s)) return ImplBase::NumArcs(s);
+ Unsigned i;
+ Unsigned num_arcs;
+ if (compactor_->Size() == -1) {
+ i = data_->States(s);
+ num_arcs = data_->States(s + 1) - i;
+ } else {
+ i = s * compactor_->Size();
+ num_arcs = compactor_->Size();
+ }
+ if (num_arcs > 0) {
+ const auto &arc = ComputeArc(s, i, kArcILabelValue);
+ if (arc.ilabel == kNoStateId) --num_arcs;
+ }
+ return num_arcs;
+ }
+
+ 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) {
+ size_t begin =
+ compactor_->Size() == -1 ? data_->States(s) : s * compactor_->Size();
+ size_t end = compactor_->Size() == -1 ? data_->States(s + 1)
+ : (s + 1) * compactor_->Size();
+ size_t num_eps = 0;
+ for (size_t i = begin; i < end; ++i) {
+ const auto &arc =
+ ComputeArc(s, i, output_epsilons ? kArcOLabelValue : kArcILabelValue);
+ const auto label = output_epsilons ? arc.olabel : arc.ilabel;
+ if (label == kNoLabel) {
+ continue;
+ } else if (label > 0) {
+ break;
+ }
+ ++num_eps;
+ }
+ return num_eps;
+ }
+
+ static CompactFstImpl<Arc, Compactor, Unsigned, CompactStore, CacheStore>
+ *Read(std::istream &strm, const FstReadOptions &opts) {
+ std::unique_ptr<
+ CompactFstImpl<Arc, Compactor, Unsigned, CompactStore, CacheStore>>
+ impl(new CompactFstImpl<Arc, Compactor, Unsigned, CompactStore,
+ CacheStore>());
+ 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>(Compactor::Read(strm));
+ if (!impl->compactor_) return nullptr;
+ impl->data_ = std::shared_ptr<CompactStore>(
+ CompactStore::Read(strm, opts, hdr, *impl->compactor_));
+ if (!impl->data_) return nullptr;
+ return impl.release();
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const {
+ FstHeader hdr;
+ hdr.SetStart(data_->Start());
+ hdr.SetNumStates(data_->NumStates());
+ hdr.SetNumArcs(data_->NumArcs());
+ // Ensures compatibility.
+ const auto file_version = opts.align ? kAlignedFileVersion : kFileVersion;
+ WriteHeader(strm, opts, file_version, &hdr);
+ compactor_->Write(strm);
+ return data_->Write(strm, opts);
+ }
+
+ // Provides information needed for generic state iterator.
+ void InitStateIterator(StateIteratorData<Arc> *data) const {
+ data->base = nullptr;
+ data->nstates = data_->NumStates();
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ ImplBase::InitArcIterator(s, data);
+ }
+
+ Arc ComputeArc(StateId s, Unsigned i, uint32 f = kArcValueFlags) const {
+ return compactor_->Expand(s, data_->Compacts(i), f);
+ }
+
+ void Expand(StateId s) {
+ size_t begin =
+ compactor_->Size() == -1 ? data_->States(s) : s * compactor_->Size();
+ size_t end = compactor_->Size() == -1 ? data_->States(s + 1)
+ : (s + 1) * compactor_->Size();
+ for (auto i = begin; i < end; ++i) {
+ const auto &arc = ComputeArc(s, i);
+ if (arc.ilabel == kNoLabel) {
+ SetFinal(s, arc.weight);
+ } else {
+ PushArc(s, arc);
+ }
+ }
+ if (!HasFinal(s)) SetFinal(s, Weight::Zero());
+ SetArcs(s);
+ }
+
+ template <class Iterator>
+ void SetCompactElements(const Iterator &begin, const Iterator &end) {
+ SetProperties(kStaticProperties | compactor_->Properties());
+ data_ = std::make_shared<CompactStore>(begin, end, *compactor_);
+ if (data_->Error()) SetProperties(kError, kError);
+ }
+
+ const Compactor *GetCompactor() const { return compactor_.get(); }
+
+ std::shared_ptr<Compactor> SharedCompactor() const { return compactor_; }
+
+ const CompactStore *Data() const { return data_.get(); }
+
+ std::shared_ptr<CompactStore> SharedData() const { return data_; }
+
+ // Properties always true of this FST class.
+ static constexpr uint64 kStaticProperties = kExpanded;
+
+ protected:
+ template <class OtherArc, class OtherCompactor, class OtherCacheStore>
+ explicit CompactFstImpl(
+ const CompactFstImpl<OtherArc, OtherCompactor, Unsigned, CompactStore,
+ OtherCacheStore> &impl)
+ : ImplBase(CacheOptions(impl.GetCacheGc(), impl.GetCacheLimit())),
+ compactor_(std::make_shared<Compactor>(*impl.GetCompactor())),
+ data_(impl.SharedData()) {
+ SetType(impl.Type());
+ SetProperties(impl.Properties());
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ private:
+ // Allows access during write.
+ friend class CompactFst<Arc, Compactor, Unsigned, CompactStore, CacheStore>;
+
+ void Init(const Fst<Arc> &fst, std::shared_ptr<CompactStore> data) {
+ string type = "compact";
+ if (sizeof(Unsigned) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(Unsigned), &size);
+ type += size;
+ }
+ type += "_";
+ type += compactor_->Type();
+ if (CompactStore::Type() != "compact") {
+ type += "_";
+ type += CompactStore::Type();
+ }
+ SetType(type);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ data_ = (data) ? data : std::make_shared<CompactStore>(fst, *compactor_);
+ if (data_->Error()) SetProperties(kError, kError);
+ const auto copy_properties =
+ fst.Properties(kMutable, false)
+ ? fst.Properties(kCopyProperties, true)
+ : CheckProperties(
+ fst, kCopyProperties & ~kWeightedCycles & ~kUnweightedCycles,
+ kCopyProperties);
+ if ((copy_properties & kError) || !compactor_->Compatible(fst)) {
+ FSTERROR() << "CompactFstImpl: Input FST incompatible with compactor";
+ SetProperties(kError, kError);
+ return;
+ }
+ SetProperties(copy_properties | kStaticProperties);
+ }
+
+ template <class Iterator>
+ void Init(const Iterator &begin, const Iterator &end) {
+ string type = "compact";
+ if (sizeof(Unsigned) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(Unsigned), &size);
+ type += size;
+ }
+ type += "_";
+ type += compactor_->Type();
+ SetType(type);
+ SetProperties(kStaticProperties | compactor_->Properties());
+ data_ = std::make_shared<CompactStore>(begin, end, *compactor_);
+ if (data_->Error()) SetProperties(kError, kError);
+ }
+
+ // 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> compactor_;
+ std::shared_ptr<CompactStore> data_;
+};
+
+template <class Arc, class Compactor, class Unsigned, class CompactStore,
+ class CacheStore>
+constexpr uint64 CompactFstImpl<Arc, Compactor, Unsigned, CompactStore,
+ CacheStore>::kStaticProperties;
+
+template <class Arc, class Compactor, class Unsigned, class CompactStore,
+ class CacheStore>
+constexpr int CompactFstImpl<Arc, Compactor, Unsigned, CompactStore,
+ CacheStore>::kFileVersion;
+
+template <class Arc, class Compactor, class Unsigned, class CompactStore,
+ class CacheStore>
+constexpr int CompactFstImpl<Arc, Compactor, Unsigned, CompactStore,
+ CacheStore>::kAlignedFileVersion;
+
+template <class Arc, class Compactor, class Unsigned, class CompactStore,
+ class CacheStore>
+constexpr int CompactFstImpl<Arc, Compactor, Unsigned, CompactStore,
+ CacheStore>::kMinFileVersion;
+
+} // namespace internal
+
+// This class attaches interface to implementation and handles reference
+// counting, delegating most methods to ImplToExpandedFst. The Unsigned type
+// is used to represent indices into the compact arc array. (Template
+// argument defaults are declared in fst-decl.h.)
+template <class A, class Compactor, class Unsigned, class CompactStore,
+ class CacheStore>
+class CompactFst : public ImplToExpandedFst<internal::CompactFstImpl<
+ A, Compactor, Unsigned, CompactStore, CacheStore>> {
+ public:
+ template <class F, class G>
+ void friend Cast(const F &, G *);
+
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ using Impl = internal::CompactFstImpl<A, Compactor, Unsigned, CompactStore,
+ CacheStore>;
+
+ friend class StateIterator<
+ CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore>>;
+ friend class ArcIterator<
+ CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore>>;
+
+ CompactFst() : ImplToExpandedFst<Impl>(std::make_shared<Impl>()) {}
+
+ // If data is not nullptr, it is assumed to be already initialized.
+ explicit CompactFst(
+ const Fst<Arc> &fst, const Compactor &compactor = Compactor(),
+ const CompactFstOptions &opts = CompactFstOptions(),
+ std::shared_ptr<CompactStore> data = std::shared_ptr<CompactStore>())
+ : ImplToExpandedFst<Impl>(std::make_shared<Impl>(
+ fst, std::make_shared<Compactor>(compactor), opts, data)) {}
+
+ // If data is not nullptr, it is assumed to be already initialized.
+ CompactFst(
+ const Fst<Arc> &fst, std::shared_ptr<Compactor> compactor,
+ const CompactFstOptions &opts = CompactFstOptions(),
+ std::shared_ptr<CompactStore> data = std::shared_ptr<CompactStore>())
+ : ImplToExpandedFst<Impl>(
+ std::make_shared<Impl>(fst, compactor, opts, data)) {}
+
+ // The following 2 constructors take as input two iterators delimiting a set
+ // of (already) compacted transitions, starting with the transitions out of
+ // the initial state. The format of the input differs for fixed out-degree
+ // and variable out-degree compactors.
+ //
+ // - For fixed out-degree compactors, the final weight (encoded as a
+ // compacted transition) needs to be given only for final states. All strings
+ // (compactor of size 1) will be assume to be terminated by a final state
+ // even when the final state is not implicitely given.
+ //
+ // - For variable out-degree compactors, the final weight (encoded as a
+ // compacted transition) needs to be given for all states and must appeared
+ // first in the list (for state s, final weight of s, followed by outgoing
+ // transitons in s).
+ //
+ // These 2 constructors allows the direct construction of a CompactFst
+ // without first creating a more memory-hungry regular FST. This is useful
+ // when memory usage is severely constrained.
+ template <class Iterator>
+ explicit CompactFst(const Iterator &begin, const Iterator &end,
+ const Compactor &compactor = Compactor(),
+ const CompactFstOptions &opts = CompactFstOptions())
+ : ImplToExpandedFst<Impl>(std::make_shared<Impl>(
+ begin, end, std::make_shared<Compactor>(compactor), opts)) {}
+
+ template <class Iterator>
+ CompactFst(const Iterator &begin, const Iterator &end,
+ std::shared_ptr<Compactor> compactor,
+ const CompactFstOptions &opts = CompactFstOptions())
+ : ImplToExpandedFst<Impl>(
+ std::make_shared<Impl>(begin, end, compactor, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ CompactFst(
+ const CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore> &fst,
+ bool safe = false)
+ : ImplToExpandedFst<Impl>(fst, safe) {}
+
+ // Get a copy of this CompactFst. See Fst<>::Copy() for further doc.
+ CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore> *Copy(
+ bool safe = false) const override {
+ return new CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore>(
+ *this, safe);
+ }
+
+ // Read a CompactFst from an input stream; return nullptr on error
+ static CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore> *Read(
+ std::istream &strm, const FstReadOptions &opts) {
+ auto *impl = Impl::Read(strm, opts);
+ return impl ? new CompactFst<A, Compactor, Unsigned, CompactStore,
+ CacheStore>(std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ // Read a CompactFst from a file; return nullptr on error
+ // Empty filename reads from standard input
+ static CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore> *Read(
+ const string &filename) {
+ auto *impl = ImplToExpandedFst<Impl>::Read(filename);
+ return impl ? new CompactFst<A, Compactor, Unsigned, CompactStore,
+ CacheStore>(std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return GetImpl()->Write(strm, opts);
+ }
+
+ bool Write(const string &filename) const override {
+ return Fst<Arc>::WriteFile(filename);
+ }
+
+ template <class FST>
+ static bool WriteFst(const FST &fst, const Compactor &compactor,
+ std::ostream &strm, const FstWriteOptions &opts);
+
+ void InitStateIterator(StateIteratorData<Arc> *data) const override {
+ GetImpl()->InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ MatcherBase<Arc> *InitMatcher(MatchType match_type) const override {
+ return new SortedMatcher<
+ CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore>>(
+ *this, match_type);
+ }
+
+ template <class Iterator>
+ void SetCompactElements(const Iterator &begin, const Iterator &end) {
+ GetMutableImpl()->SetCompactElements(begin, end);
+ }
+
+ private:
+ using ImplToFst<Impl, ExpandedFst<Arc>>::GetImpl;
+ using ImplToFst<Impl, ExpandedFst<Arc>>::GetMutableImpl;
+
+ explicit CompactFst(std::shared_ptr<Impl> impl)
+ : ImplToExpandedFst<Impl>(impl) {}
+
+ // Use overloading to extract the type of the argument.
+ static Impl *GetImplIfCompactFst(
+ const CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore>
+ &compact_fst) {
+ return compact_fst.GetImpl();
+ }
+
+ // This does not give privileged treatment to subclasses of CompactFst.
+ template <typename NonCompactFst>
+ static Impl *GetImplIfCompactFst(const NonCompactFst &fst) {
+ return nullptr;
+ }
+
+ CompactFst &operator=(const CompactFst &fst) = delete;
+};
+
+// Writes FST in Compact format, with a possible pass over the machine before
+// writing to compute the number of states and arcs.
+template <class A, class Compactor, class Unsigned, class CompactStore,
+ class CacheStore>
+template <class FST>
+bool CompactFst<A, Compactor, Unsigned, CompactStore, CacheStore>::WriteFst(
+ const FST &fst, const Compactor &compactor, std::ostream &strm,
+ const FstWriteOptions &opts) {
+ using Arc = A;
+ using Weight = typename A::Weight;
+ using Element = typename Compactor::Element;
+ const auto file_version =
+ opts.align ? Impl::kAlignedFileVersion : Impl::kFileVersion;
+ size_t num_arcs = -1;
+ size_t num_states = -1;
+ auto first_pass_compactor = compactor;
+ if (auto *impl = GetImplIfCompactFst(fst)) {
+ num_arcs = impl->Data()->NumArcs();
+ num_states = impl->Data()->NumStates();
+ first_pass_compactor = *impl->GetCompactor();
+ } 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<FST> siter(fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ ++num_states;
+ if (fst.Final(s) != Weight::Zero()) {
+ first_pass_compactor.Compact(
+ s, Arc(kNoLabel, kNoLabel, fst.Final(s), kNoStateId));
+ }
+ for (ArcIterator<FST> aiter(fst, s); !aiter.Done(); aiter.Next()) {
+ ++num_arcs;
+ first_pass_compactor.Compact(s, aiter.Value());
+ }
+ }
+ }
+ FstHeader hdr;
+ hdr.SetStart(fst.Start());
+ hdr.SetNumStates(num_states);
+ hdr.SetNumArcs(num_arcs);
+ string type = "compact";
+ if (sizeof(Unsigned) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(Unsigned), &size);
+ type += size;
+ }
+ type += "_";
+ type += Compactor::Type();
+ if (CompactStore::Type() != "compact") {
+ type += "_";
+ type += CompactStore::Type();
+ }
+ const auto copy_properties = fst.Properties(kCopyProperties, true);
+ if ((copy_properties & kError) || !compactor.Compatible(fst)) {
+ FSTERROR() << "Fst incompatible with compactor";
+ return false;
+ }
+ uint64 properties = copy_properties | Impl::kStaticProperties;
+ internal::FstImpl<Arc>::WriteFstHeader(fst, strm, opts, file_version, type,
+ properties, &hdr);
+ first_pass_compactor.Write(strm);
+ if (first_pass_compactor.Size() == -1) {
+ if (opts.align && !AlignOutput(strm)) {
+ LOG(ERROR) << "CompactFst::Write: Alignment failed: " << opts.source;
+ return false;
+ }
+ Unsigned compacts = 0;
+ for (StateIterator<FST> siter(fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ strm.write(reinterpret_cast<const char *>(&compacts), sizeof(compacts));
+ if (fst.Final(s) != Weight::Zero()) {
+ ++compacts;
+ }
+ compacts += fst.NumArcs(s);
+ }
+ strm.write(reinterpret_cast<const char *>(&compacts), sizeof(compacts));
+ }
+ if (opts.align && !AlignOutput(strm)) {
+ LOG(ERROR) << "Could not align file during write after writing states";
+ }
+ const auto &second_pass_compactor = compactor;
+ Element element;
+ for (StateIterator<FST> siter(fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ if (fst.Final(s) != Weight::Zero()) {
+ element = second_pass_compactor.Compact(
+ s, A(kNoLabel, kNoLabel, fst.Final(s), kNoStateId));
+ strm.write(reinterpret_cast<const char *>(&element), sizeof(element));
+ }
+ for (ArcIterator<FST> aiter(fst, s); !aiter.Done(); aiter.Next()) {
+ element = second_pass_compactor.Compact(s, aiter.Value());
+ strm.write(reinterpret_cast<const char *>(&element), sizeof(element));
+ }
+ }
+ strm.flush();
+ if (!strm) {
+ LOG(ERROR) << "CompactFst write failed: " << opts.source;
+ return false;
+ }
+ return true;
+}
+
+// Specialization for CompactFst; see generic version in fst.h for sample
+// usage (but use the CompactFst type!). This version should inline.
+template <class Arc, class Compactor, class Unsigned, class CompactStore,
+ class CacheStore>
+class StateIterator<
+ CompactFst<Arc, Compactor, Unsigned, CompactStore, CacheStore>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ explicit StateIterator(
+ const CompactFst<Arc, Compactor, Unsigned, CompactStore, CacheStore> &fst)
+ : nstates_(fst.GetImpl()->NumStates()), s_(0) {}
+
+ bool Done() const { return s_ >= nstates_; }
+
+ StateId Value() const { return s_; }
+
+ void Next() { ++s_; }
+
+ void Reset() { s_ = 0; }
+
+ private:
+ StateId nstates_;
+ StateId s_;
+};
+
+// Specialization for CompactFst with DefaultCompactStore. Never caches,
+// always iterates over the underlying compact elements.
+template <class Arc, class Compactor, class Unsigned, class CacheStore>
+class ArcIterator<CompactFst<
+ Arc, Compactor, Unsigned,
+ DefaultCompactStore<typename Compactor::Element, Unsigned>, CacheStore>> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Element = typename Compactor::Element;
+
+ ArcIterator(
+ const CompactFst<Arc, Compactor, Unsigned,
+ DefaultCompactStore<Element, Unsigned>, CacheStore> &fst,
+ StateId s)
+ : compactor_(fst.GetImpl()->GetCompactor()),
+ state_(s),
+ compacts_(nullptr),
+ pos_(0),
+ flags_(kArcValueFlags) {
+ const auto *data = fst.GetImpl()->Data();
+ size_t offset;
+ if (compactor_->Size() == -1) { // Variable out-degree compactor.
+ offset = data->States(s);
+ num_arcs_ = data->States(s + 1) - offset;
+ } else { // Fixed out-degree compactor.
+ offset = s * compactor_->Size();
+ num_arcs_ = compactor_->Size();
+ }
+ if (num_arcs_ > 0) {
+ compacts_ = &(data->Compacts(offset));
+ arc_ = compactor_->Expand(s, *compacts_, kArcILabelValue);
+ if (arc_.ilabel == kNoStateId) {
+ ++compacts_;
+ --num_arcs_;
+ }
+ }
+ }
+
+ bool Done() const { return pos_ >= num_arcs_; }
+
+ const Arc &Value() const {
+ arc_ = compactor_->Expand(state_, compacts_[pos_], flags_);
+ return arc_;
+ }
+
+ void Next() { ++pos_; }
+
+ size_t Position() const { return pos_; }
+
+ void Reset() { pos_ = 0; }
+
+ void Seek(size_t pos) { pos_ = pos; }
+
+ uint32 Flags() const { return flags_; }
+
+ void SetFlags(uint32 f, uint32 m) {
+ flags_ &= ~m;
+ flags_ |= (f & kArcValueFlags);
+ }
+
+ private:
+ const Compactor *compactor_; // Borrowed reference.
+ StateId state_;
+ const Element *compacts_; // Borrowed reference.
+ size_t pos_;
+ size_t num_arcs_;
+ mutable Arc arc_;
+ uint32 flags_;
+};
+
+// // Specialization for CompactFst.
+// // This is an optionally caching arc iterator.
+// // TODO(allauzen): implements the kArcValueFlags, the current
+// /// implementation only implements the kArcNoCache flag.
+// template <class A, class C, class U>
+// class ArcIterator<CompactFst<A, C, U>> {
+// public:
+// using StateId = typename A::StateId;
+//
+// ArcIterator(const CompactFst<A, C, U> &fst, StateId s)
+// : fst_(fst), state_(s), pos_(0), num_arcs_(0), offset_(0),
+// flags_(kArcValueFlags) {
+// cache_data_.ref_count = 0;
+//
+// if (fst_.GetImpl()->HasArcs(state_)) {
+// fst_.GetImpl()->InitArcIterator(s, &cache_data_);
+// num_arcs_ = cache_data_.narcs;
+// return;
+// }
+//
+// const C *compactor = fst_.GetImpl()->GetCompactor();
+// const DefaultCompactStore<A, C, U> *data = fst_.GetImpl()->Data();
+// if (compactor->Size() == -1) { // Variable out-degree compactor
+// offset_ = data->States(s);
+// num_arcs_ = data->States(s + 1) - offset_;
+// } else { // Fixed out-degree compactor
+// offset_ = s * compactor->Size();
+// num_arcs_ = compactor->Size();
+// }
+// if (num_arcs_ > 0) {
+// const A &arc = fst_.GetImpl()->ComputeArc(s, offset_);
+// if (arc.ilabel == kNoStateId) {
+// ++offset_;
+// --num_arcs_;
+// }
+// }
+// }
+//
+// ~ArcIterator() {
+// if (cache_data_.ref_count)
+// --(*cache_data_.ref_count);
+// }
+//
+// bool Done() const { return pos_ >= num_arcs_; }
+//
+// const A& Value() const {
+// if (cache_data_.ref_count == 0) {
+// if (flags_ & kArcNoCache) {
+// arc_ = fst_.GetImpl()->ComputeArc(state_, pos_ + offset_);
+// return arc_;
+// } else {
+// fst_.GetImpl()->InitArcIterator(state_, &cache_data_);
+// }
+// }
+// return cache_data_.arcs[pos_];
+// }
+//
+// void Next() { ++pos_; }
+//
+// size_t Position() const { return pos_; }
+//
+// void Reset() { pos_ = 0; }
+//
+// void Seek(size_t pos) { pos_ = pos; }
+//
+// uint32 Flags() const { return flags_; }
+//
+// void SetFlags(uint32 f, uint32 m) {
+// flags_ &= ~m;
+// flags_ |= f;
+//
+// if (!(flags_ & kArcNoCache) && cache_data_.ref_count == 0)
+// fst_.GetImpl()->InitArcIterator(state_, &cache_data_);
+// }
+//
+// private:
+// mutable const CompactFst<A, C, U> &fst_;
+// StateId state_;
+// size_t pos_;
+// size_t num_arcs_;
+// size_t offset_;
+// uint32 flags_;
+// mutable A arc_;
+// mutable ArcIteratorData<A> cache_data_;
+// };
+
+// Compactor for unweighted string FSTs.
+template <class A>
+class StringCompactor {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Element = Label;
+
+ Element Compact(StateId s, const Arc &arc) const { return arc.ilabel; }
+
+ Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const {
+ return Arc(p, p, Weight::One(), p != kNoLabel ? s + 1 : kNoStateId);
+ }
+
+ constexpr ssize_t Size() const { return 1; }
+
+ constexpr uint64 Properties() const {
+ return kString | kAcceptor | kUnweighted;
+ }
+
+ bool Compatible(const Fst<Arc> &fst) const {
+ const auto props = Properties();
+ return fst.Properties(props, true) == props;
+ }
+
+ static const string &Type() {
+ static const string type = "string";
+ return type;
+ }
+
+ bool Write(std::ostream &strm) const { return true; }
+
+ static StringCompactor *Read(std::istream &strm) {
+ return new StringCompactor;
+ }
+};
+
+// Compactor for weighted string FSTs.
+template <class A>
+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<Label, Weight>;
+
+ Element Compact(StateId s, const Arc &arc) const {
+ return std::make_pair(arc.ilabel, arc.weight);
+ }
+
+ Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const {
+ return Arc(p.first, p.first, p.second,
+ p.first != kNoLabel ? s + 1 : kNoStateId);
+ }
+
+ constexpr ssize_t Size() const { return 1; }
+
+ constexpr uint64 Properties() const { return kString | kAcceptor; }
+
+ bool Compatible(const Fst<Arc> &fst) const {
+ const auto props = Properties();
+ return fst.Properties(props, true) == props;
+ }
+
+ static const string &Type() {
+ static const string type = "weighted_string";
+ return type;
+ }
+
+ bool Write(std::ostream &strm) const { return true; }
+
+ static WeightedStringCompactor *Read(std::istream &strm) {
+ return new WeightedStringCompactor;
+ }
+};
+
+// Compactor for unweighted acceptor FSTs.
+template <class A>
+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<Label, StateId>;
+
+ Element Compact(StateId s, const Arc &arc) const {
+ return std::make_pair(arc.ilabel, arc.nextstate);
+ }
+
+ Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const {
+ return Arc(p.first, p.first, Weight::One(), p.second);
+ }
+
+ constexpr ssize_t Size() const { return -1; }
+
+ constexpr uint64 Properties() const { return kAcceptor | kUnweighted; }
+
+ bool Compatible(const Fst<Arc> &fst) const {
+ const auto props = Properties();
+ return fst.Properties(props, true) == props;
+ }
+
+ static const string &Type() {
+ static const string type = "unweighted_acceptor";
+ return type;
+ }
+
+ bool Write(std::ostream &strm) const { return true; }
+
+ static UnweightedAcceptorCompactor *Read(std::istream &istrm) {
+ return new UnweightedAcceptorCompactor;
+ }
+};
+
+// Compactor for weighted acceptor FSTs.
+template <class A>
+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<std::pair<Label, Weight>, StateId>;
+
+ Element Compact(StateId s, const Arc &arc) const {
+ return std::make_pair(std::make_pair(arc.ilabel, arc.weight),
+ arc.nextstate);
+ }
+
+ Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const {
+ return Arc(p.first.first, p.first.first, p.first.second, p.second);
+ }
+
+ constexpr ssize_t Size() const { return -1; }
+
+ constexpr uint64 Properties() const { return kAcceptor; }
+
+ bool Compatible(const Fst<Arc> &fst) const {
+ const auto props = Properties();
+ return fst.Properties(props, true) == props;
+ }
+
+ static const string &Type() {
+ static const string type = "acceptor";
+ return type;
+ }
+
+ bool Write(std::ostream &strm) const { return true; }
+
+ static AcceptorCompactor *Read(std::istream &strm) {
+ return new AcceptorCompactor;
+ }
+};
+
+// Compactor for unweighted FSTs.
+template <class A>
+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<std::pair<Label, Label>, StateId>;
+
+ Element Compact(StateId s, const Arc &arc) const {
+ return std::make_pair(std::make_pair(arc.ilabel, arc.olabel),
+ arc.nextstate);
+ }
+
+ Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const {
+ return Arc(p.first.first, p.first.second, Weight::One(), p.second);
+ }
+
+ constexpr ssize_t Size() const { return -1; }
+
+ constexpr uint64 Properties() const { return kUnweighted; }
+
+ bool Compatible(const Fst<Arc> &fst) const {
+ const auto props = Properties();
+ return fst.Properties(props, true) == props;
+ }
+
+ static const string &Type() {
+ static const string type = "unweighted";
+ return type;
+ }
+
+ bool Write(std::ostream &strm) const { return true; }
+
+ static UnweightedCompactor *Read(std::istream &strm) {
+ return new UnweightedCompactor;
+ }
+};
+
+template <class Arc, class Unsigned /* = uint32 */>
+using CompactStringFst = CompactFst<Arc, StringCompactor<Arc>, Unsigned>;
+
+template <class Arc, class Unsigned /* = uint32 */>
+using CompactWeightedStringFst =
+ CompactFst<Arc, WeightedStringCompactor<Arc>, Unsigned>;
+
+template <class Arc, class Unsigned /* = uint32 */>
+using CompactAcceptorFst = CompactFst<Arc, AcceptorCompactor<Arc>, Unsigned>;
+
+template <class Arc, class Unsigned /* = uint32 */>
+using CompactUnweightedFst =
+ CompactFst<Arc, UnweightedCompactor<Arc>, Unsigned>;
+
+template <class Arc, class Unsigned /* = uint32 */>
+using CompactUnweightedAcceptorFst =
+ CompactFst<Arc, UnweightedAcceptorCompactor<Arc>, Unsigned>;
+
+using StdCompactStringFst = CompactStringFst<StdArc, uint32>;
+
+using StdCompactWeightedStringFst = CompactWeightedStringFst<StdArc, uint32>;
+
+using StdCompactAcceptorFst = CompactAcceptorFst<StdArc, uint32>;
+
+using StdCompactUnweightedFst = CompactUnweightedFst<StdArc, uint32>;
+
+using StdCompactUnweightedAcceptorFst =
+ CompactUnweightedAcceptorFst<StdArc, uint32>;
+
+} // namespace fst
+
+#endif // FST_LIB_COMPACT_FST_H_
--- /dev/null
+// 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 <climits>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <vector>
+
+// Makes copy constructor and operator= private
+// Deprecated: now just use =delete.
+#define DISALLOW_COPY_AND_ASSIGN(type) \
+ type(const type&); \
+ void operator=(const type&)
+
+#if defined(__GNUC__) || defined(__clang__)
+#define OPENFST_DEPRECATED(message) __attribute__((deprecated(message)))
+#elif defined(_MSC_VER)
+#define OPENFST_DEPRECATED(message) __declspec(deprecated(message))
+#else
+#define OPENFST_DEPRECATED(message)
+#endif
+
+#include <fst/config.h>
+#include <fst/types.h>
+#include <fst/lock.h>
+#include <fst/flags.h>
+#include <fst/log.h>
+#include <fst/icu.h>
+
+using std::string;
+
+void FailedNewHandler();
+
+namespace fst {
+
+// Downcasting.
+template<typename To, typename From>
+inline To down_cast(From* f) { return static_cast<To>(f); }
+
+// Bitcasting.
+template <class Dest, class Source>
+inline Dest bit_cast(const Source &source) {
+ static_assert(sizeof(Dest) == sizeof(Source),
+ "Bitcasting unsafe for specified types");
+ Dest dest;
+ memcpy(&dest, &source, sizeof(dest));
+ return dest;
+}
+
+// Check sums
+class CheckSummer {
+ public:
+ CheckSummer() : count_(0) {
+ check_sum_.resize(kCheckSumLength, '\0');
+ }
+
+ void Reset() {
+ count_ = 0;
+ for (int i = 0; i < kCheckSumLength; ++i) check_sum_[i] = '\0';
+ }
+
+ void Update(void const *data, int size) {
+ const char *p = reinterpret_cast<const char *>(data);
+ for (int i = 0; i < size; ++i) {
+ check_sum_[(count_++) % kCheckSumLength] ^= p[i];
+ }
+ }
+
+ void Update(string const &data) {
+ for (int i = 0; i < data.size(); ++i) {
+ check_sum_[(count_++) % kCheckSumLength] ^= data[i];
+ }
+ }
+
+ string Digest() { return check_sum_; }
+
+ private:
+ static const int kCheckSumLength = 32;
+ int count_;
+ string check_sum_;
+
+ CheckSummer(const CheckSummer &) = delete;
+ CheckSummer &operator=(const CheckSummer &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_COMPAT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Class to complement an FST.
+
+#ifndef FST_LIB_COMPLEMENT_H_
+#define FST_LIB_COMPLEMENT_H_
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include <fst/fst.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+template <class Arc>
+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 A>
+class ComplementFstImpl : public FstImpl<A> {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<A>::SetType;
+ using FstImpl<A>::SetProperties;
+ using FstImpl<A>::SetInputSymbols;
+ using FstImpl<A>::SetOutputSymbols;
+
+ friend class StateIterator<ComplementFst<Arc>>;
+ friend class ArcIterator<ComplementFst<Arc>>;
+
+ explicit ComplementFstImpl(const Fst<Arc> &fst) : fst_(fst.Copy()) {
+ SetType("complement");
+ uint64 props = fst.Properties(kILabelSorted, false);
+ SetProperties(ComplementProperties(props), kCopyProperties);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ }
+
+ ComplementFstImpl(const ComplementFstImpl<Arc> &impl)
+ : fst_(impl.fst_->Copy()) {
+ SetType("complement");
+ SetProperties(impl.Properties(), kCopyProperties);
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ StateId Start() const {
+ if (Properties(kError)) return kNoStateId;
+ auto start = fst_->Start();
+ return start != kNoStateId ? start + 1 : 0;
+ }
+
+ // Exchange final and non-final states; makes ρ-destination state final.
+ Weight Final(StateId s) const {
+ if (s == 0 || fst_->Final(s - 1) == Weight::Zero()) {
+ return Weight::One();
+ } else {
+ return Weight::Zero();
+ }
+ }
+
+ size_t NumArcs(StateId s) const {
+ return s == 0 ? 1 : fst_->NumArcs(s - 1) + 1;
+ }
+
+ size_t NumInputEpsilons(StateId s) const {
+ return s == 0 ? 0 : fst_->NumInputEpsilons(s - 1);
+ }
+
+ size_t NumOutputEpsilons(StateId s) const {
+ return s == 0 ? 0 : fst_->NumOutputEpsilons(s - 1);
+ }
+
+ uint64 Properties() const override { return Properties(kFstProperties); }
+
+ // Sets error if found, and returns other FST impl properties.
+ uint64 Properties(uint64 mask) const override {
+ if ((mask & kError) && fst_->Properties(kError, false)) {
+ SetProperties(kError, kError);
+ }
+ return FstImpl<Arc>::Properties(mask);
+ }
+
+ private:
+ std::unique_ptr<const Fst<Arc>> 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 A>
+class ComplementFst : public ImplToFst<internal::ComplementFstImpl<A>> {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Impl = internal::ComplementFstImpl<Arc>;
+
+ friend class StateIterator<ComplementFst<Arc>>;
+ friend class ArcIterator<ComplementFst<Arc>>;
+
+ explicit ComplementFst(const Fst<Arc> &fst)
+ : ImplToFst<Impl>(std::make_shared<Impl>(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<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Gets a copy of this FST. See Fst<>::Copy() for further doc.
+ ComplementFst<Arc> *Copy(bool safe = false) const override {
+ return new ComplementFst<Arc>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ inline void InitArcIterator(StateId s,
+ ArcIteratorData<Arc> *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<Impl>::GetImpl;
+
+ ComplementFst &operator=(const ComplementFst &) = delete;
+};
+
+template <class Arc>
+const typename Arc::Label ComplementFst<Arc>::kRhoLabel;
+
+// Specialization for ComplementFst.
+template <class Arc>
+class StateIterator<ComplementFst<Arc>> final : public StateIteratorBase<Arc> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ explicit StateIterator(const ComplementFst<Arc> &fst)
+ : siter_(*fst.GetImpl()->fst_), s_(0) {}
+
+ bool Done() const override { return s_ > 0 && siter_.Done(); }
+
+ StateId Value() const override { return s_; }
+
+ void Next() override {
+ if (s_ != 0) siter_.Next();
+ ++s_;
+ }
+
+ void Reset() override {
+ siter_.Reset();
+ s_ = 0;
+ }
+
+ private:
+ StateIterator<Fst<Arc>> siter_;
+ StateId s_;
+};
+
+// Specialization for ComplementFst.
+template <class Arc>
+class ArcIterator<ComplementFst<Arc>> final
+ : public fst::ArcIteratorBase<Arc> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ ArcIterator(const ComplementFst<Arc> &fst, StateId s) : s_(s), pos_(0) {
+ if (s_ != 0) {
+ aiter_.reset(new ArcIterator<Fst<Arc>>(*fst.GetImpl()->fst_, s - 1));
+ }
+ }
+
+ bool Done() const override {
+ if (s_ != 0) {
+ return pos_ > 0 && aiter_->Done();
+ } else {
+ return pos_ > 0;
+ }
+ }
+
+ // Adds the ρ-label to the ρ destination state.
+ const Arc &Value() const override {
+ if (pos_ == 0) {
+ arc_.ilabel = arc_.olabel = ComplementFst<Arc>::kRhoLabel;
+ arc_.weight = Weight::One();
+ arc_.nextstate = 0;
+ } else {
+ arc_ = aiter_->Value();
+ ++arc_.nextstate;
+ }
+ return arc_;
+ }
+
+ void Next() override {
+ if (s_ != 0 && pos_ > 0) aiter_->Next();
+ ++pos_;
+ }
+
+ size_t Position() const override { return pos_; }
+
+ void Reset() override {
+ if (s_ != 0) aiter_->Reset();
+ pos_ = 0;
+ }
+
+ void Seek(size_t a) override {
+ if (s_ != 0) {
+ if (a == 0) {
+ aiter_->Reset();
+ } else {
+ aiter_->Seek(a - 1);
+ }
+ }
+ pos_ = a;
+ }
+
+ constexpr uint32 Flags() const override { return kArcValueFlags; }
+
+ void SetFlags(uint32, uint32) override {}
+
+ private:
+ std::unique_ptr<ArcIterator<Fst<Arc>>> aiter_;
+ StateId s_;
+ size_t pos_;
+ mutable Arc arc_;
+};
+
+template <class Arc>
+inline void ComplementFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<ComplementFst<Arc>>(*this);
+}
+
+template <class Arc>
+inline void ComplementFst<Arc>::InitArcIterator(StateId s,
+ ArcIteratorData<Arc> *data) const {
+ data->base = new ArcIterator<ComplementFst<Arc>>(*this, s);
+}
+
+// Useful alias when using StdArc.
+using StdComplementFst = ComplementFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_COMPLEMENT_H_
--- /dev/null
+// 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_LIB_COMPOSE_FILTER_H_
+#define FST_LIB_COMPOSE_FILTER_H_
+
+#include <fst/filter-state.h>
+#include <fst/fst-decl.h> // For optional argument declarations
+#include <fst/fst.h>
+#include <fst/matcher.h>
+
+
+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 M1, class M2>
+// 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<M1, M2> &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 M1, class M2 /* = M1 */>
+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<M1, M2> &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> matcher1_;
+ std::unique_ptr<Matcher2> 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 M1, class M2 /* = M1 */>
+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<Matcher1, Matcher2> &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> matcher1_;
+ std::unique_ptr<Matcher2> matcher2_;
+ const FST1 &fst1_;
+ const FST2 &fst2_;
+};
+
+// This filter requires epsilons on FST1 to be read before epsilons on FST2.
+template <class M1, class M2 /* = M1 */>
+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<Matcher1, Matcher2> &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> matcher1_;
+ std::unique_ptr<Matcher2> 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 M1, class M2 /* = M1 */>
+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<Matcher1, Matcher2> &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> matcher1_;
+ std::unique_ptr<Matcher2> 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 M1, class M2 /* = M1 */>
+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<Matcher1, Matcher2> &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> matcher1_;
+ std::unique_ptr<Matcher2> matcher2_;
+ const FST1 &fst1_;
+ const FST2 &fst2_;
+ StateId s1_; // Current fst1_ state.
+ StateId s2_; // Current fst2_ state.
+ FilterState fs_; // Current filter state ID.
+ bool alleps1_; // Only epsilson (and non-final) leaving s1?
+ bool alleps2_; // Only epsilons (and non-final) leaving s2?
+ bool noeps1_; // No epsilons leaving s1?
+ bool noeps2_; // No epsilons leaving s2?
+};
+
+// This filter works with the MultiEpsMatcher to determine if multi-epsilons are
+// preserved in the composition output (rather than rewritten as 0) and
+// ensures correct properties.
+template <class Filter>
+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> &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_LIB_COMPOSE_FILTER_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Class to compute the composition of two FSTs.
+
+#ifndef FST_LIB_COMPOSE_H_
+#define FST_LIB_COMPOSE_H_
+
+#include <algorithm>
+
+#include <fst/cache.h>
+#include <fst/compose-filter.h>
+#include <fst/fst-decl.h> // For optional argument declarations
+#include <fst/lookahead-filter.h>
+#include <fst/matcher.h>
+#include <fst/state-table.h>
+#include <fst/test-properties.h>
+
+
+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<Arc>
+// types and a shared matcher type M for Fst<Arc>. This should be
+// adequate for most applications, giving a reasonable tradeoff
+// between efficiency and code sharing (but see ComposeFstImplOptions).
+template <class Arc, class M = Matcher<Fst<Arc>>,
+ class Filter = SequenceComposeFilter<M>,
+ class StateTable =
+ GenericComposeStateTable<Arc, typename Filter::FilterState>>
+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 C, class F, class T>
+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 M1, class M2, class Filter = SequenceComposeFilter<M1, M2>,
+ class StateTable = GenericComposeStateTable<
+ typename M1::Arc, typename Filter::FilterState>,
+ class CacheStore = DefaultCacheStore<typename M1::Arc>>
+struct ComposeFstImplOptions : public CacheImplOptions<CacheStore> {
+ 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'?
+
+ explicit ComposeFstImplOptions(const CacheOptions &opts,
+ M1 *matcher1 = nullptr, M2 *matcher2 = nullptr,
+ Filter *filter = nullptr,
+ StateTable *state_table = nullptr)
+ : CacheImplOptions<CacheStore>(opts),
+ matcher1(matcher1),
+ matcher2(matcher2),
+ filter(filter),
+ state_table(state_table),
+ own_state_table(true) {}
+
+ explicit ComposeFstImplOptions(const CacheImplOptions<CacheStore> &opts,
+ M1 *matcher1 = nullptr, M2 *matcher2 = nullptr,
+ Filter *filter = nullptr,
+ StateTable *state_table = nullptr)
+ : CacheImplOptions<CacheStore>(opts),
+ matcher1(matcher1),
+ matcher2(matcher2),
+ filter(filter),
+ state_table(state_table),
+ own_state_table(true) {}
+
+ ComposeFstImplOptions()
+ : matcher1(nullptr),
+ matcher2(nullptr),
+ filter(nullptr),
+ state_table(nullptr),
+ own_state_table(true) {}
+};
+
+namespace internal {
+
+// Implementation of delayed composition. This base class is common to the
+// variants with different matchers, composition filters and state tables.
+template <class Arc, class CacheStore = DefaultCacheStore<Arc>>
+class ComposeFstImplBase
+ : public CacheBaseImpl<typename CacheStore::State, CacheStore> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using State = typename CacheStore::State;
+ using CacheImpl = CacheBaseImpl<State, CacheStore>;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::Properties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheImpl::HasStart;
+ using CacheImpl::HasFinal;
+ using CacheImpl::HasArcs;
+ using CacheImpl::SetFinal;
+ using CacheImpl::SetStart;
+
+ ComposeFstImplBase(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const CacheImplOptions<CacheStore> &opts)
+ : CacheImpl(opts) {
+ InitBase(fst1, fst2);
+ }
+
+ ComposeFstImplBase(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const CacheOptions &opts)
+ : CacheImpl(opts) {
+ InitBase(fst1, fst2);
+ }
+
+ ComposeFstImplBase(const ComposeFstImplBase<Arc, CacheStore> &impl)
+ : CacheImpl(impl, true) {
+ SetType(impl.Type());
+ SetProperties(impl.Properties(), kCopyProperties);
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ virtual ComposeFstImplBase<Arc, CacheStore> *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<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl::InitArcIterator(s, data);
+ }
+
+ virtual MatcherBase<Arc> *InitMatcher(const ComposeFst<Arc, CacheStore> &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;
+
+ void InitBase(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {
+ 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());
+ }
+};
+
+// 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 CacheStore, class Filter, class StateTable>
+class ComposeFstImpl
+ : public ComposeFstImplBase<typename CacheStore::Arc, CacheStore> {
+ public:
+ using Matcher1 = typename Filter::Matcher1;
+ using Matcher2 = typename Filter::Matcher2;
+
+ using FST1 = typename Matcher1::FST;
+ using FST2 = typename Matcher2::FST;
+
+ using Arc = typename Matcher1::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<State, CacheStore>;
+
+ using StateTuple = typename StateTable::StateTuple;
+
+ friend class ComposeFstMatcher<CacheStore, Filter, StateTable>;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+
+ template <class M1, class M2>
+ ComposeFstImpl(const FST1 &fst1, const FST2 &fst2,
+ const ComposeFstImplOptions<M1, M2, Filter, StateTable,
+ CacheStore> &opts);
+
+ ComposeFstImpl(const ComposeFstImpl<CacheStore, Filter, StateTable> &impl)
+ : ComposeFstImplBase<Arc, CacheStore>(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<CacheStore, Filter, StateTable> *Copy() const override {
+ return new ComposeFstImpl<CacheStore, Filter, StateTable>(*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<Arc>::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<Arc> *InitMatcher(const ComposeFst<Arc, CacheStore> &fst,
+ MatchType match_type) const override {
+ const auto test_props = match_type == MATCH_INPUT
+ ? kFstProperties & ~kILabelInvariantProperties
+ : kFstProperties & ~kOLabelInvariantProperties;
+ // If both matchers support 'match_type' and we have a guarantee that a
+ // call to 'filter_->FilterArc(arc1, arc2)' will not modify the ilabel of
+ // arc1 when MATCH_INPUT or the olabel or arc2 when MATCH_OUTPUT, then
+ // ComposeFstMatcher can be used.
+ if ((matcher1_->Type(false) == match_type) &&
+ (matcher2_->Type(false) == match_type) &&
+ (filter_->Properties(test_props) == test_props)) {
+ return new ComposeFstMatcher<CacheStore, Filter, StateTable>(fst, this,
+ 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 <class FST, class Matcher>
+ void OrderedExpand(StateId s, const Fst<Arc> &, 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<FST> 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 <class Matcher>
+ void MatchArc(StateId s, Matcher *matchera, const Arc &arc,
+ bool match_input) {
+ if (matchera->Find(match_input ? arc.olabel : arc.ilabel)) {
+ for (; !matchera->Done(); matchera->Next()) {
+ auto arca = matchera->Value();
+ auto arcb = arc;
+ if (match_input) {
+ const auto &fs = filter_->FilterArc(&arcb, &arca);
+ if (fs != FilterState::NoState()) AddArc(s, arcb, arca, fs);
+ } else {
+ const auto &fs = filter_->FilterArc(&arca, &arcb);
+ if (fs != FilterState::NoState()) AddArc(s, arca, arcb, fs);
+ }
+ }
+ }
+ }
+
+ // Add a matching transition at 's'.
+ void AddArc(StateId s, const Arc &arc1, const Arc &arc2,
+ const FilterState &f) {
+ const StateTuple tuple(arc1.nextstate, arc2.nextstate, f);
+ const Arc oarc(arc1.ilabel, arc2.olabel, Times(arc1.weight, arc2.weight),
+ state_table_->FindState(tuple));
+ CacheImpl::PushArc(s, oarc);
+ }
+
+ StateId ComputeStart() override {
+ const auto s1 = fst1_.Start();
+ if (s1 == kNoStateId) return kNoStateId;
+ const auto s2 = fst2_.Start();
+ if (s2 == kNoStateId) return kNoStateId;
+ const auto &fs = filter_->Start();
+ const StateTuple tuple(s1, s2, fs);
+ return state_table_->FindState(tuple);
+ }
+
+ Weight ComputeFinal(StateId s) override {
+ const auto &tuple = state_table_->Tuple(s);
+ const auto s1 = tuple.StateId1();
+ auto final1 = matcher1_->Final(s1);
+ if (final1 == Weight::Zero()) return final1;
+ const auto s2 = tuple.StateId2();
+ auto final2 = matcher2_->Final(s2);
+ if (final2 == Weight::Zero()) return final2;
+ filter_->SetState(s1, s2, tuple.GetFilterState());
+ filter_->FilterFinal(&final1, &final2);
+ return Times(final1, final2);
+ }
+
+ // Determines which side to match on per composition state.
+ bool MatchInput(StateId s1, StateId s2) {
+ switch (match_type_) {
+ case MATCH_INPUT:
+ return true;
+ case MATCH_OUTPUT:
+ return false;
+ default: // MATCH_BOTH
+ const auto priority1 = matcher1_->Priority(s1);
+ const auto priority2 = matcher2_->Priority(s2);
+ if (priority1 == kRequirePriority && priority2 == kRequirePriority) {
+ FSTERROR() << "ComposeFst: Both sides can't require match";
+ SetProperties(kError, kError);
+ return true;
+ }
+ if (priority1 == kRequirePriority) return false;
+ if (priority2 == kRequirePriority) {
+ return true;
+ }
+ return priority1 <= priority2;
+ }
+ }
+
+ // Identifies and verifies the capabilities of the matcher to be used for
+ // composition.
+ void SetMatchType();
+
+ std::unique_ptr<Filter> 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 <class CacheStore, class Filter, class StateTable>
+template <class M1, class M2>
+ComposeFstImpl<CacheStore, Filter, StateTable>::ComposeFstImpl(
+ const FST1 &fst1, const FST2 &fst2,
+ const ComposeFstImplOptions<M1, M2, Filter, StateTable, CacheStore> &opts)
+ : ComposeFstImplBase<Arc, CacheStore>(fst1, fst2, 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) {
+ 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 <class CacheStore, class Filter, class StateTable>
+void ComposeFstImpl<CacheStore, Filter, StateTable>::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 A, class CacheStore /* = DefaultCacheStore<A> */>
+class ComposeFst
+ : public ImplToFst<internal::ComposeFstImplBase<A, CacheStore>> {
+ 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<A, CacheStore>;
+
+ friend class ArcIterator<ComposeFst<Arc, CacheStore>>;
+ friend class StateIterator<ComposeFst<Arc, CacheStore>>;
+
+ // Compose specifying only caching options.
+ ComposeFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const CacheOptions &opts = CacheOptions())
+ : ImplToFst<Impl>(CreateBase(fst1, fst2, opts)) {}
+
+ // Compose specifying one shared matcher type M. Requires that the input FSTs
+ // and matcher FST types be Fst<Arc>. Recommended for best code-sharing and
+ // matcher compatiblity.
+ template <class Matcher, class Filter, class StateTuple>
+ ComposeFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const ComposeFstOptions<Arc, Matcher, Filter, StateTuple> &opts)
+ : ImplToFst<Impl>(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 <class Matcher1, class Matcher2, class Filter, class StateTuple>
+ ComposeFst(const typename Matcher1::FST &fst1,
+ const typename Matcher2::FST &fst2,
+ const ComposeFstImplOptions<Matcher1, Matcher2, Filter, StateTuple,
+ CacheStore> &opts)
+ : ImplToFst<Impl>(CreateBase2(fst1, fst2, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ ComposeFst(const ComposeFst<A, CacheStore> &fst, bool safe = false)
+ : ImplToFst<Impl>(safe ? std::shared_ptr<Impl>(fst.GetImpl()->Copy())
+ : fst.GetSharedImpl()) {}
+
+ // Get a copy of this ComposeFst. See Fst<>::Copy() for further doc.
+ ComposeFst<A, CacheStore> *Copy(bool safe = false) const override {
+ return new ComposeFst<A, CacheStore>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ MatcherBase<Arc> *InitMatcher(MatchType match_type) const override {
+ return GetImpl()->InitMatcher(*this, match_type);
+ }
+
+ protected:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ explicit ComposeFst(std::shared_ptr<Impl> impl) : ImplToFst<Impl>(impl) {}
+
+ // Create compose implementation specifying two matcher types.
+ template <class Matcher1, class Matcher2, class Filter, class StateTuple>
+ static std::shared_ptr<Impl> CreateBase2(
+ const typename Matcher1::FST &fst1, const typename Matcher2::FST &fst2,
+ const ComposeFstImplOptions<Matcher1, Matcher2, Filter, StateTuple,
+ CacheStore> &opts) {
+ auto impl = std::make_shared<
+ internal::ComposeFstImpl<CacheStore, Filter, StateTuple>>(fst1, fst2,
+ opts);
+ // TODO(kbg): Make this a compile-time static_assert once all weight
+ // properties are made constexpr for all weight types.
+ if (!(Weight::Properties() & kCommutative)) {
+ 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<Arc>.
+ template <class Matcher, class Filter, class StateTuple>
+ static std::shared_ptr<Impl> CreateBase1(
+ const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const ComposeFstOptions<Arc, Matcher, Filter, StateTuple> &opts) {
+ ComposeFstImplOptions<Matcher, Matcher, Filter, StateTuple, CacheStore>
+ 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<Impl> CreateBase(const Fst<Arc> &fst1,
+ const Fst<Arc> &fst2,
+ const CacheOptions &opts) {
+ switch (LookAheadMatchType(fst1, fst2)) { // Check for lookahead matchers
+ default:
+ case MATCH_NONE: { // Default composition (no look-ahead).
+ ComposeFstOptions<Arc> nopts(opts);
+ return CreateBase1(fst1, fst2, nopts);
+ }
+ case MATCH_OUTPUT: { // Lookahead on fst1.
+ using M = typename DefaultLookAhead<Arc, MATCH_OUTPUT>::FstMatcher;
+ using F = typename DefaultLookAhead<Arc, MATCH_OUTPUT>::ComposeFilter;
+ ComposeFstOptions<Arc, M, F> nopts(opts);
+ return CreateBase1(fst1, fst2, nopts);
+ }
+ case MATCH_INPUT: { // Lookahead on fst2
+ using M = typename DefaultLookAhead<Arc, MATCH_INPUT>::FstMatcher;
+ using F = typename DefaultLookAhead<Arc, MATCH_INPUT>::ComposeFilter;
+ ComposeFstOptions<Arc, M, F> nopts(opts);
+ return CreateBase1(fst1, fst2, nopts);
+ }
+ }
+ }
+
+ private:
+ ComposeFst &operator=(const ComposeFst &fst) = delete;
+};
+
+// Specialization for ComposeFst.
+template <class Arc, class CacheStore>
+class StateIterator<ComposeFst<Arc, CacheStore>>
+ : public CacheStateIterator<ComposeFst<Arc, CacheStore>> {
+ public:
+ explicit StateIterator(const ComposeFst<Arc, CacheStore> &fst)
+ : CacheStateIterator<ComposeFst<Arc, CacheStore>>(fst,
+ fst.GetMutableImpl()) {}
+};
+
+// Specialization for ComposeFst.
+template <class Arc, class CacheStore>
+class ArcIterator<ComposeFst<Arc, CacheStore>>
+ : public CacheArcIterator<ComposeFst<Arc, CacheStore>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const ComposeFst<Arc, CacheStore> &fst, StateId s)
+ : CacheArcIterator<ComposeFst<Arc, CacheStore>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class Arc, class CacheStore>
+inline void ComposeFst<Arc, CacheStore>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<ComposeFst<Arc, CacheStore>>(*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 CacheStore, class Filter, class StateTable>
+class ComposeFstMatcher final : public MatcherBase<typename CacheStore::Arc> {
+ 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;
+
+ ComposeFstMatcher(
+ const ComposeFst<Arc, CacheStore> &fst,
+ const internal::ComposeFstImpl<CacheStore, Filter, StateTable> *impl,
+ MatchType match_type)
+ : fst_(fst),
+ impl_(impl),
+ s_(kNoStateId),
+ match_type_(match_type),
+ matcher1_(impl->matcher1_->Copy()),
+ matcher2_(impl->matcher2_->Copy()),
+ current_loop_(false),
+ loop_(kNoLabel, 0, Weight::One(), kNoStateId),
+ error_(false) {
+ if (match_type_ == MATCH_OUTPUT) std::swap(loop_.ilabel, loop_.olabel);
+ }
+
+ ComposeFstMatcher(
+ const ComposeFstMatcher<CacheStore, Filter, StateTable> &matcher,
+ bool safe = false)
+ : fst_(matcher.fst_),
+ impl_(matcher.impl_),
+ 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),
+ error_(matcher.error_) {
+ if (safe == true) {
+ FSTERROR() << "ComposeFstMatcher: Safe copy not supported";
+ error_ = true;
+ }
+ if (match_type_ == MATCH_OUTPUT) std::swap(loop_.ilabel, loop_.olabel);
+ }
+
+ ComposeFstMatcher<CacheStore, Filter, StateTable> *Copy(
+ bool safe = false) const override {
+ return new ComposeFstMatcher<CacheStore, Filter, StateTable>(*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<Arc> &GetFst() const override { return fst_; }
+
+ uint64 Properties(uint64 inprops) const override {
+ auto outprops = inprops;
+ if (error_) outprops |= kError;
+ return outprops;
+ }
+
+ 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;
+ 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 <class MatcherA, class MatcherB>
+ 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 <class MatcherA, class MatcherB>
+ bool FindNext(MatcherA *matchera, MatcherB *matcherb) {
+ // State when entering this function:
+ // 'matchera' is pointed to a match x, y for label x, and a match for y was
+ // requested on 'matcherb'.
+ while (!matchera->Done() || !matcherb->Done()) {
+ if (matcherb->Done()) {
+ // If no more matches for y on 'matcherb', moves forward on 'matchera'
+ // until a match x, y' is found such that there is a match for y' on
+ // 'matcherb'.
+ matchera->Next();
+ while (!matchera->Done() &&
+ !matcherb->Find(match_type_ == MATCH_INPUT
+ ? matchera->Value().olabel
+ : matchera->Value().ilabel)) {
+ matchera->Next();
+ }
+ }
+ while (!matcherb->Done()) {
+ // 'matchera' is pointing to a match x, y' ('arca') and 'matcherb' is
+ // pointing to a match y', z' ('arcb'). If combining these two arcs is
+ // allowed by the filter (hence resulting in an arc x, z') return true.
+ // Position 'matcherb' on the next potential match for y' before
+ // returning.
+ const auto &arca = matchera->Value();
+ const auto &arcb = matcherb->Value();
+ // Position 'matcherb' on the next potential match for y'.
+ matcherb->Next();
+ // Returns true If combining these two arcs is allowed by the filter
+ // (hence resulting in an arc x, z'); otherwise consider next match
+ // for y' on 'matcherb'.
+ if (MatchArc(s_, match_type_ == MATCH_INPUT ? arca : arcb,
+ match_type_ == MATCH_INPUT ? arcb : arca)) {
+ return true;
+ }
+ }
+ }
+ // Both 'matchera' and 'matcherb' are done, no more match to analyse.
+ return false;
+ }
+
+ void SetState_(StateId s) override {
+ 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) override {
+ 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 override {
+ return !current_loop_ && matcher1_->Done() && matcher2_->Done();
+ }
+
+ const Arc &Value_() const override { return current_loop_ ? loop_ : arc_; }
+
+ void Next_() override {
+ 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) override { return fst_.NumArcs(s); }
+
+ const ComposeFst<Arc, CacheStore> &fst_;
+ const internal::ComposeFstImpl<CacheStore, Filter, StateTable> *impl_;
+ StateId s_;
+ MatchType match_type_;
+ std::unique_ptr<Matcher1> matcher1_;
+ std::unique_ptr<Matcher2> matcher2_;
+ bool current_loop_;
+ Arc loop_;
+ Arc arc_;
+ bool error_;
+};
+
+// Useful alias when using StdArc.
+using StdComposeFst = ComposeFst<StdArc>;
+
+enum ComposeFilter {
+ AUTO_FILTER,
+ NULL_FILTER,
+ TRIVIAL_FILTER,
+ SEQUENCE_FILTER,
+ ALT_SEQUENCE_FILTER,
+ MATCH_FILTER
+};
+
+struct ComposeOptions {
+ bool connect; // Connect output?
+ ComposeFilter filter_type; // Pre-defined filter to use.
+
+ explicit ComposeOptions(bool connect = true,
+ ComposeFilter filter_type = AUTO_FILTER)
+ : connect(connect), filter_type(filter_type) {}
+};
+
+// Computes the composition of two transducers. This version writes
+// the composed FST into a MutableFst. If FST1 transduces string x to
+// y with weight a and FST2 transduces y to z with weight b, then
+// their composition transduces string x to z with weight
+// Times(x, z).
+//
+// The output labels of the first transducer or the input labels of
+// the second transducer must be sorted. The weights need to form a
+// commutative semiring (valid for TropicalWeight and LogWeight).
+//
+// Complexity:
+//
+// Assuming the first FST is unsorted and the second is sorted:
+//
+// Time: O(V1 V2 D1 (log D2 + M2)),
+// Space: O(V1 V2 D1 M2)
+//
+// where Vi = # of states, Di = maximum out-degree, and Mi is the maximum
+// multiplicity, for the ith FST.
+//
+// Caveats:
+//
+// - Compose trims its output.
+// - The efficiency of composition can be strongly affected by several factors:
+// - the choice of which transducer is sorted - prefer sorting the FST
+// that has the greater average out-degree.
+// - the amount of non-determinism
+// - the presence and location of epsilon transitions - avoid epsilon
+// transitions on the output side of the first transducer or
+// the input side of the second transducer or prefer placing
+// them later in a path since they delay matching and can
+// introduce non-coaccessible states and transitions.
+template <class Arc>
+void Compose(const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ MutableFst<Arc> *ofst,
+ const ComposeOptions &opts = ComposeOptions()) {
+ using M = Matcher<Fst<Arc>>;
+ // In each case, we cache only the last state for fastest copy.
+ if (opts.filter_type == AUTO_FILTER) {
+ CacheOptions nopts;
+ nopts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, nopts);
+ } else if (opts.filter_type == NULL_FILTER) {
+ ComposeFstOptions<Arc, M, NullComposeFilter<M>> copts;
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ } else if (opts.filter_type == SEQUENCE_FILTER) {
+ ComposeFstOptions<Arc, M, SequenceComposeFilter<M>> copts;
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ } else if (opts.filter_type == ALT_SEQUENCE_FILTER) {
+ ComposeFstOptions<Arc, M, AltSequenceComposeFilter<M>> copts;
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ } else if (opts.filter_type == MATCH_FILTER) {
+ ComposeFstOptions<Arc, M, MatchComposeFilter<M>> copts;
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ } else if (opts.filter_type == TRIVIAL_FILTER) {
+ ComposeFstOptions<Arc, M, TrivialComposeFilter<M>> copts;
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ }
+ if (opts.connect) Connect(ofst);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_COMPOSE_H_
--- /dev/null
+// 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_LIB_CONCAT_H_
+#define FST_LIB_CONCAT_H_
+
+#include <algorithm>
+#include <vector>
+
+#include <fst/mutable-fst.h>
+#include <fst/rational.h>
+
+
+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 <class Arc>
+void Concat(MutableFst<Arc> *fst1, const Fst<Arc> &fst2) {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ // Checks that the symbol table are compatible.
+ if (!CompatSymbols(fst1->InputSymbols(), fst2.InputSymbols()) ||
+ !CompatSymbols(fst1->OutputSymbols(), fst2.OutputSymbols())) {
+ FSTERROR() << "Concat: Input/output symbol tables of 1st argument "
+ << "does not match input/output symbol tables of 2nd argument";
+ fst1->SetProperties(kError, kError);
+ return;
+ }
+ const auto props1 = fst1->Properties(kFstProperties, false);
+ const auto props2 = fst2.Properties(kFstProperties, false);
+ const auto start1 = fst1->Start();
+ if (start1 == kNoStateId) {
+ if (props2 & kError) fst1->SetProperties(kError, kError);
+ return;
+ }
+ const auto numstates1 = fst1->NumStates();
+ if (fst2.Properties(kExpanded, false)) {
+ fst1->ReserveStates(numstates1 + CountStates(fst2));
+ }
+ for (StateIterator<Fst<Arc>> 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<Fst<Arc>> aiter(fst2, s2); !aiter.Done(); aiter.Next()) {
+ auto arc = aiter.Value();
+ arc.nextstate += numstates1;
+ fst1->AddArc(s1, arc);
+ }
+ }
+ const auto start2 = fst2.Start();
+ for (auto s1 = 0; s1 < numstates1; ++s1) {
+ const auto weight = fst1->Final(s1);
+ if (weight != Weight::Zero()) {
+ fst1->SetFinal(s1, Weight::Zero());
+ if (start2 != kNoStateId) {
+ fst1->AddArc(s1, Arc(0, 0, weight, start2 + numstates1));
+ }
+ }
+ }
+ if (start2 != kNoStateId) {
+ fst1->SetProperties(ConcatProperties(props1, props2), kFstProperties);
+ }
+}
+
+// Computes the concatentation of two FSTs. This version modifies its
+// MutableFst argument (in second position).
+//
+// Complexity:
+//
+// Time: O(V1 + E1)
+// Space: O(V1 + E1)
+//
+// where Vi is the number of states, and Ei is the number of arcs, of the ith
+// FST.
+template <class Arc>
+void Concat(const Fst<Arc> &fst1, MutableFst<Arc> *fst2) {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ // Checks that the symbol table are compatible.
+ if (!CompatSymbols(fst1.InputSymbols(), fst2->InputSymbols()) ||
+ !CompatSymbols(fst1.OutputSymbols(), fst2->OutputSymbols())) {
+ FSTERROR() << "Concat: Input/output symbol tables of 1st argument "
+ << "does not match input/output symbol tables of 2nd argument";
+ fst2->SetProperties(kError, kError);
+ return;
+ }
+ const auto props1 = fst1.Properties(kFstProperties, false);
+ const auto props2 = fst2->Properties(kFstProperties, false);
+ const auto start2 = fst2->Start();
+ if (start2 == kNoStateId) {
+ if (props1 & kError) fst2->SetProperties(kError, kError);
+ return;
+ }
+ const auto numstates2 = fst2->NumStates();
+ if (fst1.Properties(kExpanded, false)) {
+ fst2->ReserveStates(numstates2 + CountStates(fst1));
+ }
+ for (StateIterator<Fst<Arc>> 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<Fst<Arc>> aiter(fst1, s1); !aiter.Done(); aiter.Next()) {
+ auto arc = aiter.Value();
+ arc.nextstate += numstates2;
+ fst2->AddArc(s2, arc);
+ }
+ }
+ const auto start1 = fst1.Start();
+ if (start1 != kNoStateId) {
+ fst2->SetStart(start1 + numstates2);
+ fst2->SetProperties(ConcatProperties(props1, props2), kFstProperties);
+ } else {
+ fst2->SetStart(fst2->AddState());
+ }
+}
+
+// Computes the concatentation of two FSTs. This version modifies its
+// RationalFst input (in first position).
+template <class Arc>
+void Concat(RationalFst<Arc> *fst1, const Fst<Arc> &fst2) {
+ fst1->GetMutableImpl()->AddConcat(fst2, true);
+}
+
+// Computes the concatentation of two FSTs. This version modifies its
+// RationalFst input (in second position).
+template <class Arc>
+void Concat(const Fst<Arc> &fst1, RationalFst<Arc> *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 A>
+class ConcatFst : public RationalFst<A> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ ConcatFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {
+ GetMutableImpl()->InitConcat(fst1, fst2);
+ }
+
+ ConcatFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const ConcatFstOptions &opts)
+ : RationalFst<Arc>(opts) {
+ GetMutableImpl()->InitConcat(fst1, fst2);
+ }
+
+ // See Fst<>::Copy() for doc.
+ ConcatFst(const ConcatFst<Arc> &fst, bool safe = false)
+ : RationalFst<Arc>(fst, safe) {}
+
+ // Get a copy of this ConcatFst. See Fst<>::Copy() for further doc.
+ ConcatFst<Arc> *Copy(bool safe = false) const override {
+ return new ConcatFst<Arc>(*this, safe);
+ }
+
+ private:
+ using ImplToFst<internal::RationalFstImpl<Arc>>::GetImpl;
+ using ImplToFst<internal::RationalFstImpl<Arc>>::GetMutableImpl;
+};
+
+// Specialization for ConcatFst.
+template <class Arc>
+class StateIterator<ConcatFst<Arc>> : public StateIterator<RationalFst<Arc>> {
+ public:
+ explicit StateIterator(const ConcatFst<Arc> &fst)
+ : StateIterator<RationalFst<Arc>>(fst) {}
+};
+
+// Specialization for ConcatFst.
+template <class Arc>
+class ArcIterator<ConcatFst<Arc>> : public ArcIterator<RationalFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const ConcatFst<Arc> &fst, StateId s)
+ : ArcIterator<RationalFst<Arc>>(fst, s) {}
+};
+
+// Useful alias when using StdArc.
+using StdConcatFst = ConcatFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_CONCAT_H_
--- /dev/null
+/* 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<long long
+ unsigned>'. */
+#define HAVE_STD__TR1__HASH_LONG_LONG_UNSIGNED_ 1
+
+/* Define to 1 if the system has the type `__gnu_cxx::slist<int>'. */
+#define HAVE___GNU_CXX__SLIST_INT_ 1
--- /dev/null
+// 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<long long
+ unsigned>'. */
+#define HAVE_STD__TR1__HASH_LONG_LONG_UNSIGNED_ 1
+
+/* Define to 1 if the system has the type `__gnu_cxx::slist<int>'. */
+#define HAVE___GNU_CXX__SLIST_INT_ 1
--- /dev/null
+// 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_LIB_CONNECT_H_
+#define FST_LIB_CONNECT_H_
+
+#include <vector>
+
+#include <fst/dfs-visit.h>
+#include <fst/mutable-fst.h>
+#include <fst/union-find.h>
+
+
+namespace fst {
+
+// Finds and returns connected components. Use with Visit().
+template <class Arc>
+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<StateId> *cc)
+ : comps_(new UnionFind<StateId>(0, kNoStateId)), cc_(cc), nstates_(0) {}
+
+ // comps: connected components equiv classes.
+ explicit CcVisitor(UnionFind<StateId> *comps)
+ : comps_(comps), cc_(nullptr), nstates_(0) {}
+
+ ~CcVisitor() {
+ if (cc_) delete comps_;
+ }
+
+ void InitVisit(const Fst<Arc> &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<StateId> *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<StateId> *comps_; // Components.
+ std::vector<StateId> *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 Arc>
+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<StateId> *scc, std::vector<bool> *access,
+ std::vector<bool> *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<Arc> &fst);
+
+ bool InitState(StateId s, StateId root);
+
+ bool TreeArc(StateId s, const Arc &arc) { return true; }
+
+ bool BackArc(StateId s, const Arc &arc) {
+ const auto t = arc.nextstate;
+ if ((*dfnumber_)[t] < (*lowlink_)[s]) (*lowlink_)[s] = (*dfnumber_)[t];
+ if ((*coaccess_)[t]) (*coaccess_)[s] = true;
+ *props_ |= kCyclic;
+ *props_ &= ~kAcyclic;
+ if (t == start_) {
+ *props_ |= kInitialCyclic;
+ *props_ &= ~kInitialAcyclic;
+ }
+ return true;
+ }
+
+ bool ForwardOrCrossArc(StateId s, const Arc &arc) {
+ const auto t = arc.nextstate;
+ if ((*dfnumber_)[t] < (*dfnumber_)[s] /* cross edge */ && (*onstack_)[t] &&
+ (*dfnumber_)[t] < (*lowlink_)[s]) {
+ (*lowlink_)[s] = (*dfnumber_)[t];
+ }
+ if ((*coaccess_)[t]) (*coaccess_)[s] = true;
+ return true;
+ }
+
+ // Last argument always ignored, but required by the interface.
+ void FinishState(StateId state, StateId p, const Arc *);
+
+ void FinishVisit() {
+ // Numbers SCCs in topological order when acyclic.
+ if (scc_) {
+ for (StateId s = 0; s < scc_->size(); ++s) {
+ (*scc_)[s] = nscc_ - 1 - (*scc_)[s];
+ }
+ }
+ if (coaccess_internal_) delete coaccess_;
+ dfnumber_.reset();
+ lowlink_.reset();
+ onstack_.reset();
+ scc_stack_.reset();
+ }
+
+ private:
+ std::vector<StateId> *scc_; // State's scc number.
+ std::vector<bool> *access_; // State's accessibility.
+ std::vector<bool> *coaccess_; // State's coaccessibility.
+ uint64 *props_;
+ const Fst<Arc> *fst_;
+ StateId start_;
+ StateId nstates_; // State count.
+ StateId nscc_; // SCC count.
+ bool coaccess_internal_;
+ std::unique_ptr<std::vector<StateId>> dfnumber_; // State discovery times.
+ std::unique_ptr<std::vector<StateId>>
+ lowlink_; // lowlink[state] == dfnumber[state] => SCC root
+ std::unique_ptr<std::vector<bool>> onstack_; // Is a state on the SCC stack?
+ std::unique_ptr<std::vector<StateId>>
+ scc_stack_; // SCC stack, with random access.
+};
+
+template <class Arc>
+inline void SccVisitor<Arc>::InitVisit(const Fst<Arc> &fst) {
+ if (scc_) scc_->clear();
+ if (access_) access_->clear();
+ if (coaccess_) {
+ coaccess_->clear();
+ coaccess_internal_ = false;
+ } else {
+ coaccess_ = new std::vector<bool>;
+ coaccess_internal_ = true;
+ }
+ *props_ |= kAcyclic | kInitialAcyclic | kAccessible | kCoAccessible;
+ *props_ &= ~(kCyclic | kInitialCyclic | kNotAccessible | kNotCoAccessible);
+ fst_ = &fst;
+ start_ = fst.Start();
+ nstates_ = 0;
+ nscc_ = 0;
+ dfnumber_.reset(new std::vector<StateId>());
+ lowlink_.reset(new std::vector<StateId>());
+ onstack_.reset(new std::vector<bool>());
+ scc_stack_.reset(new std::vector<StateId>());
+}
+
+template <class Arc>
+inline bool SccVisitor<Arc>::InitState(StateId s, StateId root) {
+ scc_stack_->push_back(s);
+ while (dfnumber_->size() <= s) {
+ if (scc_) scc_->push_back(-1);
+ if (access_) access_->push_back(false);
+ coaccess_->push_back(false);
+ dfnumber_->push_back(-1);
+ lowlink_->push_back(-1);
+ onstack_->push_back(false);
+ }
+ (*dfnumber_)[s] = nstates_;
+ (*lowlink_)[s] = nstates_;
+ (*onstack_)[s] = true;
+ if (root == start_) {
+ if (access_) (*access_)[s] = true;
+ } else {
+ if (access_) (*access_)[s] = false;
+ *props_ |= kNotAccessible;
+ *props_ &= ~kAccessible;
+ }
+ ++nstates_;
+ return true;
+}
+
+template <class Arc>
+inline void SccVisitor<Arc>::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 <class Arc>
+void Connect(MutableFst<Arc> *fst) {
+ using StateId = typename Arc::StateId;
+ std::vector<bool> access;
+ std::vector<bool> coaccess;
+ uint64 props = 0;
+ SccVisitor<Arc> scc_visitor(nullptr, &access, &coaccess, &props);
+ DfsVisit(*fst, &scc_visitor);
+ std::vector<StateId> dstates;
+ for (StateId s = 0; s < access.size(); ++s) {
+ if (!access[s] || !coaccess[s]) dstates.push_back(s);
+ }
+ fst->DeleteStates(dstates);
+ fst->SetProperties(kAccessible | kCoAccessible, kAccessible | kCoAccessible);
+}
+
+// Returns an acyclic FST where each SCC in the input FST has been condensed to
+// a single state with transitions between SCCs retained and within SCCs
+// dropped. Also populates 'scc' with a mapping from input to output states.
+template <class Arc>
+void Condense(const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ std::vector<typename Arc::StateId> *scc) {
+ using StateId = typename Arc::StateId;
+ ofst->DeleteStates();
+ uint64 props = 0;
+ SccVisitor<Arc> scc_visitor(scc, nullptr, nullptr, &props);
+ DfsVisit(ifst, &scc_visitor);
+ for (StateId s = 0; s < scc->size(); ++s) {
+ const auto c = (*scc)[s];
+ while (c >= ofst->NumStates()) ofst->AddState();
+ if (s == ifst.Start()) ofst->SetStart(c);
+ const auto weight = ifst.Final(s);
+ if (weight != Arc::Weight::Zero())
+ ofst->SetFinal(c, Plus(ofst->Final(c), weight));
+ for (ArcIterator<Fst<Arc>> aiter(ifst, s); !aiter.Done(); aiter.Next()) {
+ auto arc = aiter.Value();
+ const auto nextc = (*scc)[arc.nextstate];
+ if (nextc != c) {
+ while (nextc >= ofst->NumStates()) ofst->AddState();
+ arc.nextstate = nextc;
+ ofst->AddArc(c, arc);
+ }
+ }
+ }
+ ofst->SetProperties(kAcyclic | kInitialAcyclic, kAcyclic | kInitialAcyclic);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_CONNECT_H_
--- /dev/null
+// 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_LIB_CONST_FST_H_
+#define FST_LIB_CONST_FST_H_
+
+#include <string>
+#include <vector>
+
+#include <fst/expanded-fst.h>
+#include <fst/fst-decl.h>
+#include <fst/mapped-file.h>
+#include <fst/test-properties.h>
+#include <fst/util.h>
+
+
+namespace fst {
+
+template <class A, class Unsigned>
+class ConstFst;
+
+template <class F, class G>
+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 A, class Unsigned>
+class ConstFstImpl : public FstImpl<A> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<A>::SetInputSymbols;
+ using FstImpl<A>::SetOutputSymbols;
+ using FstImpl<A>::SetType;
+ using FstImpl<A>::SetProperties;
+ using FstImpl<A>::Properties;
+
+ ConstFstImpl()
+ : states_(nullptr),
+ arcs_(nullptr),
+ nstates_(0),
+ narcs_(0),
+ start_(kNoStateId) {
+ string type = "const";
+ if (sizeof(Unsigned) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(Unsigned), &size);
+ type += size;
+ }
+ SetType(type);
+ SetProperties(kNullProperties | kStaticProperties);
+ }
+
+ explicit ConstFstImpl(const Fst<Arc> &fst);
+
+ StateId Start() const { return start_; }
+
+ Weight Final(StateId s) const { return states_[s].weight; }
+
+ StateId NumStates() const { return nstates_; }
+
+ size_t NumArcs(StateId s) const { return states_[s].narcs; }
+
+ size_t NumInputEpsilons(StateId s) const { return states_[s].niepsilons; }
+
+ size_t NumOutputEpsilons(StateId s) const { return states_[s].noepsilons; }
+
+ static ConstFstImpl<Arc, Unsigned> *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<Arc> *data) const {
+ data->base = nullptr;
+ data->nstates = nstates_;
+ }
+
+ // Provide information needed for the generic arc iterator.
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *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<Arc, Unsigned>;
+
+ // States implemented by array *states_ below, arcs by (single) *arcs_.
+ struct ConstState {
+ Weight weight; // Final weight.
+ Unsigned pos; // Start of state's arcs in *arcs_.
+ Unsigned narcs; // Number of arcs (per state).
+ Unsigned niepsilons; // Number of input epsilons.
+ Unsigned noepsilons; // Number of output epsilons.
+
+ ConstState() : weight(Weight::Zero()) {}
+ };
+
+ // Properties always true of this FST class.
+ static constexpr uint64 kStaticProperties = kExpanded;
+ // Current unaligned file format version. The unaligned version was added and
+ // made the default since the aligned version does not work on pipes.
+ static constexpr int kFileVersion = 2;
+ // Current aligned file format version.
+ static constexpr int kAlignedFileVersion = 1;
+ // Minimum file format version supported.
+ static constexpr int kMinFileVersion = 1;
+
+ std::unique_ptr<MappedFile> states_region_; // Mapped file for states.
+ std::unique_ptr<MappedFile> arcs_region_; // Mapped file for arcs.
+ ConstState *states_; // States representation.
+ Arc *arcs_; // Arcs representation.
+ StateId nstates_; // Number of states.
+ size_t narcs_; // Number of arcs.
+ StateId start_; // Initial state.
+
+ ConstFstImpl(const ConstFstImpl &) = delete;
+ ConstFstImpl &operator=(const ConstFstImpl &) = delete;
+};
+
+template <class Arc, class Unsigned>
+constexpr uint64 ConstFstImpl<Arc, Unsigned>::kStaticProperties;
+
+template <class Arc, class Unsigned>
+constexpr int ConstFstImpl<Arc, Unsigned>::kFileVersion;
+
+template <class Arc, class Unsigned>
+constexpr int ConstFstImpl<Arc, Unsigned>::kAlignedFileVersion;
+
+template <class Arc, class Unsigned>
+constexpr int ConstFstImpl<Arc, Unsigned>::kMinFileVersion;
+
+template <class Arc, class Unsigned>
+ConstFstImpl<Arc, Unsigned>::ConstFstImpl(const Fst<Arc> &fst)
+ : nstates_(0), narcs_(0) {
+ string type = "const";
+ if (sizeof(Unsigned) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(sizeof(Unsigned) * 8, &size);
+ type += size;
+ }
+ SetType(type);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ start_ = fst.Start();
+ // Counts states and arcs.
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ ++nstates_;
+ for (ArcIterator<Fst<Arc>> aiter(fst, siter.Value()); !aiter.Done();
+ aiter.Next()) {
+ ++narcs_;
+ }
+ }
+ states_region_.reset(MappedFile::Allocate(nstates_ * sizeof(*states_)));
+ arcs_region_.reset(MappedFile::Allocate(narcs_ * sizeof(*arcs_)));
+ states_ = reinterpret_cast<ConstState *>(states_region_->mutable_data());
+ arcs_ = reinterpret_cast<Arc *>(arcs_region_->mutable_data());
+ size_t pos = 0;
+ for (StateId s = 0; s < nstates_; ++s) {
+ states_[s].weight = fst.Final(s);
+ states_[s].pos = pos;
+ states_[s].narcs = 0;
+ states_[s].niepsilons = 0;
+ states_[s].noepsilons = 0;
+ for (ArcIterator<Fst<Arc>> 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 <class Arc, class Unsigned>
+ConstFstImpl<Arc, Unsigned> *ConstFstImpl<Arc, Unsigned>::Read(
+ std::istream &strm, const FstReadOptions &opts) {
+ using ConstState = typename ConstFstImpl<Arc, Unsigned>::ConstState;
+ std::unique_ptr<ConstFstImpl<Arc, Unsigned>> impl(
+ new ConstFstImpl<Arc, Unsigned>());
+ FstHeader hdr;
+ if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return nullptr;
+ impl->start_ = hdr.Start();
+ impl->nstates_ = hdr.NumStates();
+ impl->narcs_ = hdr.NumArcs();
+ // Ensures compatibility.
+ if (hdr.Version() == kAlignedFileVersion) {
+ hdr.SetFlags(hdr.GetFlags() | FstHeader::IS_ALIGNED);
+ }
+ if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) {
+ LOG(ERROR) << "ConstFst::Read: Alignment failed: " << opts.source;
+ return nullptr;
+ }
+ size_t b = impl->nstates_ * sizeof(ConstState);
+ impl->states_region_.reset(
+ MappedFile::Map(&strm, opts.mode == FstReadOptions::MAP, opts.source, b));
+ if (!strm || !impl->states_region_) {
+ LOG(ERROR) << "ConstFst::Read: Read failed: " << opts.source;
+ return nullptr;
+ }
+ impl->states_ =
+ reinterpret_cast<ConstState *>(impl->states_region_->mutable_data());
+ if ((hdr.GetFlags() & FstHeader::IS_ALIGNED) && !AlignInput(strm)) {
+ LOG(ERROR) << "ConstFst::Read: Alignment failed: " << opts.source;
+ return nullptr;
+ }
+ b = impl->narcs_ * sizeof(Arc);
+ impl->arcs_region_.reset(
+ MappedFile::Map(&strm, opts.mode == FstReadOptions::MAP, opts.source, b));
+ if (!strm || !impl->arcs_region_) {
+ LOG(ERROR) << "ConstFst::Read: Read failed: " << opts.source;
+ return nullptr;
+ }
+ impl->arcs_ = reinterpret_cast<Arc *>(impl->arcs_region_->mutable_data());
+ return impl.release();
+}
+
+} // namespace internal
+
+// Simple concrete immutable FST. This class attaches interface to
+// implementation and handles reference counting, delegating most methods to
+// ImplToExpandedFst. The unsigned type U is used to represent indices into the
+// arc array (default declared in fst-decl.h).
+template <class A, class Unsigned>
+class ConstFst : public ImplToExpandedFst<internal::ConstFstImpl<A, Unsigned>> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ using Impl = internal::ConstFstImpl<A, Unsigned>;
+ using ConstState = typename Impl::ConstState;
+
+ friend class StateIterator<ConstFst<Arc, Unsigned>>;
+ friend class ArcIterator<ConstFst<Arc, Unsigned>>;
+
+ template <class F, class G>
+ void friend Cast(const F &, G *);
+
+ ConstFst() : ImplToExpandedFst<Impl>(std::make_shared<Impl>()) {}
+
+ explicit ConstFst(const Fst<Arc> &fst)
+ : ImplToExpandedFst<Impl>(std::make_shared<Impl>(fst)) {}
+
+ ConstFst(const ConstFst<A, Unsigned> &fst, bool safe = false)
+ : ImplToExpandedFst<Impl>(fst) {}
+
+ // Gets a copy of this ConstFst. See Fst<>::Copy() for further doc.
+ ConstFst<A, Unsigned> *Copy(bool safe = false) const override {
+ return new ConstFst<A, Unsigned>(*this, safe);
+ }
+
+ // Reads a ConstFst from an input stream, returning nullptr on error.
+ static ConstFst<A, Unsigned> *Read(std::istream &strm,
+ const FstReadOptions &opts) {
+ auto *impl = Impl::Read(strm, opts);
+ return impl ? new ConstFst<A, Unsigned>(std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ // Read a ConstFst from a file; return nullptr on error; empty filename reads
+ // from standard input.
+ static ConstFst<A, Unsigned> *Read(const string &filename) {
+ auto *impl = ImplToExpandedFst<Impl>::Read(filename);
+ return impl ? new ConstFst<A, Unsigned>(std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return WriteFst(*this, strm, opts);
+ }
+
+ bool Write(const string &filename) const override {
+ return Fst<Arc>::WriteFile(filename);
+ }
+
+ template <class FST>
+ static bool WriteFst(const FST &fst, std::ostream &strm,
+ const FstWriteOptions &opts);
+
+ void InitStateIterator(StateIteratorData<Arc> *data) const override {
+ GetImpl()->InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetImpl()->InitArcIterator(s, data);
+ }
+
+ private:
+ explicit ConstFst(std::shared_ptr<Impl> impl)
+ : ImplToExpandedFst<Impl>(impl) {}
+
+ using ImplToFst<Impl, ExpandedFst<Arc>>::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 <typename FST>
+ 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 <class Arc, class Unsigned>
+template <class FST>
+bool ConstFst<Arc, Unsigned>::WriteFst(const FST &fst, std::ostream &strm,
+ const FstWriteOptions &opts) {
+ const auto file_version =
+ opts.align ? internal::ConstFstImpl<Arc, Unsigned>::kAlignedFileVersion
+ : internal::ConstFstImpl<Arc, Unsigned>::kFileVersion;
+ size_t num_arcs = 0; // To silence -Wsometimes-uninitialized warnings.
+ size_t num_states = 0; // Ditto.
+ size_t start_offset = 0;
+ bool update_header = true;
+ if (const auto *impl = GetImplIfConstFst(fst)) {
+ num_arcs = impl->narcs_;
+ num_states = impl->nstates_;
+ update_header = false;
+ } else if (opts.stream_write || (start_offset = strm.tellp()) == -1) {
+ // precompute values needed for header when we cannot seek to rewrite it.
+ num_arcs = 0;
+ num_states = 0;
+ for (StateIterator<FST> siter(fst); !siter.Done(); siter.Next()) {
+ num_arcs += fst.NumArcs(siter.Value());
+ ++num_states;
+ }
+ update_header = false;
+ }
+ FstHeader hdr;
+ hdr.SetStart(fst.Start());
+ hdr.SetNumStates(num_states);
+ hdr.SetNumArcs(num_arcs);
+ string type = "const";
+ if (sizeof(Unsigned) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(Unsigned), &size);
+ type += size;
+ }
+ const auto properties =
+ fst.Properties(kCopyProperties, true) |
+ internal::ConstFstImpl<Arc, Unsigned>::kStaticProperties;
+ internal::FstImpl<Arc>::WriteFstHeader(fst, strm, opts, file_version, type,
+ properties, &hdr);
+ if (opts.align && !AlignOutput(strm)) {
+ LOG(ERROR) << "Could not align file during write after header";
+ return false;
+ }
+ size_t pos = 0;
+ size_t states = 0;
+ typename ConstFst<Arc, Unsigned>::ConstState state;
+ for (StateIterator<FST> siter(fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ state.weight = fst.Final(s);
+ state.pos = pos;
+ state.narcs = fst.NumArcs(s);
+ state.niepsilons = fst.NumInputEpsilons(s);
+ state.noepsilons = fst.NumOutputEpsilons(s);
+ strm.write(reinterpret_cast<const char *>(&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<FST> siter(fst); !siter.Done(); siter.Next()) {
+ for (ArcIterator<FST> aiter(fst, siter.Value()); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ strm.write(reinterpret_cast<const char *>(&arc), sizeof(arc));
+ }
+ }
+ strm.flush();
+ if (!strm) {
+ LOG(ERROR) << "ConstFst::WriteFst: write failed: " << opts.source;
+ return false;
+ }
+ if (update_header) {
+ return internal::FstImpl<Arc>::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 Arc, class Unsigned>
+class StateIterator<ConstFst<Arc, Unsigned>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ explicit StateIterator(const ConstFst<Arc, Unsigned> &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 Arc, class Unsigned>
+class ArcIterator<ConstFst<Arc, Unsigned>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const ConstFst<Arc, Unsigned> &fst, StateId s)
+ : arcs_(fst.GetImpl()->Arcs(s)),
+ narcs_(fst.GetImpl()->NumArcs(s)),
+ i_(0) {}
+
+ bool Done() const { return i_ >= narcs_; }
+
+ const Arc &Value() const { return arcs_[i_]; }
+
+ void Next() { ++i_; }
+
+ size_t Position() const { return i_; }
+
+ void Reset() { i_ = 0; }
+
+ void Seek(size_t a) { i_ = a; }
+
+ constexpr uint32 Flags() const { return kArcValueFlags; }
+
+ void SetFlags(uint32, uint32) {}
+
+ private:
+ const Arc *arcs_;
+ size_t narcs_;
+ size_t i_;
+};
+
+// A useful alias when using StdArc.
+using StdConstFst = ConstFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_CONST_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes to determinize an FST.
+
+#ifndef FST_LIB_DETERMINIZE_H_
+#define FST_LIB_DETERMINIZE_H_
+
+#include <algorithm>
+#include <climits>
+#include <forward_list>
+#include <map>
+#include <string>
+#include <vector>
+
+#include <fst/arc-map.h>
+#include <fst/bi-table.h>
+#include <fst/cache.h>
+#include <fst/factor-weight.h>
+#include <fst/filter-state.h>
+#include <fst/prune.h>
+#include <fst/test-properties.h>
+
+
+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 <class W>
+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 <typename Label, StringType S>
+struct LabelCommonDivisor {
+ public:
+ using Weight = StringWeight<Label, S>;
+
+ Weight operator()(const Weight &w1, const Weight &w2) const {
+ StringWeightIterator<Label, S> iter1(w1);
+ StringWeightIterator<Label, S> iter2(w2);
+ if (!(StringWeight<Label, S>::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 Label, class W, GallicType G,
+ class CommonDivisor = DefaultCommonDivisor<W>>
+class GallicCommonDivisor {
+ public:
+ using Weight = GallicWeight<Label, W, G>;
+
+ 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, GALLIC_STRING_TYPE(G)> label_common_divisor_;
+ CommonDivisor weight_common_divisor_;
+};
+
+// Specialization for general GALLIC weight.
+template <class Label, class W, class CommonDivisor>
+class GallicCommonDivisor<Label, W, GALLIC, CommonDivisor> {
+ public:
+ using Weight = GallicWeight<Label, W, GALLIC>;
+ using GRWeight = GallicWeight<Label, W, GALLIC_RESTRICT>;
+ using Iterator =
+ UnionWeightIterator<GRWeight, GallicUnionWeightOptions<Label, W>>;
+
+ 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<Label, W, GALLIC_RESTRICT, CommonDivisor> common_divisor_;
+};
+
+namespace internal {
+
+// Represents an element in a subset
+template <class Arc>
+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<Arc> &element) const {
+ return state_id == element.state_id && weight == element.weight;
+ }
+
+ inline bool operator!=(const DeterminizeElement<Arc> &element) const {
+ return !(*this == element);
+ }
+
+ inline bool operator<(const DeterminizeElement<Arc> &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 <typename A, typename FilterState>
+struct DeterminizeStateTuple {
+ using Arc = A;
+ using Element = DeterminizeElement<Arc>;
+ using Subset = std::forward_list<Element>;
+
+ DeterminizeStateTuple() : filter_state(FilterState::NoState()) {}
+
+ inline bool operator==(
+ const DeterminizeStateTuple<Arc, FilterState> &tuple) const {
+ return (tuple.filter_state == filter_state) && (tuple.subset == subset);
+ }
+
+ inline bool operator!=(
+ const DeterminizeStateTuple<Arc, FilterState> &tuple) const {
+ return (tuple.filter_state != filter_state) || (tuple.subset != subset);
+ }
+
+ Subset subset;
+ FilterState filter_state;
+};
+
+// Proto-transition for determinization.
+template <class StateTuple>
+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 Arc>
+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<Arc>;
+ using StateTuple = internal::DeterminizeStateTuple<Arc, FilterState>;
+ using LabelMap = std::map<Label, internal::DeterminizeArc<StateTuple>>;
+
+ // This is needed e.g. to go into the gallic domain for transducers.
+ template <class A>
+ struct rebind {
+ using Other = DefaultDeterminizeFilter<A>;
+ };
+
+ explicit DefaultDeterminizeFilter(const Fst<Arc> &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 <class Filter>
+ DefaultDeterminizeFilter(const Fst<Arc> &fst, Filter *filter)
+ : fst_(fst.Copy()) {
+ delete filter;
+ }
+
+ // Copy constructor; the FST can be passed if it has been deep-copied.
+ DefaultDeterminizeFilter(const DefaultDeterminizeFilter<Arc> &filter,
+ const Fst<Arc> *fst = nullptr)
+ : fst_(fst ? fst->Copy() : filter.fst_->Copy()) {}
+
+ FilterState Start() const { return FilterState(0); }
+
+ // Does no work.
+ void SetState(StateId s, const StateTuple &tuple) {}
+
+ // Filters transition, possibly modifying label map. Returns true if arc is
+ // added to the label map.
+ bool FilterArc(const Arc &arc, const Element &src_element,
+ const Element &dest_element, LabelMap *label_map) const {
+ // Adds element to unique state tuple for arc label.
+ auto &det_arc = (*label_map)[arc.ilabel];
+ if (det_arc.label == kNoLabel) {
+ det_arc = internal::DeterminizeArc<StateTuple>(arc);
+ det_arc.dest_tuple->filter_state = FilterState(0);
+ }
+ det_arc.dest_tuple->subset.push_front(dest_element);
+ return true;
+ }
+
+ // Filters super-final transition, returning new final weight.
+ Weight FilterFinal(Weight weight, const Element &element) { return weight; }
+
+ static uint64 Properties(uint64 props) { return props; }
+
+ private:
+ std::unique_ptr<Fst<Arc>> fst_;
+};
+
+// Determinization state table interface:
+//
+// template <class Arc, class FilterState>
+// class DeterminizeStateTable {
+// public:
+// using StateId = typename Arc::StateId;
+// using StateTuple = internal::DeterminizeStateTuple<Arc, FilterState>;
+//
+// // Required sub-class. This is needed (e.g.) to go into the gallic domain.
+// template <class B, class G>
+// struct rebind {
+// using Other = DeterminizeStateTable<B, G>;
+// }
+//
+// // Required constuctor.
+// DeterminizeStateTable();
+//
+// // Required copy constructor that does not copy state.
+// DeterminizeStateTable(const DeterminizeStateTable<Arc, FilterState>
+// &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 Arc, class FilterState>
+class DefaultDeterminizeStateTable {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using StateTuple = internal::DeterminizeStateTuple<Arc, FilterState>;
+ using Element = typename StateTuple::Element;
+ using Subset = typename StateTuple::Subset;
+
+ template <class B, class G>
+ struct rebind {
+ using Other = DefaultDeterminizeStateTable<B, G>;
+ };
+
+ explicit DefaultDeterminizeStateTable(size_t table_size = 0)
+ : table_size_(table_size), tuples_(table_size_) {}
+
+ DefaultDeterminizeStateTable(
+ const DefaultDeterminizeStateTable<Arc, FilterState> &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<StateId, StateTuple *, StateTupleKey, StateTupleEqual,
+ HS_STL>
+ 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 Arc,
+ class CommonDivisor = DefaultCommonDivisor<typename Arc::Weight>,
+ class Filter = DefaultDeterminizeFilter<Arc>,
+ class StateTable =
+ DefaultDeterminizeStateTable<Arc, typename Filter::FilterState>>
+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 Arc>
+class DeterminizeFstImplBase : public CacheImpl<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::Properties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheBaseImpl<CacheState<Arc>>::HasStart;
+ using CacheBaseImpl<CacheState<Arc>>::HasFinal;
+ using CacheBaseImpl<CacheState<Arc>>::HasArcs;
+ using CacheBaseImpl<CacheState<Arc>>::SetFinal;
+ using CacheBaseImpl<CacheState<Arc>>::SetStart;
+
+ template <class CommonDivisor, class Filter, class StateTable>
+ DeterminizeFstImplBase(
+ const Fst<Arc> &fst,
+ const DeterminizeFstOptions<Arc, CommonDivisor, Filter, StateTable> &opts)
+ : CacheImpl<Arc>(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<Arc> &impl)
+ : CacheImpl<Arc>(impl), fst_(impl.fst_->Copy(true)) {
+ SetType("determinize");
+ SetProperties(impl.Properties(), kCopyProperties);
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ virtual DeterminizeFstImplBase<Arc> *Copy() const = 0;
+
+ StateId Start() {
+ if (!HasStart()) {
+ const auto start = ComputeStart();
+ if (start != kNoStateId) SetStart(start);
+ }
+ return CacheImpl<Arc>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) SetFinal(s, ComputeFinal(s));
+ return CacheImpl<Arc>::Final(s);
+ }
+
+ virtual void Expand(StateId s) = 0;
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumOutputEpsilons(s);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<Arc>::InitArcIterator(s, data);
+ }
+
+ virtual StateId ComputeStart() = 0;
+
+ virtual Weight ComputeFinal(StateId s) = 0;
+
+ const Fst<Arc> &GetFst() const { return *fst_; }
+
+ private:
+ std::unique_ptr<const Fst<Arc>> fst_; // Input FST.
+};
+
+// Implementation of delayed determinization for weighted acceptors.
+template <class Arc, class CommonDivisor, class Filter, class StateTable>
+class DeterminizeFsaImpl : public DeterminizeFstImplBase<Arc> {
+ 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<Arc, FilterState>;
+ using Element = typename StateTuple::Element;
+ using Subset = typename StateTuple::Subset;
+ using LabelMap = typename Filter::LabelMap;
+
+ using FstImpl<Arc>::SetProperties;
+ using DeterminizeFstImplBase<Arc>::GetFst;
+ using DeterminizeFstImplBase<Arc>::SetArcs;
+
+ DeterminizeFsaImpl(
+ const Fst<Arc> &fst, const std::vector<Weight> *in_dist,
+ std::vector<Weight> *out_dist,
+ const DeterminizeFstOptions<Arc, CommonDivisor, Filter, StateTable> &opts)
+ : DeterminizeFstImplBase<Arc>(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<Arc, CommonDivisor, Filter, StateTable> &impl)
+ : DeterminizeFstImplBase<Arc>(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<Arc, CommonDivisor, Filter, StateTable> *Copy()
+ const override {
+ return new DeterminizeFsaImpl<Arc, CommonDivisor, Filter, StateTable>(
+ *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<Arc>::Properties(mask);
+ }
+
+ StateId ComputeStart() override {
+ const auto s = GetFst().Start();
+ if (s == kNoStateId) return kNoStateId;
+ const Element element(s, Weight::One());
+ auto *tuple = new StateTuple;
+ tuple->subset.push_front(element);
+ tuple->filter_state = filter_->Start();
+ return FindState(tuple);
+ }
+
+ Weight ComputeFinal(StateId s) override {
+ const auto *tuple = state_table_->Tuple(s);
+ filter_->SetState(s, *tuple);
+ auto final_weight = Weight::Zero();
+ for (auto it = tuple->subset.begin(); it != tuple->subset.end(); ++it) {
+ const auto &element = *it;
+ final_weight =
+ Plus(final_weight,
+ Times(element.weight, GetFst().Final(element.state_id)));
+ final_weight = filter_->FilterFinal(final_weight, element);
+ if (!final_weight.Member()) SetProperties(kError, kError);
+ }
+ return final_weight;
+ }
+
+ StateId FindState(StateTuple *tuple) {
+ const auto s = state_table_->FindState(tuple);
+ if (in_dist_ && out_dist_->size() <= s) {
+ out_dist_->push_back(ComputeDistance(tuple->subset));
+ }
+ return s;
+ }
+
+ // Computes distance from a state to the final states in the DFA given the
+ // distances in the NFA.
+ Weight ComputeDistance(const Subset &subset) {
+ auto outd = Weight::Zero();
+ for (auto it = subset.begin(); it != subset.end(); ++it) {
+ const auto &element = *it;
+ const auto ind =
+ (element.state_id < in_dist_->size() ? (*in_dist_)[element.state_id]
+ : Weight::Zero());
+ outd = Plus(outd, Times(element.weight, ind));
+ }
+ return outd;
+ }
+
+ // Computes the outgoing transitions from a state, creating new destination
+ // states as needed.
+ void Expand(StateId s) override {
+ LabelMap label_map;
+ GetLabelMap(s, &label_map);
+ for (auto it = label_map.begin(); it != label_map.end(); ++it) {
+ AddArc(s, it->second);
+ }
+ SetArcs(s);
+ }
+
+ private:
+ using DetArc = internal::DeterminizeArc<StateTuple>;
+
+ // 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<Fst<Arc>> aiter(GetFst(), src_element.state_id);
+ !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const Element dest_element(arc.nextstate,
+ Times(src_element.weight, arc.weight));
+ filter_->FilterArc(arc, src_element, dest_element, label_map);
+ }
+ }
+ for (auto it = label_map->begin(); it != label_map->end(); ++it) {
+ NormArc(&it->second);
+ }
+ }
+
+ // Sorts subsets and removes duplicate elements, normalizing transition and
+ // subset weights.
+ void NormArc(DetArc *det_arc) {
+ auto *dest_tuple = det_arc->dest_tuple;
+ dest_tuple->subset.sort();
+ auto piter = dest_tuple->subset.begin();
+ for (auto diter = dest_tuple->subset.begin();
+ diter != dest_tuple->subset.end();) {
+ auto &dest_element = *diter;
+ auto &prev_element = *piter;
+ // Computes arc weight.
+ det_arc->weight = common_divisor_(det_arc->weight, dest_element.weight);
+ if (piter != diter && dest_element.state_id == prev_element.state_id) {
+ // Found duplicate state: sums state weight and deletes duplicate.
+ prev_element.weight = Plus(prev_element.weight, dest_element.weight);
+ if (!prev_element.weight.Member()) SetProperties(kError, kError);
+ ++diter;
+ dest_tuple->subset.erase_after(piter);
+ } else {
+ piter = diter;
+ ++diter;
+ }
+ }
+ // Divides out label weight from destination subset elements, quantizing to
+ // ensure comparisons are effective.
+ for (auto diter = dest_tuple->subset.begin();
+ diter != dest_tuple->subset.end(); ++diter) {
+ auto &dest_element = *diter;
+ dest_element.weight =
+ Divide(dest_element.weight, det_arc->weight, DIVIDE_LEFT);
+ dest_element.weight = dest_element.weight.Quantize(delta_);
+ }
+ }
+
+ // Adds an arc from state S to the destination state associated with state
+ // tuple in det_arc as created by GetLabelMap.
+ void AddArc(StateId s, const DetArc &det_arc) {
+ const Arc arc(det_arc.label, det_arc.label, det_arc.weight,
+ FindState(det_arc.dest_tuple));
+ CacheImpl<Arc>::PushArc(s, arc);
+ }
+
+ float delta_; // Quantization delta for weights.
+ const std::vector<Weight> *in_dist_; // Distance to final NFA states.
+ std::vector<Weight> *out_dist_; // Distance to final DFA states.
+
+ // FIXME(kbg): Ought to be static const?
+ CommonDivisor common_divisor_;
+ std::unique_ptr<Filter> filter_;
+ std::unique_ptr<StateTable> state_table_;
+};
+
+// Implementation of delayed determinization for transducers. Transducer
+// determinization is implemented by mapping the input to the Gallic semiring as
+// an acceptor whose weights contain the output strings and using acceptor
+// determinization above to determinize that acceptor.
+template <class Arc, GallicType G, class CommonDivisor, class Filter,
+ class StateTable>
+class DeterminizeFstImpl : public DeterminizeFstImplBase<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using ToMapper = ToGallicMapper<Arc, G>;
+ using ToArc = typename ToMapper::ToArc;
+ using ToFst = ArcMapFst<Arc, ToArc, ToMapper>;
+ using FromMapper = FromGallicMapper<Arc, G>;
+ using FromFst = ArcMapFst<ToArc, Arc, FromMapper>;
+
+ using ToCommonDivisor = GallicCommonDivisor<Label, Weight, G, CommonDivisor>;
+ using ToFilter = typename Filter::template rebind<ToArc>::Other;
+ using ToFilterState = typename ToFilter::FilterState;
+ using ToStateTable =
+ typename StateTable::template rebind<ToArc, ToFilterState>::Other;
+ using FactorIterator = GallicFactor<Label, Weight, G>;
+
+ using FstImpl<Arc>::SetProperties;
+ using DeterminizeFstImplBase<Arc>::GetFst;
+ using CacheBaseImpl<CacheState<Arc>>::GetCacheGc;
+ using CacheBaseImpl<CacheState<Arc>>::GetCacheLimit;
+
+ DeterminizeFstImpl(
+ const Fst<Arc> &fst,
+ const DeterminizeFstOptions<Arc, CommonDivisor, Filter, StateTable> &opts)
+ : DeterminizeFstImplBase<Arc>(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<Arc, G, CommonDivisor, Filter, StateTable> &impl)
+ : DeterminizeFstImplBase<Arc>(impl),
+ delta_(impl.delta_),
+ subsequential_label_(impl.subsequential_label_),
+ increment_subsequential_label_(impl.increment_subsequential_label_) {
+ Init(GetFst(), nullptr);
+ }
+
+ DeterminizeFstImpl<Arc, G, CommonDivisor, Filter, StateTable> *Copy()
+ const override {
+ return new DeterminizeFstImpl<Arc, G, CommonDivisor, Filter, StateTable>(
+ *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<Arc>::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<FromFst> aiter(*from_fst_, s); !aiter.Done();
+ aiter.Next()) {
+ CacheImpl<Arc>::PushArc(s, aiter.Value());
+ }
+ CacheImpl<Arc>::SetArcs(s);
+ }
+
+ private:
+ // Initialization of transducer determinization implementation, which is
+ // defined after DeterminizeFst since it calls it.
+ void Init(const Fst<Arc> &fst, Filter *filter);
+
+ float delta_;
+ Label subsequential_label_;
+ bool increment_subsequential_label_;
+ std::unique_ptr<FromFst> 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 A>
+class DeterminizeFst : public ImplToFst<internal::DeterminizeFstImplBase<A>> {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::DeterminizeFstImplBase<Arc>;
+
+ friend class ArcIterator<DeterminizeFst<Arc>>;
+ friend class StateIterator<DeterminizeFst<Arc>>;
+
+ template <class B, GallicType G, class CommonDivisor, class Filter,
+ class StateTable>
+ friend class DeterminizeFstImpl;
+
+ explicit DeterminizeFst(const Fst<A> &fst)
+ : ImplToFst<Impl>(CreateImpl(fst)) {}
+
+ template <class CommonDivisor, class Filter, class StateTable>
+ DeterminizeFst(
+ const Fst<Arc> &fst,
+ const DeterminizeFstOptions<Arc, CommonDivisor, Filter, StateTable> &opts)
+ : ImplToFst<Impl>(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. Useful for e.g., computing the k-shortest unique paths.
+ template <class D, class F, class T>
+ DeterminizeFst(const Fst<A> &fst, const std::vector<Weight> *in_dist,
+ std::vector<Weight> *out_dist,
+ const DeterminizeFstOptions<A, D, F, T> &opts)
+ : ImplToFst<Impl>(
+ std::make_shared<internal::DeterminizeFsaImpl<A, D, F, T>>(
+ 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<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(safe ? std::shared_ptr<Impl>(fst.GetImpl()->Copy())
+ : fst.GetSharedImpl()) {}
+
+ // Get a copy of this DeterminizeFst. See Fst<>::Copy() for further doc.
+ DeterminizeFst<Arc> *Copy(bool safe = false) const override {
+ return new DeterminizeFst<Arc>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ static std::shared_ptr<Impl> CreateImpl(const Fst<Arc> &fst) {
+ using D = DefaultCommonDivisor<Weight>;
+ using F = DefaultDeterminizeFilter<Arc>;
+ using T = DefaultDeterminizeStateTable<Arc, typename F::FilterState>;
+ const DeterminizeFstOptions<Arc, D, F, T> opts;
+ return CreateImpl(fst, opts);
+ }
+
+ template <class CommonDivisor, class Filter, class StateTable>
+ static std::shared_ptr<Impl> CreateImpl(
+ const Fst<Arc> &fst,
+ const DeterminizeFstOptions<Arc, CommonDivisor, Filter, StateTable>
+ &opts) {
+ if (fst.Properties(kAcceptor, true)) {
+ // Calls implementation for acceptors.
+ return std::make_shared<
+ internal::DeterminizeFsaImpl<Arc, CommonDivisor, Filter, StateTable>>(
+ fst, nullptr, nullptr, opts);
+ } else if (opts.type == DETERMINIZE_DISAMBIGUATE) {
+ auto rv = std::make_shared<internal::DeterminizeFstImpl<
+ Arc, GALLIC_MIN, CommonDivisor, Filter, StateTable>>(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<internal::DeterminizeFstImpl<
+ Arc, GALLIC_RESTRICT, CommonDivisor, Filter, StateTable>>(fst, opts);
+ } else { // opts.type == DETERMINIZE_NONFUNCTIONAL
+ // Calls implementation for non functional transducers;
+ return std::make_shared<internal::DeterminizeFstImpl<
+ Arc, GALLIC, CommonDivisor, Filter, StateTable>>(fst, opts);
+ }
+ }
+
+ DeterminizeFst &operator=(const DeterminizeFst &) = delete;
+};
+
+namespace internal {
+
+// Initialization of transducer determinization implementation, which is defined
+// after DeterminizeFst since it calls it.
+template <class A, GallicType G, class D, class F, class T>
+void DeterminizeFstImpl<A, G, D, F, T>::Init(const Fst<A> &fst, F *filter) {
+ // Mapper to an acceptor.
+ 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.
+ CacheOptions copts(GetCacheGc(), GetCacheLimit());
+ DeterminizeFstOptions<ToArc, ToCommonDivisor, ToFilter, ToStateTable> dopts(
+ copts, delta_, 0, DETERMINIZE_FUNCTIONAL, false, to_filter);
+ // Uses acceptor-only constructor to avoid template recursion.
+ DeterminizeFst<ToArc> det_fsa(to_fst, nullptr, nullptr, dopts);
+ // Mapper back to transducer.
+ FactorWeightOptions<ToArc> fopts(
+ CacheOptions(true, 0), delta_, kFactorFinalWeights, subsequential_label_,
+ subsequential_label_, increment_subsequential_label_,
+ increment_subsequential_label_);
+ FactorWeightFst<ToArc, FactorIterator> factored_fst(det_fsa, fopts);
+ from_fst_.reset(new FromFst(factored_fst, FromMapper(subsequential_label_)));
+}
+
+} // namespace internal
+
+// Specialization for DeterminizeFst.
+template <class Arc>
+class StateIterator<DeterminizeFst<Arc>>
+ : public CacheStateIterator<DeterminizeFst<Arc>> {
+ public:
+ explicit StateIterator(const DeterminizeFst<Arc> &fst)
+ : CacheStateIterator<DeterminizeFst<Arc>>(fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for DeterminizeFst.
+template <class Arc>
+class ArcIterator<DeterminizeFst<Arc>>
+ : public CacheArcIterator<DeterminizeFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const DeterminizeFst<Arc> &fst, StateId s)
+ : CacheArcIterator<DeterminizeFst<Arc>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class Arc>
+inline void DeterminizeFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<DeterminizeFst<Arc>>(*this);
+}
+
+// Useful aliases when using StdArc.
+using StdDeterminizeFst = DeterminizeFst<StdArc>;
+
+template <class Arc>
+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 <class Arc>
+void Determinize(
+ const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ const DeterminizeOptions<Arc> &opts = DeterminizeOptions<Arc>()) {
+ using Weight = typename Arc::Weight;
+ DeterminizeFstOptions<Arc> 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<Weight> idistance;
+ std::vector<Weight> odistance;
+ ShortestDistance(ifst, &idistance, true);
+ DeterminizeFst<Arc> dfst(ifst, &idistance, &odistance, nopts);
+ PruneOptions<Arc, AnyArcFilter<Arc>> popts(
+ opts.weight_threshold, opts.state_threshold, AnyArcFilter<Arc>(),
+ &odistance);
+ Prune(dfst, ofst, popts);
+ } else {
+ *ofst = DeterminizeFst<Arc>(ifst, nopts);
+ Prune(ofst, opts.weight_threshold, opts.state_threshold);
+ }
+ } else {
+ *ofst = DeterminizeFst<Arc>(ifst, nopts);
+ }
+}
+
+} // namespace fst
+
+#endif // FST_LIB_DETERMINIZE_H_
--- /dev/null
+// 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_LIB_DFS_VISIT_H_
+#define FST_LIB_DFS_VISIT_H_
+
+#include <stack>
+#include <vector>
+
+#include <fst/arcfilter.h>
+#include <fst/fst.h>
+
+
+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 Arc>
+// class Visitor {
+// public:
+// using StateId = typename Arc::StateId;
+//
+// Visitor(T *return_data);
+//
+// // Invoked before DFS visit.
+// void InitVisit(const Fst<Arc> &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 <class FST>
+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<DfsState<FST>> *pool) {
+ return pool->Allocate();
+ }
+
+ static void Destroy(DfsState<FST> *dfs_state,
+ MemoryPool<DfsState<FST>> *pool) {
+ if (dfs_state) {
+ dfs_state->~DfsState<FST>();
+ pool->Free(dfs_state);
+ }
+ }
+
+ StateId state_id; // FST state.
+ ArcIterator<FST> 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 <class FST, class Visitor, class ArcFilter>
+void DfsVisit(const FST &fst, Visitor *visitor, ArcFilter filter,
+ bool access_only = false) {
+ using Arc = typename FST::Arc;
+ using StateId = typename Arc::StateId;
+ visitor->InitVisit(fst);
+ const auto start = fst.Start();
+ if (start == kNoStateId) {
+ visitor->FinishVisit();
+ return;
+ }
+ // An FST state's DFS status
+ static constexpr uint8 kDfsWhite = 0; // Undiscovered.
+ static constexpr uint8 kDfsGrey = 1; // Discovered but unfinished.
+ static constexpr uint8 kDfsBlack = 2; // Finished.
+ std::vector<uint8> state_color;
+ std::stack<internal::DfsState<FST> *> state_stack; // DFS execution stack.
+ MemoryPool<internal::DfsState<FST>> 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<FST> 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>(fst, root));
+ dfs = visitor->InitState(root, root);
+ while (!state_stack.empty()) {
+ auto *dfs_state = state_stack.top();
+ const auto s = dfs_state->state_id;
+ if (s >= state_color.size()) {
+ nstates = s + 1;
+ state_color.resize(nstates, kDfsWhite);
+ }
+ ArcIterator<FST> &aiter = dfs_state->arc_iter;
+ if (!dfs || aiter.Done()) {
+ state_color[s] = kDfsBlack;
+ internal::DfsState<FST>::Destroy(dfs_state, &state_pool);
+ state_stack.pop();
+ if (!state_stack.empty()) {
+ auto *parent_state = state_stack.top();
+ auto &piter = parent_state->arc_iter;
+ visitor->FinishState(s, parent_state->state_id, &piter.Value());
+ piter.Next();
+ } else {
+ visitor->FinishState(s, kNoStateId, nullptr);
+ }
+ continue;
+ }
+ const auto &arc = aiter.Value();
+ if (arc.nextstate >= state_color.size()) {
+ nstates = arc.nextstate + 1;
+ state_color.resize(nstates, kDfsWhite);
+ }
+ if (!filter(arc)) {
+ aiter.Next();
+ continue;
+ }
+ const auto next_color = state_color[arc.nextstate];
+ switch (next_color) {
+ default:
+ case kDfsWhite:
+ dfs = visitor->TreeArc(s, arc);
+ if (!dfs) break;
+ state_color[arc.nextstate] = kDfsGrey;
+ state_stack.push(new (&state_pool)
+ internal::DfsState<FST>(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 <class Arc, class Visitor>
+void DfsVisit(const Fst<Arc> &fst, Visitor *visitor) {
+ DfsVisit(fst, visitor, AnyArcFilter<Arc>());
+}
+
+} // namespace fst
+
+#endif // FST_LIB_DFS_VISIT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Class to compute the difference between two FSAs.
+
+#ifndef FST_LIB_DIFFERENCE_H_
+#define FST_LIB_DIFFERENCE_H_
+
+#include <memory>
+
+
+#include <fst/cache.h>
+#include <fst/complement.h>
+#include <fst/compose.h>
+
+
+namespace fst {
+
+template <class Arc, class M = Matcher<Fst<Arc>>,
+ class Filter = SequenceComposeFilter<M>,
+ class StateTable =
+ GenericComposeStateTable<Arc, typename Filter::FilterState>>
+struct DifferenceFstOptions
+ : public ComposeFstOptions<Arc, M, Filter, StateTable> {
+ explicit DifferenceFstOptions(const CacheOptions &opts = CacheOptions(),
+ M *matcher1 = nullptr, M *matcher2 = nullptr,
+ Filter *filter = nullptr,
+ StateTable *state_table = nullptr)
+ : ComposeFstOptions<Arc, M, Filter, StateTable>(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 A>
+class DifferenceFst : public ComposeFst<A> {
+ public:
+ using Arc = A;
+ using Weight = typename Arc::Weight;
+ using StateId = typename Arc::StateId;
+
+ using ComposeFst<Arc>::CreateBase1;
+
+ // A - B = A ^ B'.
+ DifferenceFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const CacheOptions &opts = CacheOptions())
+ : ComposeFst<Arc>(CreateDifferenceImplWithCacheOpts(fst1, fst2, opts)) {
+ if (!fst1.Properties(kAcceptor, true)) {
+ FSTERROR() << "DifferenceFst: 1st argument not an acceptor";
+ GetImpl()->SetProperties(kError, kError);
+ }
+ }
+
+ template <class Matcher, class Filter, class StateTable>
+ DifferenceFst(
+ const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const DifferenceFstOptions<Arc, Matcher, Filter, StateTable> &opts)
+ : ComposeFst<Arc>(
+ 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<Arc> &fst, bool safe = false)
+ : ComposeFst<Arc>(fst, safe) {}
+
+ // Get a copy of this DifferenceFst. See Fst<>::Copy() for further doc.
+ DifferenceFst<Arc> *Copy(bool safe = false) const override {
+ return new DifferenceFst<Arc>(*this, safe);
+ }
+
+ private:
+ using Impl = internal::ComposeFstImplBase<Arc>;
+ using ImplToFst<Impl>::GetImpl;
+
+ static std::shared_ptr<Impl> CreateDifferenceImplWithCacheOpts(
+ const Fst<Arc> &fst1, const Fst<Arc> &fst2, const CacheOptions &opts) {
+ using RM = RhoMatcher<Matcher<Fst<A>>>;
+ ComplementFst<Arc> cfst(fst2);
+ ComposeFstOptions<A, RM> copts(
+ CacheOptions(), new RM(fst1, MATCH_NONE),
+ new RM(cfst, MATCH_INPUT, ComplementFst<Arc>::kRhoLabel));
+ return CreateBase1(fst1, cfst, copts);
+ }
+
+ template <class Matcher, class Filter, class StateTable>
+ static std::shared_ptr<Impl> CreateDifferenceImplWithDifferenceOpts(
+ const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const DifferenceFstOptions<Arc, Matcher, Filter, StateTable> &opts) {
+ using RM = RhoMatcher<Matcher>;
+ ComplementFst<Arc> cfst(fst2);
+ ComposeFstOptions<Arc, RM> copts(opts);
+ copts.matcher1 = new RM(fst1, MATCH_NONE, kNoLabel, MATCHER_REWRITE_ALWAYS,
+ opts.matcher1);
+ copts.matcher2 = new RM(cfst, MATCH_INPUT, ComplementFst<Arc>::kRhoLabel,
+ MATCHER_REWRITE_ALWAYS, opts.matcher2);
+ return CreateBase1(fst1, cfst, copts);
+ }
+};
+
+// Specialization for DifferenceFst.
+template <class Arc>
+class StateIterator<DifferenceFst<Arc>>
+ : public StateIterator<ComposeFst<Arc>> {
+ public:
+ explicit StateIterator(const DifferenceFst<Arc> &fst)
+ : StateIterator<ComposeFst<Arc>>(fst) {}
+};
+
+// Specialization for DifferenceFst.
+template <class Arc>
+class ArcIterator<DifferenceFst<Arc>> : public ArcIterator<ComposeFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const DifferenceFst<Arc> &fst, StateId s)
+ : ArcIterator<ComposeFst<Arc>>(fst, s) {}
+};
+
+using DifferenceOptions = ComposeOptions;
+
+// Useful alias when using StdArc.
+using StdDifferenceFst = DifferenceFst<StdArc>;
+
+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 <class Arc>
+void Difference(const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ MutableFst<Arc> *ofst,
+ const DifferenceOptions &opts = DifferenceOptions()) {
+ using M = Matcher<Fst<Arc>>;
+ if (opts.filter_type == AUTO_FILTER) {
+ CacheOptions nopts;
+ nopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = DifferenceFst<Arc>(ifst1, ifst2, nopts);
+ } else if (opts.filter_type == SEQUENCE_FILTER) {
+ DifferenceFstOptions<Arc> dopts;
+ dopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = DifferenceFst<Arc>(ifst1, ifst2, dopts);
+ } else if (opts.filter_type == ALT_SEQUENCE_FILTER) {
+ DifferenceFstOptions<Arc, M, AltSequenceComposeFilter<M>> dopts;
+ dopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = DifferenceFst<Arc>(ifst1, ifst2, dopts);
+ } else if (opts.filter_type == MATCH_FILTER) {
+ DifferenceFstOptions<Arc, M, MatchComposeFilter<M>> dopts;
+ dopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = DifferenceFst<Arc>(ifst1, ifst2, dopts);
+ }
+ if (opts.connect) Connect(ofst);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_DIFFERENCE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes to disambiguate an FST.
+
+#ifndef FST_LIB_DISAMBIGUATE_H_
+#define FST_LIB_DISAMBIGUATE_H_
+
+#include <list>
+#include <map>
+#include <set>
+#include <utility>
+#include <vector>
+
+#include <fst/arcsort.h>
+#include <fst/compose.h>
+#include <fst/connect.h>
+#include <fst/determinize.h>
+#include <fst/dfs-visit.h>
+#include <fst/project.h>
+#include <fst/prune.h>
+#include <fst/state-map.h>
+#include <fst/state-table.h>
+#include <fst/union-find.h>
+#include <fst/verify.h>
+
+
+namespace fst {
+
+template <class Arc>
+struct DisambiguateOptions : public DeterminizeOptions<Arc> {
+ 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<Arc>(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 Arc, class Relation>
+class RelationDeterminizeFilter {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FilterState = IntegerFilterState<StateId>;
+ using StateTuple = DeterminizeStateTuple<Arc, FilterState>;
+ using Subset = typename StateTuple::Subset;
+ using Element = typename StateTuple::Element;
+ using LabelMap = std::multimap<Label, DeterminizeArc<StateTuple>>;
+
+ // 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 <class A>
+ struct rebind {
+ using Other = RelationDeterminizeFilter<A, Relation>;
+ };
+
+ explicit RelationDeterminizeFilter(const Fst<Arc> &fst)
+ : fst_(fst.Copy()), r_(new Relation()), s_(kNoStateId), head_(nullptr) {}
+
+ // Ownership of the relation is given to this class.
+ RelationDeterminizeFilter(const Fst<Arc> &fst, Relation *r)
+ : fst_(fst.Copy()), r_(r), s_(kNoStateId), head_(0) {}
+
+ // Ownership of the relation is given to this class.
+ RelationDeterminizeFilter(const Fst<Arc> &fst, Relation *r,
+ std::vector<StateId> *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 <class Filter>
+ RelationDeterminizeFilter(const Fst<Arc> &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<Arc> *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<StateId> *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<Arc>> fst_; // Input FST.
+ std::unique_ptr<Relation> 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<StateId> *head_; // Head state for a given state,
+ // owned by the Disambiguator.
+};
+
+template <class Arc, class Relation>
+bool RelationDeterminizeFilter<Arc, Relation>::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 <class Arc, class Relation>
+void RelationDeterminizeFilter<Arc, Relation>::InitLabelMap(
+ LabelMap *label_map) const {
+ const auto src_head = tuple_->filter_state.GetState();
+ Label label = kNoLabel;
+ StateId nextstate = kNoStateId;
+ for (ArcIterator<Fst<Arc>> 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<StateTuple> det_arc(arc);
+ det_arc.dest_tuple->filter_state = FilterState(arc.nextstate);
+ label_map->insert(std::make_pair(arc.ilabel, det_arc));
+ label = arc.ilabel;
+ nextstate = arc.nextstate;
+ }
+}
+
+// Helper class to disambiguate an FST via Disambiguate().
+template <class Arc>
+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<StateId, ssize_t>;
+
+ Disambiguator() : error_(false) {}
+
+ void Disambiguate(
+ const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ const DisambiguateOptions<Arc> &opts = DisambiguateOptions<Arc>()) {
+ VectorFst<Arc> 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<StateId> &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<StateId> &head_;
+ };
+
+ // A relation that determines if two states share a common future.
+ class CommonFuture {
+ public:
+ using StateTable = GenericComposeStateTable<Arc, TrivialFilterState>;
+ using StateTuple = typename StateTable::StateTuple;
+
+ // Needed for compilation with DeterminizeRelationFilter.
+ CommonFuture() {
+ FSTERROR() << "Disambiguate::CommonFuture: FST not provided";
+ }
+
+ explicit CommonFuture(const Fst<Arc> &ifst) {
+ using M = Matcher<Fst<Arc>>;
+ ComposeFstOptions<Arc, M, NullComposeFilter<M>> opts;
+ // Ensures composition is between acceptors.
+ const bool trans = ifst.Properties(kNotAcceptor, true);
+ const auto *fsa =
+ trans ? new ProjectFst<Arc>(ifst, PROJECT_INPUT) : &ifst;
+ opts.state_table = new StateTable(*fsa, *fsa);
+ const ComposeFst<Arc> cfst(*fsa, *fsa, opts);
+ std::vector<bool> coaccess;
+ uint64 props = 0;
+ SccVisitor<Arc> 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<std::pair<StateId, StateId>> related_;
+ };
+
+ using ArcIdMap = std::multimap<ArcId, ArcId, ArcIdCompare>;
+
+ // 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<Arc> &fst, ArcId aid) {
+ if (aid.second == -1) { // Returns super-final transition.
+ return Arc(kNoLabel, kNoLabel, fst.Final(aid.first), kNoStateId);
+ } else {
+ ArcIterator<Fst<Arc>> 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<Arc> &ifst, MutableFst<Arc> *ofst,
+ const DisambiguateOptions<Arc> &opts);
+
+ // Finds transitions that are ambiguous candidates in the result of
+ // PreDisambiguate.
+ void FindAmbiguities(const ExpandedFst<Arc> &fst);
+
+ // Finds transition pairs that are ambiguous candidates from two specified
+ // source states.
+ void FindAmbiguousPairs(const ExpandedFst<Arc> &fst, StateId s1, StateId s2);
+
+ // Marks ambiguous transitions to be removed.
+ void MarkAmbiguities();
+
+ // Deletes spurious ambiguous transitions (due to quantization).
+ void RemoveSplits(MutableFst<Arc> *ofst);
+
+ // Deletes actual ambiguous transitions.
+ void RemoveAmbiguities(MutableFst<Arc> *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<std::pair<StateId, StateId>> coreachable_;
+
+ // Queue of disambiguation-related states to be processed. We store only
+ // state pairs s1, s2 such that s1 <= s2.
+ std::list<std::pair<StateId, StateId>> queue_;
+
+ // Head state in the pre-disambiguation for a given state.
+ std::vector<StateId> 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<ArcIdMap> candidates_;
+
+ // Set of ambiguous transitions to be removed.
+ std::set<ArcId> ambiguous_;
+
+ // States to merge due to quantization issues.
+ std::unique_ptr<UnionFind<StateId>> merge_;
+ // Marks error condition.
+ bool error_;
+
+ Disambiguator(const Disambiguator &) = delete;
+ Disambiguator &operator=(const Disambiguator &) = delete;
+};
+
+template <class Arc>
+void Disambiguator<Arc>::PreDisambiguate(const ExpandedFst<Arc> &ifst,
+ MutableFst<Arc> *ofst,
+ const DisambiguateOptions<Arc> &opts) {
+ using CommonDivisor = DefaultCommonDivisor<Weight>;
+ using Filter = RelationDeterminizeFilter<Arc, CommonFuture>;
+ // 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<Arc, CommonDivisor, Filter> 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<Weight> idistance, odistance;
+ ShortestDistance(ifst, &idistance, true);
+ DeterminizeFst<Arc> dfst(ifst, &idistance, &odistance, nopts);
+ PruneOptions< Arc, AnyArcFilter<Arc>> popts(opts.weight_threshold,
+ opts.state_threshold,
+ AnyArcFilter<Arc>(),
+ &odistance);
+ Prune(dfst, ofst, popts);
+ } else */ {
+ *ofst = DeterminizeFst<Arc>(ifst, nopts);
+ Prune(ofst, opts.weight_threshold, opts.state_threshold);
+ }
+ } else {
+ *ofst = DeterminizeFst<Arc>(ifst, nopts);
+ }
+ head_.resize(ofst->NumStates(), kNoStateId);
+}
+
+template <class Arc>
+void Disambiguator<Arc>::FindAmbiguities(const ExpandedFst<Arc> &fst) {
+ if (fst.Start() == kNoStateId) return;
+ candidates_.reset(new ArcIdMap(ArcIdCompare(head_)));
+ const auto start_pr = std::make_pair(fst.Start(), fst.Start());
+ coreachable_.insert(start_pr);
+ queue_.push_back(start_pr);
+ while (!queue_.empty()) {
+ const auto &pr = queue_.front();
+ const auto s1 = pr.first;
+ const auto s2 = pr.second;
+ queue_.pop_front();
+ FindAmbiguousPairs(fst, s1, s2);
+ }
+}
+
+template <class Arc>
+void Disambiguator<Arc>::FindAmbiguousPairs(const ExpandedFst<Arc> &fst,
+ StateId s1, StateId s2) {
+ if (fst.NumArcs(s2) > fst.NumArcs(s1)) FindAmbiguousPairs(fst, s2, s1);
+ SortedMatcher<Fst<Arc>> matcher(fst, MATCH_INPUT);
+ matcher.SetState(s2);
+ for (ArcIterator<Fst<Arc>> aiter(fst, s1); !aiter.Done(); aiter.Next()) {
+ const auto &arc1 = aiter.Value();
+ const ArcId a1(s1, aiter.Position());
+ if (matcher.Find(arc1.ilabel)) {
+ for (; !matcher.Done(); matcher.Next()) {
+ const auto &arc2 = matcher.Value();
+ // Continues on implicit epsilon match.
+ if (arc2.ilabel == kNoLabel) continue;
+ const ArcId a2(s2, matcher.Position());
+ // Actual transition is ambiguous.
+ if (s1 != s2 && arc1.nextstate == arc2.nextstate) {
+ InsertCandidate(s1, s2, a1, a2);
+ }
+ const auto spr = arc1.nextstate <= arc2.nextstate
+ ? std::make_pair(arc1.nextstate, arc2.nextstate)
+ : std::make_pair(arc2.nextstate, arc1.nextstate);
+ // Not already marked as coreachable?
+ if (coreachable_.insert(spr).second) {
+ // Only possible if state split by quantization issues.
+ if (spr.first != spr.second &&
+ head_[spr.first] == head_[spr.second]) {
+ if (!merge_) {
+ merge_.reset(new UnionFind<StateId>(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 <class Arc>
+void Disambiguator<Arc>::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 <class Arc>
+void Disambiguator<Arc>::RemoveSplits(MutableFst<Arc> *ofst) {
+ if (!merge_) return;
+ // Merges split states to remove spurious ambiguities.
+ for (StateIterator<MutableFst<Arc>> siter(*ofst); !siter.Done();
+ siter.Next()) {
+ for (MutableArcIterator<MutableFst<Arc>> 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 <class Arc>
+void Disambiguator<Arc>::RemoveAmbiguities(MutableFst<Arc> *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<MutableFst<Arc>> 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 <class Arc>
+void Disambiguate(
+ const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ const DisambiguateOptions<Arc> &opts = DisambiguateOptions<Arc>()) {
+ internal::Disambiguator<Arc> disambiguator;
+ disambiguator.Disambiguate(ifst, ofst, opts);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_DISAMBIGUATE_H_
--- /dev/null
+// 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<StateId> &); 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_LIB_EDIT_FST_H_
+#define FST_LIB_EDIT_FST_H_
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <fst/cache.h>
+
+
+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 Arc, typename WrappedFstT = ExpandedFst<Arc>,
+ typename MutableFstT = VectorFst<Arc>>
+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<Arc, WrappedFstT, MutableFstT> *Read(
+ std::istream &strm, const FstReadOptions &opts);
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const {
+ // Serialize all private data members of this class.
+ FstWriteOptions edits_opts(opts);
+ edits_opts.write_header = true; // Force writing contained header.
+ edits_.Write(strm, edits_opts);
+ WriteType(strm, external_to_internal_ids_);
+ WriteType(strm, edited_final_weights_);
+ WriteType(strm, num_new_states_);
+ if (!strm) {
+ LOG(ERROR) << "EditFstData::Write: Write failed: " << opts.source;
+ return false;
+ }
+ return true;
+ }
+
+ StateId NumNewStates() const { return num_new_states_; }
+
+ // accessor methods for the fst holding edited states
+ StateId EditedStart() const { return edits_.Start(); }
+
+ Weight Final(StateId s, const WrappedFstT *wrapped) const {
+ auto final_weight_it = GetFinalWeightIterator(s);
+ if (final_weight_it == NotInFinalWeightMap()) {
+ auto it = GetEditedIdMapIterator(s);
+ return it == NotInEditedMap() ? wrapped->Final(s)
+ : edits_.Final(it->second);
+ } else {
+ return final_weight_it->second;
+ }
+ }
+
+ size_t NumArcs(StateId s, const WrappedFstT *wrapped) const {
+ auto it = GetEditedIdMapIterator(s);
+ return it == NotInEditedMap() ? wrapped->NumArcs(s)
+ : edits_.NumArcs(it->second);
+ }
+
+ size_t NumInputEpsilons(StateId s, const WrappedFstT *wrapped) const {
+ auto it = GetEditedIdMapIterator(s);
+ return it == NotInEditedMap() ? wrapped->NumInputEpsilons(s)
+ : edits_.NumInputEpsilons(it->second);
+ }
+
+ size_t NumOutputEpsilons(StateId s, const WrappedFstT *wrapped) const {
+ auto it = GetEditedIdMapIterator(s);
+ return it == NotInEditedMap() ? wrapped->NumOutputEpsilons(s)
+ : edits_.NumOutputEpsilons(it->second);
+ }
+
+ void SetEditedProperties(uint64 props, uint64 mask) {
+ edits_.SetProperties(props, mask);
+ }
+
+ // Non-const MutableFst operations.
+
+ // Sets the start state for this FST.
+ void SetStart(StateId s) { edits_.SetStart(s); }
+
+ // Sets the final state for this FST.
+ Weight SetFinal(StateId s, Weight w, const WrappedFstT *wrapped) {
+ Weight old_weight = Final(s, wrapped);
+ auto it = GetEditedIdMapIterator(s);
+ // If we haven't already edited state s, don't add it to edited_ (which can
+ // be expensive if s has many transitions); just use the
+ // edited_final_weights_ map.
+ if (it == NotInEditedMap()) {
+ edited_final_weights_[s] = w;
+ } else {
+ edits_.SetFinal(GetEditableInternalId(s, wrapped), w);
+ }
+ return old_weight;
+ }
+
+ // Adds a new state to this FST, initially with no arcs.
+ StateId AddState(StateId curr_num_states) {
+ StateId internal_state_id = edits_.AddState();
+ StateId external_state_id = curr_num_states;
+ external_to_internal_ids_[external_state_id] = internal_state_id;
+ num_new_states_++;
+ return external_state_id;
+ }
+
+ // Adds the specified arc to the specified state of this FST.
+ const Arc *AddArc(StateId s, const Arc &arc, const WrappedFstT *wrapped) {
+ const auto internal_id = GetEditableInternalId(s, wrapped);
+ const auto num_arcs = edits_.NumArcs(internal_id);
+ ArcIterator<MutableFstT> arc_it(edits_, internal_id);
+ const Arc *prev_arc = nullptr;
+ if (num_arcs > 0) {
+ // grab the final arc associated with this state in edits_
+ arc_it.Seek(num_arcs - 1);
+ prev_arc = &(arc_it.Value());
+ }
+ edits_.AddArc(internal_id, arc);
+ return prev_arc;
+ }
+
+ void DeleteStates() {
+ edits_.DeleteStates();
+ num_new_states_ = 0;
+ external_to_internal_ids_.clear();
+ edited_final_weights_.clear();
+ }
+
+ // Removes all but the first n outgoing arcs of the specified state.
+ void DeleteArcs(StateId s, size_t n, const WrappedFstT *wrapped) {
+ edits_.DeleteArcs(GetEditableInternalId(s, wrapped), n);
+ }
+
+ // Removes all outgoing arcs from the specified state.
+ void DeleteArcs(StateId s, const WrappedFstT *wrapped) {
+ edits_.DeleteArcs(GetEditableInternalId(s, wrapped));
+ }
+
+ // End methods for non-const MutableFst operations.
+
+ // Provides information for the generic arc iterator.
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data,
+ const WrappedFstT *wrapped) const {
+ auto id_map_it = GetEditedIdMapIterator(s);
+ if (id_map_it == NotInEditedMap()) {
+ VLOG(3) << "EditFstData::InitArcIterator: iterating on state " << s
+ << " of original fst";
+ wrapped->InitArcIterator(s, data);
+ } else {
+ VLOG(2) << "EditFstData::InitArcIterator: iterating on edited state " << s
+ << " (internal state id: " << id_map_it->second << ")";
+ edits_.InitArcIterator(id_map_it->second, data);
+ }
+ }
+
+ // Provides information for the generic mutable arc iterator.
+ void InitMutableArcIterator(StateId s, MutableArcIteratorData<Arc> *data,
+ const WrappedFstT *wrapped) {
+ data->base = new MutableArcIterator<MutableFstT>(
+ &edits_, GetEditableInternalId(s, wrapped));
+ }
+
+ // Prints out the map from external to internal state id's (for debugging
+ // purposes).
+ void PrintMap() {
+ for (auto map_it = external_to_internal_ids_.begin();
+ map_it != NotInEditedMap(); ++map_it) {
+ LOG(INFO) << "(external,internal)=(" << map_it->first << ","
+ << map_it->second << ")";
+ }
+ }
+
+ private:
+ // Returns the iterator of the map from external to internal state id's
+ // of edits_ for the specified external state id.
+ typename std::unordered_map<StateId, StateId>::const_iterator
+ GetEditedIdMapIterator(StateId s) const {
+ return external_to_internal_ids_.find(s);
+ }
+
+ typename std::unordered_map<StateId, StateId>::const_iterator
+ NotInEditedMap() const {
+ return external_to_internal_ids_.end();
+ }
+
+ typename std::unordered_map<StateId, Weight>::const_iterator
+ GetFinalWeightIterator(StateId s) const {
+ return edited_final_weights_.find(s);
+ }
+
+ typename std::unordered_map<StateId, Weight>::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<Fst<Arc>> 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<StateId, StateId> 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<StateId, Weight> 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 <typename A, typename WrappedFstT, typename MutableFstT>
+EditFstData<A, WrappedFstT, MutableFstT> *
+EditFstData<A, WrappedFstT, MutableFstT>::Read(std::istream &strm,
+ const FstReadOptions &opts) {
+ auto *data = new EditFstData<A, WrappedFstT, MutableFstT>();
+ // 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<A>) 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<MutableFstT> 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<StateId> &); 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 A, typename WrappedFstT = ExpandedFst<A>,
+ typename MutableFstT = VectorFst<A>>
+class EditFstImpl : public FstImpl<A> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+ using FstImpl<Arc>::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<Arc>::SetType("edit");
+ InheritPropertiesFromWrapped();
+ data_ = std::make_shared<EditFstData<Arc, WrappedFstT, MutableFstT>>();
+ }
+
+ // Wraps the specified ExpandedFst. This constructor requires that the
+ // specified Fst is an ExpandedFst instance. This requirement is only enforced
+ // at runtime. (See below for the reason.)
+ //
+ // This library uses the pointer-to-implementation or "PIMPL" design pattern.
+ // In particular, to make it convenient to bind an implementation class to its
+ // interface, there are a pair of template "binder" classes, one for immutable
+ // and one for mutable fst's (ImplToFst and ImplToMutableFst, respectively).
+ // As it happens, the API for the ImplToMutableFst<I,F> class requires that
+ // the implementation class--the template parameter "I"--have a constructor
+ // taking a const Fst<A> reference. Accordingly, the constructor here must
+ // perform a static_cast to the WrappedFstT type required by EditFst and
+ // therefore EditFstImpl.
+ explicit EditFstImpl(const Fst<Arc> &wrapped)
+ : wrapped_(static_cast<WrappedFstT *>(wrapped.Copy())) {
+ FstImpl<Arc>::SetType("edit");
+ data_ = std::make_shared<EditFstData<Arc, WrappedFstT, MutableFstT>>();
+ // 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<Arc>(),
+ wrapped_(static_cast<WrappedFstT *>(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<Arc, WrappedFstT, MutableFstT> *Read(
+ std::istream &strm, const FstReadOptions &opts);
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const {
+ FstHeader hdr;
+ hdr.SetStart(Start());
+ hdr.SetNumStates(NumStates());
+ FstWriteOptions header_opts(opts);
+ // Allows the contained FST to hold any symbols.
+ header_opts.write_isymbols = false;
+ header_opts.write_osymbols = false;
+ WriteHeader(strm, header_opts, kFileVersion, &hdr);
+ // First, serializes the wrapped FST to stream.
+ FstWriteOptions wrapped_opts(opts);
+ // Forcse writing the contained header.
+ wrapped_opts.write_header = true;
+ wrapped_->Write(strm, wrapped_opts);
+ data_->Write(strm, opts);
+ strm.flush();
+ if (!strm) {
+ LOG(ERROR) << "EditFst::Write: Write failed: " << opts.source;
+ return false;
+ }
+ return true;
+ }
+
+ // Sets the start state for this FST.
+ void SetStart(StateId s) {
+ MutateCheck();
+ data_->SetStart(s);
+ SetProperties(SetStartProperties(FstImpl<Arc>::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<Arc>::Properties(), old_weight, weight));
+ }
+
+ // Adds a new state to this fst, initially with no arcs.
+ StateId AddState() {
+ MutateCheck();
+ SetProperties(AddStateProperties(FstImpl<Arc>::Properties()));
+ return data_->AddState(NumStates());
+ }
+
+ // Adds the specified arc to the specified state of this fst.
+ void AddArc(StateId s, const Arc &arc) {
+ MutateCheck();
+ const auto *prev_arc = data_->AddArc(s, arc, wrapped_.get());
+ SetProperties(
+ AddArcProperties(FstImpl<Arc>::Properties(), s, arc, prev_arc));
+ }
+
+ void DeleteStates(const std::vector<StateId> &dstates) {
+ FSTERROR() << ": EditFstImpl::DeleteStates(const std::vector<StateId>&): "
+ << " 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<Arc>::Properties()));
+ }
+
+ // Removes all outgoing arcs from the specified state.
+ void DeleteArcs(StateId s) {
+ MutateCheck();
+ data_->DeleteArcs(s, wrapped_.get());
+ SetProperties(DeleteArcsProperties(FstImpl<Arc>::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<Arc> *data) const {
+ data->base = nullptr;
+ data->nstates = NumStates();
+ }
+
+ // Provides information for the generic arc iterator.
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const {
+ data_->InitArcIterator(s, data, wrapped_.get());
+ }
+
+ // Provides information for the generic mutable arc iterator.
+ void InitMutableArcIterator(StateId s, MutableArcIteratorData<Arc> *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<EditFstData<Arc, WrappedFstT, MutableFstT>>(*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<const WrappedFstT> wrapped_;
+ // The mutable data for this EditFst instance, with delegates for all the
+ // methods that can mutate data.
+ std::shared_ptr<EditFstData<Arc, WrappedFstT, MutableFstT>> data_;
+};
+
+template <typename Arc, typename WrappedFstT, typename MutableFstT>
+constexpr uint64 EditFstImpl<Arc, WrappedFstT, MutableFstT>::kStaticProperties;
+
+template <typename Arc, typename WrappedFstT, typename MutableFstT>
+constexpr int EditFstImpl<Arc, WrappedFstT, MutableFstT>::kFileVersion;
+
+template <typename Arc, typename WrappedFstT, typename MutableFstT>
+constexpr int EditFstImpl<Arc, WrappedFstT, MutableFstT>::kMinFileVersion;
+
+template <typename Arc, typename WrappedFstT, typename MutableFstT>
+inline void EditFstImpl<Arc, WrappedFstT, MutableFstT>::DeleteStates() {
+ data_->DeleteStates();
+ // we are deleting all states, so just forget about pointer to wrapped_
+ // and do what default constructor does: set wrapped_ to a new VectorFst
+ wrapped_.reset(new MutableFstT());
+ const auto new_props =
+ DeleteAllStatesProperties(FstImpl<Arc>::Properties(), kStaticProperties);
+ FstImpl<Arc>::SetProperties(new_props);
+}
+
+template <typename Arc, typename WrappedFstT, typename MutableFstT>
+EditFstImpl<Arc, WrappedFstT, MutableFstT> *
+EditFstImpl<Arc, WrappedFstT, MutableFstT>::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<Fst<Arc>> wrapped_fst(Fst<Arc>::Read(strm, wrapped_opts));
+ if (!wrapped_fst) return nullptr;
+ impl->wrapped_.reset(static_cast<WrappedFstT *>(wrapped_fst.release()));
+ impl->data_ = std::shared_ptr<EditFstData<Arc, WrappedFstT, MutableFstT>>(
+ EditFstData<Arc, WrappedFstT, MutableFstT>::Read(strm, opts));
+ if (!impl->data_) return nullptr;
+ return impl;
+}
+
+} // namespace internal
+
+// Concrete, editable FST. This class attaches interface to implementation.
+template <typename A, typename WrappedFstT = ExpandedFst<A>,
+ typename MutableFstT = VectorFst<A>>
+class EditFst : public ImplToMutableFst<
+ internal::EditFstImpl<A, WrappedFstT, MutableFstT>> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ using Impl = internal::EditFstImpl<Arc, WrappedFstT, MutableFstT>;
+
+ friend class MutableArcIterator<EditFst<Arc, WrappedFstT, MutableFstT>>;
+
+ EditFst() : ImplToMutableFst<Impl>(std::make_shared<Impl>()) {}
+
+ explicit EditFst(const Fst<Arc> &fst)
+ : ImplToMutableFst<Impl>(std::make_shared<Impl>(fst)) {}
+
+ explicit EditFst(const WrappedFstT &fst)
+ : ImplToMutableFst<Impl>(std::make_shared<Impl>(fst)) {}
+
+ // See Fst<>::Copy() for doc.
+ EditFst(const EditFst<Arc, WrappedFstT, MutableFstT> &fst, bool safe = false)
+ : ImplToMutableFst<Impl>(fst, safe) {}
+
+ ~EditFst() override {}
+
+ // Gets a copy of this EditFst. See Fst<>::Copy() for further doc.
+ EditFst<Arc, WrappedFstT, MutableFstT> *Copy(
+ bool safe = false) const override {
+ return new EditFst<Arc, WrappedFstT, MutableFstT>(*this, safe);
+ }
+
+ EditFst<Arc, WrappedFstT, MutableFstT> &operator=(
+ const EditFst<Arc, WrappedFstT, MutableFstT> &fst) {
+ SetImpl(fst.GetSharedImpl());
+ return *this;
+ }
+
+ EditFst<Arc, WrappedFstT, MutableFstT> &operator=(
+ const Fst<Arc> &fst) override {
+ SetImpl(std::make_shared<Impl>(fst));
+ return *this;
+ }
+
+ // Reads an EditFst from an input stream, returning nullptr on error.
+ static EditFst<Arc, WrappedFstT, MutableFstT> *Read(
+ std::istream &strm, const FstReadOptions &opts) {
+ auto *impl = Impl::Read(strm, opts);
+ return impl ? new EditFst<Arc>(std::shared_ptr<Impl>(impl)) : nullptr;
+ }
+
+ // Reads an EditFst from a file, returning nullptr on error. If the filename
+ // argument is an empty string, it reads from standard input.
+ static EditFst<Arc, WrappedFstT, MutableFstT> *Read(const string &filename) {
+ auto *impl = ImplToExpandedFst<Impl, MutableFst<Arc>>::Read(filename);
+ return impl ? new EditFst<Arc, WrappedFstT, MutableFstT>(
+ std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return GetImpl()->Write(strm, opts);
+ }
+
+ bool Write(const string &filename) const override {
+ return Fst<Arc>::WriteFile(filename);
+ }
+
+ void InitStateIterator(StateIteratorData<Arc> *data) const override {
+ GetImpl()->InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetImpl()->InitArcIterator(s, data);
+ }
+
+ void InitMutableArcIterator(StateId s,
+ MutableArcIteratorData<A> *data) override {
+ GetMutableImpl()->InitMutableArcIterator(s, data);
+ }
+
+ private:
+ explicit EditFst(std::shared_ptr<Impl> impl) : ImplToMutableFst<Impl>(impl) {}
+
+ using ImplToFst<Impl, MutableFst<Arc>>::GetImpl;
+ using ImplToFst<Impl, MutableFst<Arc>>::GetMutableImpl;
+ using ImplToFst<Impl, MutableFst<Arc>>::SetImpl;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_EDIT_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Class to encode and decode an FST.
+
+#ifndef FST_LIB_ENCODE_H_
+#define FST_LIB_ENCODE_H_
+
+#include <iostream>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fstream>
+
+#include <fst/arc-map.h>
+#include <fst/rmfinalepsilon.h>
+
+
+namespace fst {
+
+enum EncodeType { ENCODE = 1, DECODE = 2 };
+
+static constexpr uint32 kEncodeLabels = 0x0001;
+static constexpr uint32 kEncodeWeights = 0x0002;
+static constexpr uint32 kEncodeFlags = 0x0003;
+
+namespace internal {
+
+static constexpr uint32 kEncodeHasISymbols = 0x0004;
+static constexpr uint32 kEncodeHasOSymbols = 0x0008;
+
+// Identifies stream data as an encode table (and its endianity)
+static const int32 kEncodeMagicNumber = 2129983209;
+
+// The following class encapsulates implementation details for the encoding and
+// decoding of label/weight tuples used for encoding and decoding of FSTs. The
+// EncodeTable is bidirectional. I.e, it stores both the Tuple of encode labels
+// and weights to a unique label, and the reverse.
+template <class Arc>
+class EncodeTable {
+ public:
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+
+ // Encoded data consists of arc input/output labels and arc weight.
+ struct Tuple {
+ Tuple() {}
+
+ Tuple(Label ilabel_, Label olabel_, Weight weight_)
+ : ilabel(ilabel_), olabel(olabel_), weight(std::move(weight_)) {}
+
+ Tuple(const Tuple &tuple)
+ : ilabel(tuple.ilabel),
+ olabel(tuple.olabel),
+ weight(std::move(tuple.weight)) {}
+
+ Label ilabel;
+ Label olabel;
+ Weight weight;
+ };
+
+ // Comparison object for hashing EncodeTable Tuple(s).
+ class TupleEqual {
+ public:
+ bool operator()(const Tuple *x, const Tuple *y) const {
+ return (x->ilabel == y->ilabel && x->olabel == y->olabel &&
+ x->weight == y->weight);
+ }
+ };
+
+ // Hash function for EncodeTabe Tuples. Based on the encode flags
+ // we either hash the labels, weights or combination of them.
+ class TupleKey {
+ public:
+ TupleKey() : encode_flags_(kEncodeLabels | kEncodeWeights) {}
+
+ TupleKey(const TupleKey &key) : encode_flags_(key.encode_flags_) {}
+
+ explicit TupleKey(uint32 encode_flags) : encode_flags_(encode_flags) {}
+
+ size_t operator()(const Tuple *x) const {
+ size_t hash = x->ilabel;
+ static constexpr int lshift = 5;
+ static constexpr int rshift = CHAR_BIT * sizeof(size_t) - 5;
+ if (encode_flags_ & kEncodeLabels) {
+ hash = hash << lshift ^ hash >> rshift ^ x->olabel;
+ }
+ if (encode_flags_ & kEncodeWeights) {
+ hash = hash << lshift ^ hash >> rshift ^ x->weight.Hash();
+ }
+ return hash;
+ }
+
+ private:
+ int32 encode_flags_;
+ };
+
+ explicit EncodeTable(uint32 encode_flags)
+ : flags_(encode_flags), encode_hash_(1024, TupleKey(encode_flags)) {}
+
+ using EncodeHash = std::unordered_map<const Tuple *, Label, TupleKey,
+ TupleEqual>;
+
+ // Given an arc, encodes either input/output labels or input/costs or both.
+ Label Encode(const Arc &arc) {
+ std::unique_ptr<Tuple> tuple(
+ new Tuple(arc.ilabel, flags_ & kEncodeLabels ? arc.olabel : 0,
+ flags_ & kEncodeWeights ? arc.weight : Weight::One()));
+ auto insert_result = encode_hash_.insert(
+ std::make_pair(tuple.get(), encode_tuples_.size() + 1));
+ if (insert_result.second) encode_tuples_.push_back(std::move(tuple));
+ return insert_result.first->second;
+ }
+
+ // Given an arc, looks up its encoded label or returns kNoLabel if not found.
+ Label GetLabel(const Arc &arc) const {
+ const Tuple tuple(arc.ilabel, flags_ & kEncodeLabels ? arc.olabel : 0,
+ flags_ & kEncodeWeights ? arc.weight : Weight::One());
+ auto it = encode_hash_.find(&tuple);
+ return (it == encode_hash_.end()) ? kNoLabel : it->second;
+ }
+
+ // Given an encoded arc label, decodes back to input/output labels and costs.
+ const Tuple *Decode(Label key) const {
+ if (key < 1 || key > encode_tuples_.size()) {
+ LOG(ERROR) << "EncodeTable::Decode: Unknown decode key: " << key;
+ return nullptr;
+ }
+ return encode_tuples_[key - 1].get();
+ }
+
+ size_t Size() const { return encode_tuples_.size(); }
+
+ bool Write(std::ostream &strm, const string &source) const;
+
+ static EncodeTable<Arc> *Read(std::istream &strm, const string &source);
+
+ uint32 Flags() const { return flags_ & kEncodeFlags; }
+
+ const SymbolTable *InputSymbols() const { return isymbols_.get(); }
+
+ const SymbolTable *OutputSymbols() const { return osymbols_.get(); }
+
+ void SetInputSymbols(const SymbolTable *syms) {
+ if (syms) {
+ isymbols_.reset(syms->Copy());
+ flags_ |= kEncodeHasISymbols;
+ } else {
+ isymbols_.reset();
+ flags_ &= ~kEncodeHasISymbols;
+ }
+ }
+
+ void SetOutputSymbols(const SymbolTable *syms) {
+ if (syms) {
+ osymbols_.reset(syms->Copy());
+ flags_ |= kEncodeHasOSymbols;
+ } else {
+ osymbols_.reset();
+ flags_ &= ~kEncodeHasOSymbols;
+ }
+ }
+
+ private:
+ uint32 flags_;
+ std::vector<std::unique_ptr<Tuple>> encode_tuples_;
+ EncodeHash encode_hash_;
+ std::unique_ptr<SymbolTable> isymbols_; // Pre-encoded input symbol table.
+ std::unique_ptr<SymbolTable> osymbols_; // Pre-encoded output symbol table.
+
+ EncodeTable(const EncodeTable &) = delete;
+ EncodeTable &operator=(const EncodeTable &) = delete;
+};
+
+template <class Arc>
+bool EncodeTable<Arc>::Write(std::ostream &strm,
+ const string &source) const {
+ WriteType(strm, kEncodeMagicNumber);
+ WriteType(strm, flags_);
+ const int64 size = encode_tuples_.size();
+ WriteType(strm, size);
+ for (const auto &tuple : encode_tuples_) {
+ WriteType(strm, tuple->ilabel);
+ WriteType(strm, tuple->olabel);
+ tuple->weight.Write(strm);
+ }
+ if (flags_ & kEncodeHasISymbols) isymbols_->Write(strm);
+ if (flags_ & kEncodeHasOSymbols) osymbols_->Write(strm);
+ strm.flush();
+ if (!strm) {
+ LOG(ERROR) << "EncodeTable::Write: Write failed: " << source;
+ return false;
+ }
+ return true;
+}
+
+template <class Arc>
+EncodeTable<Arc> *EncodeTable<Arc>::Read(std::istream &strm,
+ const string &source) {
+ int32 magic_number = 0;
+ ReadType(strm, &magic_number);
+ if (magic_number != kEncodeMagicNumber) {
+ LOG(ERROR) << "EncodeTable::Read: Bad encode table header: " << source;
+ return nullptr;
+ }
+ uint32 flags;
+ ReadType(strm, &flags);
+ int64 size;
+ ReadType(strm, &size);
+ if (!strm) {
+ LOG(ERROR) << "EncodeTable::Read: Read failed: " << source;
+ return nullptr;
+ }
+ std::unique_ptr<EncodeTable<Arc>> table(new EncodeTable<Arc>(flags));
+ for (int64 i = 0; i < size; ++i) {
+ std::unique_ptr<Tuple> tuple(new Tuple());
+ ReadType(strm, &tuple->ilabel);
+ ReadType(strm, &tuple->olabel);
+ tuple->weight.Read(strm);
+ if (!strm) {
+ LOG(ERROR) << "EncodeTable::Read: Read failed: " << source;
+ return nullptr;
+ }
+ table->encode_tuples_.push_back(std::move(tuple));
+ table->encode_hash_[table->encode_tuples_.back().get()] =
+ table->encode_tuples_.size();
+ }
+ if (flags & kEncodeHasISymbols) {
+ table->isymbols_.reset(SymbolTable::Read(strm, source));
+ }
+ if (flags & kEncodeHasOSymbols) {
+ table->osymbols_.reset(SymbolTable::Read(strm, source));
+ }
+ return table.release();
+}
+
+} // namespace internal
+
+// A mapper to encode/decode weighted transducers. Encoding of an FST is used
+// for performing classical determinization or minimization on a weighted
+// transducer viewing it as an unweighted acceptor over encoded labels.
+//
+// The mapper stores the encoding in a local hash table (EncodeTable). This
+// table is shared (and reference-counted) between the encoder and decoder.
+// A decoder has read-only access to the EncodeTable.
+//
+// The EncodeMapper allows on the fly encoding of the machine. As the
+// EncodeTable is generated the same table may by used to decode the machine
+// on the fly. For example in the following sequence of operations
+//
+// Encode -> Determinize -> Decode
+//
+// we will use the encoding table generated during the encode step in the
+// decode, even though the encoding is not complete.
+template <class Arc>
+class EncodeMapper {
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+
+ public:
+ EncodeMapper(uint32 flags, EncodeType type)
+ : flags_(flags),
+ type_(type),
+ table_(std::make_shared<internal::EncodeTable<Arc>>(flags)),
+ error_(false) {}
+
+ EncodeMapper(const EncodeMapper &mapper)
+ : flags_(mapper.flags_),
+ type_(mapper.type_),
+ table_(mapper.table_),
+ error_(false) {}
+
+ // Copy constructor but setting the type, typically to DECODE.
+ EncodeMapper(const EncodeMapper &mapper, EncodeType type)
+ : flags_(mapper.flags_),
+ type_(type),
+ table_(mapper.table_),
+ error_(mapper.error_) {}
+
+ Arc operator()(const Arc &arc);
+
+ MapFinalAction FinalAction() const {
+ return (type_ == ENCODE && (flags_ & kEncodeWeights))
+ ? MAP_REQUIRE_SUPERFINAL
+ : MAP_NO_SUPERFINAL;
+ }
+
+ constexpr MapSymbolsAction InputSymbolsAction() const {
+ return MAP_CLEAR_SYMBOLS;
+ }
+
+ constexpr MapSymbolsAction OutputSymbolsAction() const {
+ return MAP_CLEAR_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 inprops) {
+ uint64 outprops = inprops;
+ if (error_) outprops |= kError;
+ uint64 mask = kFstProperties;
+ if (flags_ & kEncodeLabels) {
+ mask &= kILabelInvariantProperties & kOLabelInvariantProperties;
+ }
+ if (flags_ & kEncodeWeights) {
+ mask &= kILabelInvariantProperties & kWeightInvariantProperties &
+ (type_ == ENCODE ? kAddSuperFinalProperties
+ : kRmSuperFinalProperties);
+ }
+ return outprops & mask;
+ }
+
+ uint32 Flags() const { return flags_; }
+
+ EncodeType Type() const { return type_; }
+
+ bool Write(std::ostream &strm, const string &source) const {
+ return table_->Write(strm, source);
+ }
+
+ bool Write(const string &filename) const {
+ std::ofstream strm(filename.c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "EncodeMap: Can't open file: " << filename;
+ return false;
+ }
+ return Write(strm, filename);
+ }
+
+ static EncodeMapper<Arc> *Read(std::istream &strm, const string &source,
+ EncodeType type = ENCODE) {
+ auto *table = internal::EncodeTable<Arc>::Read(strm, source);
+ return table ? new EncodeMapper(table->Flags(), type, table) : nullptr;
+ }
+
+ static EncodeMapper<Arc> *Read(const string &filename,
+ EncodeType type = ENCODE) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "EncodeMap: Can't open file: " << filename;
+ return nullptr;
+ }
+ return Read(strm, filename, type);
+ }
+
+ const SymbolTable *InputSymbols() const { return table_->InputSymbols(); }
+
+ const SymbolTable *OutputSymbols() const { return table_->OutputSymbols(); }
+
+ void SetInputSymbols(const SymbolTable *syms) {
+ table_->SetInputSymbols(syms);
+ }
+
+ void SetOutputSymbols(const SymbolTable *syms) {
+ table_->SetOutputSymbols(syms);
+ }
+
+ private:
+ uint32 flags_;
+ EncodeType type_;
+ std::shared_ptr<internal::EncodeTable<Arc>> table_;
+ bool error_;
+
+ explicit EncodeMapper(uint32 flags, EncodeType type,
+ internal::EncodeTable<Arc> *table)
+ : flags_(flags), type_(type), table_(table), error_(false) {}
+
+ EncodeMapper &operator=(const EncodeMapper &) = delete;
+};
+
+template <class Arc>
+Arc EncodeMapper<Arc>::operator()(const Arc &arc) {
+ if (type_ == ENCODE) {
+ if ((arc.nextstate == kNoStateId && !(flags_ & kEncodeWeights)) ||
+ (arc.nextstate == kNoStateId && (flags_ & kEncodeWeights) &&
+ arc.weight == Weight::Zero())) {
+ return arc;
+ } else {
+ const auto label = table_->Encode(arc);
+ return Arc(label, flags_ & kEncodeLabels ? label : arc.olabel,
+ flags_ & kEncodeWeights ? Weight::One() : arc.weight,
+ arc.nextstate);
+ }
+ } else { // type_ == DECODE
+ if (arc.nextstate == kNoStateId) {
+ return arc;
+ } else {
+ if (arc.ilabel == 0) return arc;
+ if (flags_ & kEncodeLabels && arc.ilabel != arc.olabel) {
+ FSTERROR() << "EncodeMapper: Label-encoded arc has different "
+ "input and output labels";
+ error_ = true;
+ }
+ if (flags_ & kEncodeWeights && arc.weight != Weight::One()) {
+ FSTERROR() << "EncodeMapper: Weight-encoded arc has non-trivial weight";
+ error_ = true;
+ }
+ const auto tuple = table_->Decode(arc.ilabel);
+ if (!tuple) {
+ FSTERROR() << "EncodeMapper: Decode failed";
+ error_ = true;
+ return Arc(kNoLabel, kNoLabel, Weight::NoWeight(), arc.nextstate);
+ } else {
+ return Arc(tuple->ilabel,
+ flags_ & kEncodeLabels ? tuple->olabel : arc.olabel,
+ flags_ & kEncodeWeights ? tuple->weight : arc.weight,
+ arc.nextstate);
+ }
+ }
+ }
+}
+
+// Complexity: O(E + V).
+template <class Arc>
+inline void Encode(MutableFst<Arc> *fst, EncodeMapper<Arc> *mapper) {
+ mapper->SetInputSymbols(fst->InputSymbols());
+ mapper->SetOutputSymbols(fst->OutputSymbols());
+ ArcMap(fst, mapper);
+}
+
+template <class Arc>
+inline void Decode(MutableFst<Arc> *fst, const EncodeMapper<Arc> &mapper) {
+ ArcMap(fst, EncodeMapper<Arc>(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 Arc>
+class EncodeFst : public ArcMapFst<Arc, Arc, EncodeMapper<Arc>> {
+ public:
+ using Mapper = EncodeMapper<Arc>;
+ using Impl = internal::ArcMapFstImpl<Arc, Arc, Mapper>;
+
+ EncodeFst(const Fst<Arc> &fst, Mapper *encoder)
+ : ArcMapFst<Arc, Arc, Mapper>(fst, encoder, ArcMapFstOptions()) {
+ encoder->SetInputSymbols(fst.InputSymbols());
+ encoder->SetOutputSymbols(fst.OutputSymbols());
+ }
+
+ EncodeFst(const Fst<Arc> &fst, const Mapper &encoder)
+ : ArcMapFst<Arc, Arc, Mapper>(fst, encoder, ArcMapFstOptions()) {}
+
+ // See Fst<>::Copy() for doc.
+ EncodeFst(const EncodeFst<Arc> &fst, bool copy = false)
+ : ArcMapFst<Arc, Arc, Mapper>(fst, copy) {}
+
+ // Makes a copy of this EncodeFst. See Fst<>::Copy() for further doc.
+ EncodeFst<Arc> *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<Impl>::GetImpl;
+ using ImplToFst<Impl>::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 Arc>
+class DecodeFst : public ArcMapFst<Arc, Arc, EncodeMapper<Arc>> {
+ public:
+ using Mapper = EncodeMapper<Arc>;
+ using Impl = internal::ArcMapFstImpl<Arc, Arc, Mapper>;
+ using ImplToFst<Impl>::GetImpl;
+
+ DecodeFst(const Fst<Arc> &fst, const Mapper &encoder)
+ : ArcMapFst<Arc, Arc, Mapper>(fst, Mapper(encoder, DECODE),
+ ArcMapFstOptions()) {
+ GetMutableImpl()->SetInputSymbols(encoder.InputSymbols());
+ GetMutableImpl()->SetOutputSymbols(encoder.OutputSymbols());
+ }
+
+ // See Fst<>::Copy() for doc.
+ DecodeFst(const DecodeFst<Arc> &fst, bool safe = false)
+ : ArcMapFst<Arc, Arc, Mapper>(fst, safe) {}
+
+ // Makes a copy of this DecodeFst. See Fst<>::Copy() for further doc.
+ DecodeFst<Arc> *Copy(bool safe = false) const override {
+ return new DecodeFst(*this, safe);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetMutableImpl;
+};
+
+// Specialization for EncodeFst.
+template <class Arc>
+class StateIterator<EncodeFst<Arc>>
+ : public StateIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>> {
+ public:
+ explicit StateIterator(const EncodeFst<Arc> &fst)
+ : StateIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>>(fst) {}
+};
+
+// Specialization for EncodeFst.
+template <class Arc>
+class ArcIterator<EncodeFst<Arc>>
+ : public ArcIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>> {
+ public:
+ ArcIterator(const EncodeFst<Arc> &fst, typename Arc::StateId s)
+ : ArcIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>>(fst, s) {}
+};
+
+// Specialization for DecodeFst.
+template <class Arc>
+class StateIterator<DecodeFst<Arc>>
+ : public StateIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>> {
+ public:
+ explicit StateIterator(const DecodeFst<Arc> &fst)
+ : StateIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>>(fst) {}
+};
+
+// Specialization for DecodeFst.
+template <class Arc>
+class ArcIterator<DecodeFst<Arc>>
+ : public ArcIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>> {
+ public:
+ ArcIterator(const DecodeFst<Arc> &fst, typename Arc::StateId s)
+ : ArcIterator<ArcMapFst<Arc, Arc, EncodeMapper<Arc>>>(fst, s) {}
+};
+
+// Useful aliases when using StdArc.
+
+using StdEncodeFst = EncodeFst<StdArc>;
+
+using StdDecodeFst = DecodeFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_ENCODE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Function that implements epsilon-normalization.
+
+#ifndef FST_LIB_EPSNORMALIZE_H_
+#define FST_LIB_EPSNORMALIZE_H_
+
+
+#include <fst/arc-map.h>
+#include <fst/factor-weight.h>
+#include <fst/invert.h>
+#include <fst/rmepsilon.h>
+
+
+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 <class Arc>
+void EpsNormalize(const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ EpsNormalizeType type = EPS_NORM_INPUT) {
+ EpsNormalize<Arc, GALLIC>(ifst, ofst, type);
+}
+
+// Same as above, expect allows specifying explicitely the gallic weight type.
+template <class Arc, GallicType G>
+void EpsNormalize(const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ EpsNormalizeType type) {
+ VectorFst<GallicArc<Arc, G>> gfst;
+ if (type == EPS_NORM_INPUT) {
+ ArcMap(ifst, &gfst, ToGallicMapper<Arc, G>());
+ } else { // type == EPS_NORM_OUTPUT
+ ArcMap(InvertFst<Arc>(ifst), &gfst, ToGallicMapper<Arc, G>());
+ }
+ RmEpsilon(&gfst);
+ FactorWeightFst<GallicArc<Arc, G>,
+ GallicFactor<typename Arc::Label, typename Arc::Weight, G>>
+ fwfst(gfst);
+ ArcMap(fwfst, ofst, FromGallicMapper<Arc, G>());
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ if (type == EPS_NORM_OUTPUT) Invert(ofst);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_EPSNORMALIZE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Function to test equality of two FSTs.
+
+#ifndef FST_LIB_EQUAL_H_
+#define FST_LIB_EQUAL_H_
+
+#include <fst/fst.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+constexpr uint32 kEqualFsts = 0x0001;
+constexpr uint32 kEqualFstTypes = 0x0002;
+constexpr uint32 kEqualCompatProperties = 0x0004;
+constexpr uint32 kEqualCompatSymbols = 0x0008;
+constexpr uint32 kEqualAll =
+ kEqualFsts | kEqualFstTypes | kEqualCompatProperties | kEqualCompatSymbols;
+
+// Tests if two Fsts have the same states and arcs in the same order (when
+// etype & kEqualFst).
+// Also optional checks equality of Fst types (etype & kEqualFstTypes) and
+// compatibility of stored properties (etype & kEqualCompatProperties) and
+// of symbol tables (etype & kEqualCompatSymbols).
+template <class Arc>
+bool Equal(const Fst<Arc> &fst1, const Fst<Arc> &fst2, float delta = kDelta,
+ uint32 etype = kEqualFsts) {
+ if ((etype & kEqualFstTypes) && (fst1.Type() != fst2.Type())) {
+ VLOG(1) << "Equal: Mismatched FST types (" << fst1.Type() << " != "
+ << fst2.Type() << ")";
+ return false;
+ }
+ if ((etype & kEqualCompatProperties) &&
+ !CompatProperties(fst1.Properties(kCopyProperties, false),
+ fst2.Properties(kCopyProperties, false))) {
+ VLOG(1) << "Equal: Properties not compatible";
+ return false;
+ }
+ if (etype & kEqualCompatSymbols) {
+ if (!CompatSymbols(fst1.InputSymbols(), fst2.InputSymbols(), false)) {
+ VLOG(1) << "Equal: Input symbols not compatible";
+ return false;
+ }
+ if (!CompatSymbols(fst1.OutputSymbols(), fst2.OutputSymbols(), false)) {
+ VLOG(1) << "Equal: Output symbols not compatible";
+ return false;
+ }
+ }
+ if (!(etype & kEqualFsts)) return true;
+ if (fst1.Start() != fst2.Start()) {
+ VLOG(1) << "Equal: Mismatched start states (" << fst1.Start() << " != "
+ << fst2.Start() << ")";
+ return false;
+ }
+ StateIterator<Fst<Arc>> siter1(fst1);
+ StateIterator<Fst<Arc>> siter2(fst2);
+ while (!siter1.Done() || !siter2.Done()) {
+ if (siter1.Done() || siter2.Done()) {
+ VLOG(1) << "Equal: Mismatched number of states";
+ return false;
+ }
+ const auto s1 = siter1.Value();
+ const auto s2 = siter2.Value();
+ if (s1 != s2) {
+ VLOG(1) << "Equal: Mismatched states (" << s1 << "!= "
+ << s2 << ")";
+ return false;
+ }
+ const auto &final1 = fst1.Final(s1);
+ const auto &final2 = fst2.Final(s2);
+ if (!ApproxEqual(final1, final2, delta)) {
+ VLOG(1) << "Equal: Mismatched final weights at state " << s1
+ << " (" << final1 << " != " << final2 << ")";
+ return false;
+ }
+ ArcIterator<Fst<Arc>> aiter1(fst1, s1);
+ ArcIterator<Fst<Arc>> aiter2(fst2, s2);
+ for (auto a = 0; !aiter1.Done() || !aiter2.Done(); ++a) {
+ if (aiter1.Done() || aiter2.Done()) {
+ VLOG(1) << "Equal: Mismatched number of arcs at state " << s1;
+ return false;
+ }
+ const auto &arc1 = aiter1.Value();
+ const auto &arc2 = aiter2.Value();
+ if (arc1.ilabel != arc2.ilabel) {
+ VLOG(1) << "Equal: Mismatched arc input labels at state " << s1
+ << ", arc " << a << " (" << arc1.ilabel << " != "
+ << arc2.ilabel << ")";
+ return false;
+ } else if (arc1.olabel != arc2.olabel) {
+ VLOG(1) << "Equal: Mismatched arc output labels at state " << s1
+ << ", arc " << a << " (" << arc1.olabel << " != "
+ << arc2.olabel << ")";
+ return false;
+ } else if (!ApproxEqual(arc1.weight, arc2.weight, delta)) {
+ VLOG(1) << "Equal: Mismatched arc weights at state " << s1
+ << ", arc " << a << " (" << arc1.weight << " != "
+ << arc2.weight << ")";
+ return false;
+ } else if (arc1.nextstate != arc2.nextstate) {
+ VLOG(1) << "Equal: Mismatched next state at state " << s1
+ << ", arc " << a << " (" << arc1.nextstate << " != "
+ << arc2.nextstate << ")";
+ return false;
+ }
+ aiter1.Next();
+ aiter2.Next();
+ }
+ // Sanity checks: should never fail.
+ if (fst1.NumArcs(s1) != fst2.NumArcs(s2)) {
+ FSTERROR() << "Equal: Inconsistent arc counts at state " << s1
+ << " (" << fst1.NumArcs(s1) << " != "
+ << fst2.NumArcs(s2) << ")";
+ return false;
+ }
+ if (fst1.NumInputEpsilons(s1) != fst2.NumInputEpsilons(s2)) {
+ FSTERROR() << "Equal: Inconsistent input epsilon counts at state " << s1
+ << " (" << fst1.NumInputEpsilons(s1) << " != "
+ << fst2.NumInputEpsilons(s2) << ")";
+ return false;
+ }
+ if (fst1.NumOutputEpsilons(s1) != fst2.NumOutputEpsilons(s2)) {
+ FSTERROR() << "Equal: Inconsistent output epsilon counts at state " << s1
+ << " (" << fst1.NumOutputEpsilons(s1) << " != "
+ << fst2.NumOutputEpsilons(s2) << ")";
+ }
+ siter1.Next();
+ siter2.Next();
+ }
+ return true;
+}
+
+} // namespace fst
+
+#endif // FST_LIB_EQUAL_H_
--- /dev/null
+// 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_LIB_EQUIVALENT_H_
+#define FST_LIB_EQUIVALENT_H_
+
+#include <algorithm>
+#include <deque>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/encode.h>
+#include <fst/push.h>
+#include <fst/union-find.h>
+#include <fst/vector-fst.h>
+
+
+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 <class Arc>
+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<MappedId>(s) << 1) + which_fst;
+ }
+
+ // Maps set ID to State ID.
+ static StateId UnMapState(MappedId id) {
+ return static_cast<StateId>((--id) >> 1);
+ }
+
+ // Convenience function: checks if state with MappedId s is final in
+ // acceptor fa.
+ static bool IsFinal(const Fst<Arc> &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<MappedId> *sets, MappedId id) {
+ const auto repr = sets->FindSet(id);
+ if (repr != kInvalidId) {
+ return repr;
+ } else {
+ sets->MakeSet(id);
+ return id;
+ }
+ }
+};
+
+template <class Arc>
+constexpr
+ typename EquivalenceUtil<Arc>::MappedId EquivalenceUtil<Arc>::kDeadState;
+
+template <class Arc>
+constexpr
+ typename EquivalenceUtil<Arc>::MappedId EquivalenceUtil<Arc>::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 <class Arc>
+bool Equivalent(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ double 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<Arc> efst1(fst1);
+ VectorFst<Arc> efst2(fst2);
+ Push(&efst1, REWEIGHT_TO_INITIAL, delta);
+ Push(&efst2, REWEIGHT_TO_INITIAL, delta);
+ ArcMap(&efst1, QuantizeMapper<Arc>(delta));
+ ArcMap(&efst2, QuantizeMapper<Arc>(delta));
+ EncodeMapper<Arc> mapper(kEncodeWeights | kEncodeLabels, ENCODE);
+ ArcMap(&efst1, &mapper);
+ ArcMap(&efst2, &mapper);
+ return Equivalent(efst1, efst2);
+ }
+ using Util = internal::EquivalenceUtil<Arc>;
+ 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<MappedId> 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<typename Arc::Label, std::pair<MappedId, MappedId>>;
+ Label2StatePairMap arc_pairs;
+ // Pairs of MappedId's to be processed, organized in a queue.
+ std::deque<std::pair<MappedId, MappedId>> q;
+ bool ret = true;
+ // Returns early if the start states differ w.r.t. finality.
+ if (Util::IsFinal(fst1, s1) != Util::IsFinal(fst2, s2)) ret = false;
+ // Main loop: explores the two acceptors in a breadth-first manner, updating
+ // the equivalence relation on the statesets. Loop invariant: each block of
+ // the states contains either final states only or non-final states only.
+ for (q.push_back(std::make_pair(s1, s2)); ret && !q.empty(); q.pop_front()) {
+ s1 = q.front().first;
+ s2 = q.front().second;
+ // Representatives of the equivalence classes of s1/s2.
+ const auto rep1 = Util::FindSet(&eq_classes, s1);
+ const auto rep2 = Util::FindSet(&eq_classes, s2);
+ if (rep1 != rep2) {
+ eq_classes.Union(rep1, rep2);
+ arc_pairs.clear();
+ // Copies outgoing arcs starting at s1 into the hash-table.
+ if (Util::kDeadState != s1) {
+ ArcIterator<Fst<Arc>> 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<Fst<Arc>> 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_LIB_EQUIVALENT_H_
--- /dev/null
+// 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_LIB_EXPANDED_FST_H_
+#define FST_LIB_EXPANDED_FST_H_
+
+#include <sys/types.h>
+#include <istream>
+#include <string>
+
+#include <fstream>
+
+#include <fst/fst.h>
+
+
+namespace fst {
+
+// A generic FST plus state count.
+template <class A>
+class ExpandedFst : public Fst<A> {
+ 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<Arc> *Copy(bool safe = false) const override = 0;
+
+ // Read an ExpandedFst from an input stream; return NULL on error.
+ static ExpandedFst<Arc> *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<Arc>::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<ExpandedFst<Arc> *>(fst);
+ }
+
+ // Read an ExpandedFst from a file; return NULL on error.
+ // Empty filename reads from standard input.
+ static ExpandedFst<Arc> *Read(const string &filename) {
+ if (!filename.empty()) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "ExpandedFst::Read: Can't open file: " << filename;
+ return nullptr;
+ }
+ return Read(strm, FstReadOptions(filename));
+ } else {
+ return Read(std::cin, FstReadOptions("standard input"));
+ }
+ }
+};
+
+namespace internal {
+
+// ExpandedFst<A> case - abstract methods.
+template <class Arc>
+inline typename Arc::Weight Final(const ExpandedFst<Arc> &fst,
+ typename Arc::StateId s) {
+ return fst.Final(s);
+}
+
+template <class Arc>
+inline ssize_t NumArcs(const ExpandedFst<Arc> &fst, typename Arc::StateId s) {
+ return fst.NumArcs(s);
+}
+
+template <class Arc>
+inline ssize_t NumInputEpsilons(const ExpandedFst<Arc> &fst,
+ typename Arc::StateId s) {
+ return fst.NumInputEpsilons(s);
+}
+
+template <class Arc>
+inline ssize_t NumOutputEpsilons(const ExpandedFst<Arc> &fst,
+ typename Arc::StateId s) {
+ return fst.NumOutputEpsilons(s);
+}
+
+} // namespace internal
+
+// A useful alias when using StdArc.
+using StdExpandedFst = ExpandedFst<StdArc>;
+
+// 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 Impl, class FST = ExpandedFst<typename Impl::Arc>>
+class ImplToExpandedFst : public ImplToFst<Impl, FST> {
+ public:
+ using Arc = typename FST::Arc;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using ImplToFst<Impl, FST>::operator=;
+
+ StateId NumStates() const override { return GetImpl()->NumStates(); }
+
+ protected:
+ using ImplToFst<Impl, FST>::GetImpl;
+
+ explicit ImplToExpandedFst(std::shared_ptr<Impl> impl)
+ : ImplToFst<Impl, FST>(impl) {}
+
+ ImplToExpandedFst(const ImplToExpandedFst<Impl, FST> &fst)
+ : ImplToFst<Impl, FST>(fst) {}
+
+ ImplToExpandedFst(const ImplToExpandedFst<Impl, FST> &fst, bool safe)
+ : ImplToFst<Impl, FST>(fst, safe) {}
+
+ static Impl *Read(std::istream &strm, const FstReadOptions &opts) {
+ return Impl::Read(strm, opts);
+ }
+
+ // Read FST implementation from a file; return NULL on error.
+ // Empty filename reads from standard input.
+ static Impl *Read(const string &filename) {
+ if (!filename.empty()) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "ExpandedFst::Read: Can't open file: " << filename;
+ return nullptr;
+ }
+ return Impl::Read(strm, FstReadOptions(filename));
+ } else {
+ return Impl::Read(std::cin, FstReadOptions("standard input"));
+ }
+ }
+};
+
+// Function to return the number of states in an FST, counting them
+// if necessary.
+template <class Arc>
+typename Arc::StateId CountStates(const Fst<Arc> &fst) {
+ if (fst.Properties(kExpanded, false)) {
+ const auto *efst = static_cast<const ExpandedFst<Arc> *>(&fst);
+ return efst->NumStates();
+ } else {
+ typename Arc::StateId nstates = 0;
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ ++nstates;
+ }
+ return nstates;
+ }
+}
+
+// Function to return the number of arcs in an FST.
+template <class Arc>
+typename Arc::StateId CountArcs(const Fst<Arc> &fst) {
+ size_t narcs = 0;
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ narcs += fst.NumArcs(siter.Value());
+ }
+ return narcs;
+}
+
+} // namespace fst
+
+#endif // FST_LIB_EXPANDED_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Expectation semiring as described by Jason Eisner:
+// See: doi=10.1.1.22.9398
+// Multiplex semiring operations and identities:
+// One: <One, Zero>
+// Zero: <Zero, Zero>
+// Plus: <a1, b1> + <a2, b2> = < (a1 + a2) , (b1 + b2) >
+// Times: <a1, b1> * <a2, b2> = < (a1 * a2) , [(a1 * b2) + (a2 * b1)] >
+// Division: Undefined (currently)
+//
+// Usually used to store the pair <probability, random_variable> so that
+// ShortestDistance[Fst<ArcTpl<ExpectationWeight<P, V>>>]
+// == < PosteriorProbability, Expected_Value[V] >
+
+#ifndef FST_LIB_EXPECTATION_WEIGHT_H_
+#define FST_LIB_EXPECTATION_WEIGHT_H_
+
+#include <string>
+
+#include <fst/pair-weight.h>
+#include <fst/product-weight.h>
+
+
+namespace fst {
+
+// X1 is usually a probability weight like LogWeight.
+// X2 is usually a random variable or vector (see SignedLogWeight or
+// SparsePowerWeight).
+//
+// If X1 is distinct from X2, it is required that there is an external product
+// between X1 and X2 and if both semriring are commutative, or left or right
+// semirings, then result must have those properties.
+template <class X1, class X2>
+class ExpectationWeight : public PairWeight<X1, X2> {
+ public:
+ using PairWeight<X1, X2>::Value1;
+ using PairWeight<X1, X2>::Value2;
+
+ using PairWeight<X1, X2>::Reverse;
+ using PairWeight<X1, X2>::Quantize;
+ using PairWeight<X1, X2>::Member;
+
+ using ReverseWeight =
+ ExpectationWeight<typename X1::ReverseWeight, typename X2::ReverseWeight>;
+
+ ExpectationWeight() : PairWeight<X1, X2>(Zero()) {}
+
+ ExpectationWeight(const ExpectationWeight &weight)
+ : PairWeight<X1, X2>(weight) {}
+
+ explicit ExpectationWeight(const PairWeight<X1, X2> &weight)
+ : PairWeight<X1, X2>(weight) {}
+
+ ExpectationWeight(const X1 &x1, const X2 &x2) : PairWeight<X1, X2>(x1, x2) {}
+
+ static const ExpectationWeight &Zero() {
+ static const ExpectationWeight zero(X1::Zero(), X2::Zero());
+ return zero;
+ }
+
+ static const ExpectationWeight &One() {
+ static const ExpectationWeight one(X1::One(), X2::Zero());
+ return one;
+ }
+
+ static const ExpectationWeight &NoWeight() {
+ static const ExpectationWeight no_weight(X1::NoWeight(), X2::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type = "expectation_" + X1::Type() + "_" + X2::Type();
+ return type;
+ }
+
+ PairWeight<X1, X2> Quantize(float delta = kDelta) const {
+ return ExpectationWeight(PairWeight<X1, X2>::Quantize());
+ }
+
+ ReverseWeight Reverse() const {
+ return ReverseWeight(PairWeight<X1, X2>::Reverse());
+ }
+
+ bool Member() const { return PairWeight<X1, X2>::Member(); }
+
+ static constexpr uint64 Properties() {
+ return X1::Properties() & X2::Properties() &
+ (kLeftSemiring | kRightSemiring | kCommutative | kIdempotent);
+ }
+};
+
+template <class X1, class X2>
+inline ExpectationWeight<X1, X2> Plus(const ExpectationWeight<X1, X2> &w1,
+ const ExpectationWeight<X1, X2> &w2) {
+ return ExpectationWeight<X1, X2>(Plus(w1.Value1(), w2.Value1()),
+ Plus(w1.Value2(), w2.Value2()));
+}
+
+template <class X1, class X2>
+inline ExpectationWeight<X1, X2> Times(const ExpectationWeight<X1, X2> &w1,
+ const ExpectationWeight<X1, X2> &w2) {
+ return ExpectationWeight<X1, X2>(
+ Times(w1.Value1(), w2.Value1()),
+ Plus(Times(w1.Value1(), w2.Value2()), Times(w1.Value2(), w2.Value1())));
+}
+
+template <class X1, class X2>
+inline ExpectationWeight<X1, X2> Divide(const ExpectationWeight<X1, X2> &w1,
+ const ExpectationWeight<X1, X2> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ FSTERROR() << "ExpectationWeight::Divide: Not implemented";
+ return ExpectationWeight<X1, X2>::NoWeight();
+}
+
+// This function object generates weights by calling the underlying generators
+// for the template weight types, like all other pair weight types. This is
+// intended primarily for testing.
+template <class X1, class X2>
+class WeightGenerate<ExpectationWeight<X1, X2>>
+ : public WeightGenerate<PairWeight<X1, X2>> {
+ public:
+ using Weight = ExpectationWeight<X1, X2>;
+ using Generate = WeightGenerate<PairWeight<X1, X2>>;
+
+ explicit WeightGenerate(bool allow_zero = true) : Generate(allow_zero) {}
+
+ Weight operator()() const { return Weight(Generate::operator()()); }
+};
+
+} // namespace fst
+
+#endif // FST_LIB_EXPECTATION_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Declarations of 'scriptable' versions of compression operations, that is,
+// those that can be called with FstClass-type arguments.
+
+#ifndef FST_EXTENSIONS_COMPRESS_COMPRESS_SCRIPT_H_
+#define FST_EXTENSIONS_COMPRESS_COMPRESS_SCRIPT_H_
+
+#include <utility>
+#include <vector>
+
+#include <fst/extensions/compress/compress.h>
+
+#include <fst/util.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+typedef args::Package<const FstClass &, const string &, const bool>
+ CompressArgs;
+
+template <class Arc>
+void Compress(CompressArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ const string &filename = args->arg2;
+ const bool gzip = args->arg3;
+
+ if (!fst::Compress(fst, filename, gzip)) FSTERROR() << "Compress: failed";
+}
+
+void Compress(const FstClass &fst, const string &filename, const bool gzip);
+
+typedef args::Package<const string &, MutableFstClass *, const bool>
+ DecompressArgs;
+
+template <class Arc>
+void Decompress(DecompressArgs *args) {
+ const string &filename = args->arg1;
+ MutableFst<Arc> *fst = args->arg2->GetMutableFst<Arc>();
+ const bool gzip = args->arg3;
+
+ if (!fst::Decompress(filename, fst, gzip))
+ FSTERROR() << "Decompress: failed";
+}
+
+void Decompress(const string &filename, MutableFstClass *fst, const bool gzip);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_EXTENSIONS_COMPRESS_COMPRESS_SCRIPT_H_
--- /dev/null
+// 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 <cstdio>
+
+#include <iostream>
+#include <queue>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fstream>
+#include <fst/extensions/compress/elias.h>
+#include <fst/extensions/compress/gzfile.h>
+
+#include <fst/encode.h>
+#include <fst/expanded-fst.h>
+#include <fst/fst.h>
+#include <fst/mutable-fst.h>
+#include <fst/statesort.h>
+
+namespace fst {
+
+// Identifies stream data as a vanilla compressed FST.
+static const int32 kCompressMagicNumber = 1858869554;
+// Identifies stream data as (probably) a Gzip file accidentally read from
+// a vanilla stream, without gzip support.
+static const int32 kGzipMagicNumber = 0x8b1f;
+// Selects the two most significant bytes.
+constexpr uint32 kGzipMask = 0xffffffff >> 16;
+
+// Lempel Ziv on data structure Edge, with a less than operator
+// EdgeLessThan and an equals operator EdgeEquals.
+// Edge has a value defaultedge which it never takes and
+// Edge is defined, it is initialized to defaultedge
+template <class Var, class Edge, class EdgeLessThan, class EdgeEquals>
+class LempelZiv {
+ public:
+ LempelZiv() : dict_number_(0) {
+ root_.current_number = dict_number_++;
+ root_.current_edge = default_edge_;
+ decode_vector_.push_back(std::make_pair(0, default_edge_));
+ }
+ // Encodes a vector input into output
+ void BatchEncode(const std::vector<Edge> &input,
+ std::vector<std::pair<Var, Edge>> *output);
+
+ // Decodes codedvector to output. Returns false if
+ // the index exceeds the size.
+ bool BatchDecode(const std::vector<std::pair<Var, Edge>> &input,
+ std::vector<Edge> *output);
+
+ // Decodes a single dictionary element. Returns false
+ // if the index exceeds the size.
+ bool SingleDecode(const Var &index, Edge *output) {
+ if (index >= decode_vector_.size()) {
+ LOG(ERROR) << "LempelZiv::SingleDecode: "
+ << "Index exceeded the dictionary size";
+ return false;
+ } else {
+ *output = decode_vector_[index].second;
+ return true;
+ }
+ }
+
+ ~LempelZiv() {
+ for (auto it = (root_.next_number).begin(); it != (root_.next_number).end();
+ ++it) {
+ CleanUp(it->second);
+ }
+ }
+ // Adds a single dictionary element while decoding
+ // void AddDictElement(const std::pair<Var, Edge> &newdict) {
+ // EdgeEquals InstEdgeEquals;
+ // if (InstEdgeEquals(newdict.second, default_edge_) != 1)
+ // decode_vector_.push_back(newdict);
+ // }
+
+ private:
+ // Node datastructure is used for encoding
+
+ struct Node {
+ Var current_number;
+ Edge current_edge;
+ std::map<Edge, Node *, EdgeLessThan> next_number;
+ };
+
+ void CleanUp(Node *temp) {
+ for (auto it = (temp->next_number).begin(); it != (temp->next_number).end();
+ ++it) {
+ CleanUp(it->second);
+ }
+ delete temp;
+ }
+ Node root_;
+ Var dict_number_;
+ // decode_vector_ is used for decoding
+ std::vector<std::pair<Var, Edge>> decode_vector_;
+ Edge default_edge_;
+};
+
+template <class Var, class Edge, class EdgeLessThan, class EdgeEquals>
+void LempelZiv<Var, Edge, EdgeLessThan, EdgeEquals>::BatchEncode(
+ const std::vector<Edge> &input, std::vector<std::pair<Var, Edge>> *output) {
+ for (typename std::vector<Edge>::const_iterator it = input.begin();
+ it != input.end(); ++it) {
+ Node *temp_node = &root_;
+ while (it != input.end()) {
+ auto next = (temp_node->next_number).find(*it);
+ if (next != (temp_node->next_number).end()) {
+ temp_node = next->second;
+ ++it;
+ } else {
+ break;
+ }
+ }
+ if (it == input.end() && temp_node->current_number != 0) {
+ output->push_back(
+ std::make_pair(temp_node->current_number, default_edge_));
+ } else if (it != input.end()) {
+ output->push_back(std::make_pair(temp_node->current_number, *it));
+ Node *new_node = new (Node);
+ new_node->current_number = dict_number_++;
+ new_node->current_edge = *it;
+ (temp_node->next_number)[*it] = new_node;
+ }
+ if (it == input.end()) break;
+ }
+}
+
+template <class Var, class Edge, class EdgeLessThan, class EdgeEquals>
+bool LempelZiv<Var, Edge, EdgeLessThan, EdgeEquals>::BatchDecode(
+ const std::vector<std::pair<Var, Edge>> &input, std::vector<Edge> *output) {
+ for (typename std::vector<std::pair<Var, Edge>>::const_iterator it =
+ input.begin();
+ it != input.end(); ++it) {
+ std::vector<Edge> temp_output;
+ EdgeEquals InstEdgeEquals;
+ if (InstEdgeEquals(it->second, default_edge_) != 1) {
+ decode_vector_.push_back(*it);
+ temp_output.push_back(it->second);
+ }
+ Var temp_integer = it->first;
+ if (temp_integer >= decode_vector_.size()) {
+ LOG(ERROR) << "LempelZiv::BatchDecode: "
+ << "Index exceeded the dictionary size";
+ return false;
+ } else {
+ while (temp_integer != 0) {
+ temp_output.push_back(decode_vector_[temp_integer].second);
+ temp_integer = decode_vector_[temp_integer].first;
+ }
+ std::reverse(temp_output.begin(), temp_output.end());
+ output->insert(output->end(), temp_output.begin(), temp_output.end());
+ }
+ }
+ return true;
+}
+
+// The main Compressor class
+template <class Arc>
+class Compressor {
+ public:
+ typedef typename Arc::StateId StateId;
+ typedef typename Arc::Label Label;
+ typedef typename Arc::Weight Weight;
+
+ Compressor() {}
+
+ // Compresses fst into a boolean vector code. Returns true on sucesss.
+ bool Compress(const Fst<Arc> &fst, std::ostream &strm);
+
+ // Decompresses the boolean vector into Fst. Returns true on sucesss.
+ bool Decompress(std::istream &strm, const string &source,
+ MutableFst<Arc> *fst);
+
+ // Finds the BFS order of a fst
+ void BfsOrder(const ExpandedFst<Arc> &fst, std::vector<StateId> *order);
+
+ // Preprocessing step to convert fst to a isomorphic fst
+ // Returns a preproccess fst and a dictionary
+ void Preprocess(const Fst<Arc> &fst, MutableFst<Arc> *preprocessedfst,
+ EncodeMapper<Arc> *encoder);
+
+ // Performs Lempel Ziv and outputs a stream of integers
+ // and sends it to a stream
+ void EncodeProcessedFst(const ExpandedFst<Arc> &fst, std::ostream &strm);
+
+ // Decodes fst from the stream
+ void DecodeProcessedFst(const std::vector<StateId> &input,
+ MutableFst<Arc> *fst, bool unweighted);
+
+ // Converts buffer_code_ to uint8 and writes to a stream.
+
+ // Writes the boolean file to the stream
+ void WriteToStream(std::ostream &strm);
+
+ // Writes the weights to the stream
+ void WriteWeight(const std::vector<Weight> &input, std::ostream &strm);
+
+ void ReadWeight(std::istream &strm, std::vector<Weight> *output);
+
+ // Same as fst::Decode without the line RmFinalEpsilon(fst)
+ void DecodeForCompress(MutableFst<Arc> *fst, const EncodeMapper<Arc> &mapper);
+
+ // Updates the buffer_code_
+ template <class CVar>
+ void WriteToBuffer(CVar input) {
+ std::vector<bool> current_code;
+ Elias<CVar>::DeltaEncode(input, ¤t_code);
+ if (!buffer_code_.empty()) {
+ buffer_code_.insert(buffer_code_.end(), current_code.begin(),
+ current_code.end());
+ } else {
+ buffer_code_.assign(current_code.begin(), current_code.end());
+ }
+ }
+
+ private:
+ struct LZLabel {
+ LZLabel() : label(0) {}
+ Label label;
+ };
+
+ struct LabelLessThan {
+ bool operator()(const LZLabel &labelone, const LZLabel &labeltwo) const {
+ return labelone.label < labeltwo.label;
+ }
+ };
+
+ struct LabelEquals {
+ bool operator()(const LZLabel &labelone, const LZLabel &labeltwo) const {
+ return labelone.label == labeltwo.label;
+ }
+ };
+
+ struct Transition {
+ Transition() : nextstate(0), label(0), weight(Weight::Zero()) {}
+
+ StateId nextstate;
+ Label label;
+ Weight weight;
+ };
+
+ struct TransitionLessThan {
+ bool operator()(const Transition &transition_one,
+ const Transition &transition_two) const {
+ if (transition_one.nextstate == transition_two.nextstate)
+ return transition_one.label < transition_two.label;
+ else
+ return transition_one.nextstate < transition_two.nextstate;
+ }
+ } transition_less_than;
+
+ struct TransitionEquals {
+ bool operator()(const Transition &transition_one,
+ const Transition &transition_two) const {
+ return transition_one.nextstate == transition_two.nextstate &&
+ transition_one.label == transition_two.label;
+ }
+ } transition_equals;
+
+ struct OldDictCompare {
+ bool operator()(const std::pair<StateId, Transition> &pair_one,
+ const std::pair<StateId, Transition> &pair_two) const {
+ if ((pair_one.second).nextstate == (pair_two.second).nextstate)
+ return (pair_one.second).label < (pair_two.second).label;
+ else
+ return (pair_one.second).nextstate < (pair_two.second).nextstate;
+ }
+ } old_dict_compare;
+
+ std::vector<bool> buffer_code_;
+ std::vector<Weight> arc_weight_;
+ std::vector<Weight> final_weight_;
+};
+
+template <class Arc>
+inline void Compressor<Arc>::DecodeForCompress(
+ MutableFst<Arc> *fst, const EncodeMapper<Arc> &mapper) {
+ ArcMap(fst, EncodeMapper<Arc>(mapper, DECODE));
+ fst->SetInputSymbols(mapper.InputSymbols());
+ fst->SetOutputSymbols(mapper.OutputSymbols());
+}
+
+// Compressor::BfsOrder
+template <class Arc>
+void Compressor<Arc>::BfsOrder(const ExpandedFst<Arc> &fst,
+ std::vector<StateId> *order) {
+ Arc arc;
+ StateId bfs_visit_number = 0;
+ std::queue<StateId> states_queue;
+ order->assign(fst.NumStates(), kNoStateId);
+ states_queue.push(fst.Start());
+ (*order)[fst.Start()] = bfs_visit_number++;
+ while (!states_queue.empty()) {
+ for (ArcIterator<Fst<Arc>> aiter(fst, states_queue.front()); !aiter.Done();
+ aiter.Next()) {
+ arc = aiter.Value();
+ StateId nextstate = arc.nextstate;
+ if ((*order)[nextstate] == kNoStateId) {
+ (*order)[nextstate] = bfs_visit_number++;
+ states_queue.push(nextstate);
+ }
+ }
+ states_queue.pop();
+ }
+
+ // If the FST is unconnected, then the following
+ // code finds them
+ while (bfs_visit_number < fst.NumStates()) {
+ int unseen_state = 0;
+ for (unseen_state = 0; unseen_state < fst.NumStates(); ++unseen_state) {
+ if ((*order)[unseen_state] == kNoStateId) break;
+ }
+ states_queue.push(unseen_state);
+ (*order)[unseen_state] = bfs_visit_number++;
+ while (!states_queue.empty()) {
+ for (ArcIterator<Fst<Arc>> aiter(fst, states_queue.front());
+ !aiter.Done(); aiter.Next()) {
+ arc = aiter.Value();
+ StateId nextstate = arc.nextstate;
+ if ((*order)[nextstate] == kNoStateId) {
+ (*order)[nextstate] = bfs_visit_number++;
+ states_queue.push(nextstate);
+ }
+ }
+ states_queue.pop();
+ }
+ }
+}
+
+template <class Arc>
+void Compressor<Arc>::Preprocess(const Fst<Arc> &fst,
+ MutableFst<Arc> *preprocessedfst,
+ EncodeMapper<Arc> *encoder) {
+ std::vector<StateId> order;
+ *preprocessedfst = fst;
+ // Relabels the edges and develops a dictionary
+ Encode(preprocessedfst, encoder);
+ // Finds the BFS sorting order of the fst
+ BfsOrder(*preprocessedfst, &order);
+ // Reorders the states according to the BFS order
+ StateSort(preprocessedfst, order);
+}
+
+template <class Arc>
+void Compressor<Arc>::EncodeProcessedFst(const ExpandedFst<Arc> &fst,
+ std::ostream &strm) {
+ std::vector<StateId> output;
+ LempelZiv<StateId, LZLabel, LabelLessThan, LabelEquals> dict_new;
+ LempelZiv<StateId, Transition, TransitionLessThan, TransitionEquals> dict_old;
+ std::vector<LZLabel> current_new_input;
+ std::vector<Transition> current_old_input;
+ std::vector<std::pair<StateId, LZLabel>> current_new_output;
+ std::vector<std::pair<StateId, Transition>> current_old_output;
+ std::vector<StateId> final_states;
+
+ StateId number_of_states = fst.NumStates();
+
+ StateId seen_states = 0;
+ // Adding the number of states
+ WriteToBuffer<StateId>(number_of_states);
+
+ for (StateId state = 0; state < number_of_states; ++state) {
+ current_new_input.clear();
+ current_old_input.clear();
+ current_new_output.clear();
+ current_old_output.clear();
+ if (state > seen_states) ++seen_states;
+
+ // Collecting the final states
+ if (fst.Final(state) != Weight::Zero()) {
+ final_states.push_back(state);
+ final_weight_.push_back(fst.Final(state));
+ }
+
+ // Reading the states
+ for (ArcIterator<Fst<Arc>> aiter(fst, state); !aiter.Done();
+ aiter.Next()) {
+ Arc arc = aiter.Value();
+ if (arc.nextstate > seen_states) { // RILEY: > or >= ?
+ ++seen_states;
+ LZLabel temp_label;
+ temp_label.label = arc.ilabel;
+ arc_weight_.push_back(arc.weight);
+ current_new_input.push_back(temp_label);
+ } else {
+ Transition temp_transition;
+ temp_transition.nextstate = arc.nextstate;
+ temp_transition.label = arc.ilabel;
+ temp_transition.weight = arc.weight;
+ current_old_input.push_back(temp_transition);
+ }
+ }
+ // Adding new states
+ dict_new.BatchEncode(current_new_input, ¤t_new_output);
+ WriteToBuffer<StateId>(current_new_output.size());
+
+ for (auto it = current_new_output.begin(); it != current_new_output.end();
+ ++it) {
+ WriteToBuffer<StateId>(it->first);
+ WriteToBuffer<Label>((it->second).label);
+ }
+ // Adding old states by sorting and using difference coding
+ std::sort(current_old_input.begin(), current_old_input.end(),
+ transition_less_than);
+ for (auto it = current_old_input.begin(); it != current_old_input.end();
+ ++it) {
+ arc_weight_.push_back(it->weight);
+ }
+ dict_old.BatchEncode(current_old_input, ¤t_old_output);
+ std::vector<StateId> dict_old_temp;
+ std::vector<Transition> transition_old_temp;
+ for (auto it = current_old_output.begin(); it != current_old_output.end();
+ ++it) {
+ dict_old_temp.push_back(it->first);
+ transition_old_temp.push_back(it->second);
+ }
+ if (!transition_old_temp.empty()) {
+ if ((transition_old_temp.back()).nextstate == 0 &&
+ (transition_old_temp.back()).label == 0) {
+ transition_old_temp.pop_back();
+ }
+ }
+ std::sort(dict_old_temp.begin(), dict_old_temp.end());
+ std::sort(transition_old_temp.begin(), transition_old_temp.end(),
+ transition_less_than);
+
+ WriteToBuffer<StateId>(dict_old_temp.size());
+ if (dict_old_temp.size() != transition_old_temp.size())
+ WriteToBuffer<int>(1);
+ else
+ WriteToBuffer<int>(0);
+
+ StateId previous;
+ if (!dict_old_temp.empty()) {
+ WriteToBuffer<StateId>(dict_old_temp.front());
+ previous = dict_old_temp.front();
+ }
+ if (dict_old_temp.size() > 1) {
+ for (auto it = dict_old_temp.begin() + 1; it != dict_old_temp.end();
+ ++it) {
+ WriteToBuffer<StateId>(*it - previous);
+ previous = *it;
+ }
+ }
+ if (!transition_old_temp.empty()) {
+ WriteToBuffer<StateId>((transition_old_temp.front()).nextstate);
+ previous = (transition_old_temp.front()).nextstate;
+ WriteToBuffer<Label>((transition_old_temp.front()).label);
+ }
+ if (transition_old_temp.size() > 1) {
+ for (auto it = transition_old_temp.begin() + 1;
+ it != transition_old_temp.end(); ++it) {
+ WriteToBuffer<StateId>(it->nextstate - previous);
+ previous = it->nextstate;
+ WriteToBuffer<StateId>(it->label);
+ }
+ }
+ }
+ // Adding final states
+ WriteToBuffer<StateId>(final_states.size());
+ if (!final_states.empty()) {
+ for (auto it = final_states.begin(); it != final_states.end(); ++it) {
+ WriteToBuffer<StateId>(*it);
+ }
+ }
+ WriteToStream(strm);
+ uint8 unweighted = (fst.Properties(kUnweighted, true) == kUnweighted);
+ WriteType(strm, unweighted);
+ if (unweighted == 0) {
+ WriteWeight(arc_weight_, strm);
+ WriteWeight(final_weight_, strm);
+ }
+}
+
+template <class Arc>
+void Compressor<Arc>::DecodeProcessedFst(const std::vector<StateId> &input,
+ MutableFst<Arc> *fst,
+ bool unweighted) {
+ LempelZiv<StateId, LZLabel, LabelLessThan, LabelEquals> dict_new;
+ LempelZiv<StateId, Transition, TransitionLessThan, TransitionEquals> dict_old;
+ std::vector<std::pair<StateId, LZLabel>> current_new_input;
+ std::vector<std::pair<StateId, Transition>> current_old_input;
+ std::vector<LZLabel> current_new_output;
+ std::vector<Transition> current_old_output;
+ std::vector<std::pair<StateId, Transition>> actual_old_dict_numbers;
+ std::vector<Transition> actual_old_dict_transitions;
+ auto arc_weight_it = arc_weight_.begin();
+ Transition default_transition;
+ StateId seen_states = 1;
+
+ // Adding states
+
+ for (StateId temp_integer = 0; temp_integer < input.front(); ++temp_integer) {
+ fst->AddState();
+ }
+
+ fst->SetStart(0);
+ typename std::vector<StateId>::const_iterator main_it = input.begin();
+ ++main_it;
+
+ for (StateId current_state = 0; current_state < input.front();
+ ++current_state) {
+ if (current_state >= seen_states) ++seen_states;
+ current_new_input.clear();
+ current_new_output.clear();
+ current_old_input.clear();
+ current_old_output.clear();
+ // New states
+ StateId current_number_new_elements = *main_it;
+ ++main_it;
+ for (StateId new_integer = 0; new_integer < current_number_new_elements;
+ ++new_integer) {
+ std::pair<StateId, LZLabel> temp_new_dict_element;
+ temp_new_dict_element.first = *main_it;
+ ++main_it;
+ LZLabel temp_label;
+ temp_label.label = *main_it;
+ ++main_it;
+ temp_new_dict_element.second = temp_label;
+ current_new_input.push_back(temp_new_dict_element);
+ }
+ dict_new.BatchDecode(current_new_input, ¤t_new_output);
+ for (auto it = current_new_output.begin(); it != current_new_output.end();
+ ++it) {
+ if (!unweighted) {
+ fst->AddArc(current_state,
+ Arc(it->label, it->label, *arc_weight_it, seen_states++));
+ ++arc_weight_it;
+ } else {
+ fst->AddArc(current_state,
+ Arc(it->label, it->label, Weight::One(), seen_states++));
+ }
+ }
+
+ // Old states dictionary
+ StateId current_number_old_elements = *main_it;
+ ++main_it;
+ StateId is_zero_removed = *main_it;
+ ++main_it;
+ StateId previous = 0;
+ actual_old_dict_numbers.clear();
+ for (StateId new_integer = 0; new_integer < current_number_old_elements;
+ ++new_integer) {
+ std::pair<StateId, Transition> pair_temp_transition;
+ if (new_integer == 0) {
+ pair_temp_transition.first = *main_it;
+ previous = *main_it;
+ } else {
+ pair_temp_transition.first = *main_it + previous;
+ previous = pair_temp_transition.first;
+ }
+ ++main_it;
+ Transition temp_test;
+ if (!dict_old.SingleDecode(pair_temp_transition.first, &temp_test)) {
+ FSTERROR() << "Compressor::Decode: failed";
+ fst->DeleteStates();
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ pair_temp_transition.second = temp_test;
+ actual_old_dict_numbers.push_back(pair_temp_transition);
+ }
+
+ // Reordering the dictionary elements
+ std::sort(actual_old_dict_numbers.begin(), actual_old_dict_numbers.end(),
+ old_dict_compare);
+
+ // Transitions
+ previous = 0;
+ actual_old_dict_transitions.clear();
+
+ for (StateId new_integer = 0;
+ new_integer < current_number_old_elements - is_zero_removed;
+ ++new_integer) {
+ Transition temp_transition;
+ if (new_integer == 0) {
+ temp_transition.nextstate = *main_it;
+ previous = *main_it;
+ } else {
+ temp_transition.nextstate = *main_it + previous;
+ previous = temp_transition.nextstate;
+ }
+ ++main_it;
+ temp_transition.label = *main_it;
+ ++main_it;
+ actual_old_dict_transitions.push_back(temp_transition);
+ }
+
+ if (is_zero_removed == 1) {
+ actual_old_dict_transitions.push_back(default_transition);
+ }
+
+ auto trans_it = actual_old_dict_transitions.begin();
+ auto dict_it = actual_old_dict_numbers.begin();
+
+ while (trans_it != actual_old_dict_transitions.end() &&
+ dict_it != actual_old_dict_numbers.end()) {
+ if (dict_it->first == 0) {
+ ++dict_it;
+ } else {
+ std::pair<StateId, Transition> temp_pair;
+ if (transition_equals(*trans_it, default_transition) == 1) {
+ temp_pair.first = dict_it->first;
+ temp_pair.second = default_transition;
+ ++dict_it;
+ } else if (transition_less_than(dict_it->second, *trans_it) == 1) {
+ temp_pair.first = dict_it->first;
+ temp_pair.second = *trans_it;
+ ++dict_it;
+ } else {
+ temp_pair.first = 0;
+ temp_pair.second = *trans_it;
+ }
+ ++trans_it;
+ current_old_input.push_back(temp_pair);
+ }
+ }
+ while (trans_it != actual_old_dict_transitions.end()) {
+ std::pair<StateId, Transition> temp_pair;
+ temp_pair.first = 0;
+ temp_pair.second = *trans_it;
+ ++trans_it;
+ current_old_input.push_back(temp_pair);
+ }
+
+ // Adding old elements in the dictionary
+ if (!dict_old.BatchDecode(current_old_input, ¤t_old_output)) {
+ FSTERROR() << "Compressor::Decode: Failed";
+ fst->DeleteStates();
+ fst->SetProperties(kError, kError);
+ return;
+ }
+
+ for (auto it = current_old_output.begin(); it != current_old_output.end();
+ ++it) {
+ if (!unweighted) {
+ fst->AddArc(current_state,
+ Arc(it->label, it->label, *arc_weight_it, it->nextstate));
+ ++arc_weight_it;
+ } else {
+ fst->AddArc(current_state,
+ Arc(it->label, it->label, Weight::One(), it->nextstate));
+ }
+ }
+ }
+ // Adding the final states
+ StateId number_of_final_states = *main_it;
+ if (number_of_final_states > 0) {
+ ++main_it;
+ for (StateId temp_int = 0; temp_int < number_of_final_states; ++temp_int) {
+ if (!unweighted) {
+ fst->SetFinal(*main_it, final_weight_[temp_int]);
+ } else {
+ fst->SetFinal(*main_it, Weight(0));
+ }
+ ++main_it;
+ }
+ }
+}
+
+template <class Arc>
+void Compressor<Arc>::ReadWeight(std::istream &strm,
+ std::vector<Weight> *output) {
+ int64 size;
+ Weight weight;
+ ReadType(strm, &size);
+ for (int64 i = 0; i < size; ++i) {
+ weight.Read(strm);
+ output->push_back(weight);
+ }
+}
+
+template <class Arc>
+bool Compressor<Arc>::Decompress(std::istream &strm, const string &source,
+ MutableFst<Arc> *fst) {
+ fst->DeleteStates();
+ int32 magic_number = 0;
+ ReadType(strm, &magic_number);
+ if (magic_number != kCompressMagicNumber) {
+ LOG(ERROR) << "Decompress: Bad compressed Fst: " << source;
+ // If the most significant two bytes of the magic number match the
+ // gzip magic number, then we are probably reading a gzip file as an
+ // ordinary stream.
+ if ((magic_number & kGzipMask) == kGzipMagicNumber) {
+ LOG(ERROR) << "Decompress: Fst appears to be compressed with Gzip, but "
+ "gzip decompression was not requested. Try with "
+ "the --gzip flag"
+ ".";
+ }
+ return false;
+ }
+ std::unique_ptr<EncodeMapper<Arc>> encoder(
+ EncodeMapper<Arc>::Read(strm, "Decoding", DECODE));
+ std::vector<bool> bool_code;
+ uint8 block;
+ uint8 msb = 128;
+ int64 data_size;
+ ReadType(strm, &data_size);
+ for (int64 i = 0; i < data_size; ++i) {
+ ReadType(strm, &block);
+ for (int j = 0; j < 8; ++j) {
+ uint8 temp = msb & block;
+ if (temp == 128)
+ bool_code.push_back(1);
+ else
+ bool_code.push_back(0);
+ block = block << 1;
+ }
+ }
+ std::vector<StateId> int_code;
+ Elias<StateId>::BatchDecode(bool_code, &int_code);
+ bool_code.clear();
+ uint8 unweighted;
+ ReadType(strm, &unweighted);
+ if (unweighted == 0) {
+ ReadWeight(strm, &arc_weight_);
+ ReadWeight(strm, &final_weight_);
+ }
+ DecodeProcessedFst(int_code, fst, unweighted);
+ DecodeForCompress(fst, *encoder);
+ return !fst->Properties(kError, false);
+}
+
+template <class Arc>
+void Compressor<Arc>::WriteWeight(const std::vector<Weight> &input,
+ std::ostream &strm) {
+ int64 size = input.size();
+ WriteType(strm, size);
+ for (typename std::vector<Weight>::const_iterator it = input.begin();
+ it != input.end(); ++it) {
+ it->Write(strm);
+ }
+}
+
+template <class Arc>
+void Compressor<Arc>::WriteToStream(std::ostream &strm) {
+ while (buffer_code_.size() % 8 != 0) buffer_code_.push_back(1);
+ int64 data_size = buffer_code_.size() / 8;
+ WriteType(strm, data_size);
+ std::vector<bool>::const_iterator it;
+ int64 i;
+ uint8 block;
+ for (it = buffer_code_.begin(), i = 0; it != buffer_code_.end(); ++it, ++i) {
+ if (i % 8 == 0) {
+ if (i > 0) WriteType(strm, block);
+ block = 0;
+ } else {
+ block = block << 1;
+ }
+ block |= *it;
+ }
+ WriteType(strm, block);
+}
+
+template <class Arc>
+bool Compressor<Arc>::Compress(const Fst<Arc> &fst, std::ostream &strm) {
+ VectorFst<Arc> processedfst;
+ EncodeMapper<Arc> encoder(kEncodeLabels, ENCODE);
+ Preprocess(fst, &processedfst, &encoder);
+ WriteType(strm, kCompressMagicNumber);
+ encoder.Write(strm, "encoder stream");
+ EncodeProcessedFst(processedfst, strm);
+ return true;
+}
+
+// Convenience functions that call the compressor and decompressor.
+
+template <class Arc>
+void Compress(const Fst<Arc> &fst, std::ostream &strm) {
+ Compressor<Arc> comp;
+ comp.Compress(fst, strm);
+}
+
+// Returns true on success.
+template <class Arc>
+bool Compress(const Fst<Arc> &fst, const string &file_name,
+ const bool gzip = false) {
+ if (gzip) {
+ if (file_name.empty()) {
+ std::stringstream strm;
+ Compress(fst, strm);
+ OGzFile gzfile(fileno(stdout));
+ gzfile.write(strm);
+ if (!gzfile) {
+ LOG(ERROR) << "Compress: Can't write to file: stdout";
+ return false;
+ }
+ } else {
+ std::stringstream strm;
+ Compress(fst, strm);
+ OGzFile gzfile(file_name.c_str());
+ if (!gzfile) {
+ LOG(ERROR) << "Compress: Can't open file: " << file_name;
+ return false;
+ }
+ gzfile.write(strm);
+ if (!gzfile) {
+ LOG(ERROR) << "Compress: Can't write to file: " << file_name;
+ return false;
+ }
+ }
+ } else if (file_name.empty()) {
+ Compress(fst, std::cout);
+ } else {
+ std::ofstream strm(file_name.c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "Compress: Can't open file: " << file_name;
+ return false;
+ }
+ Compress(fst, strm);
+ }
+ return true;
+}
+
+template <class Arc>
+void Decompress(std::istream &strm, const string &source,
+ MutableFst<Arc> *fst) {
+ Compressor<Arc> comp;
+ comp.Decompress(strm, source, fst);
+}
+
+// Returns true on success.
+template <class Arc>
+bool Decompress(const string &file_name, MutableFst<Arc> *fst,
+ const bool gzip = false) {
+ if (gzip) {
+ if (file_name.empty()) {
+ IGzFile gzfile(fileno(stdin));
+ Decompress(*gzfile.read(), "stdin", fst);
+ if (!gzfile) {
+ LOG(ERROR) << "Decompress: Can't read from file: stdin";
+ return false;
+ }
+ } else {
+ IGzFile gzfile(file_name.c_str());
+ if (!gzfile) {
+ LOG(ERROR) << "Decompress: Can't open file: " << file_name;
+ return false;
+ }
+ Decompress(*gzfile.read(), file_name, fst);
+ if (!gzfile) {
+ LOG(ERROR) << "Decompress: Can't read from file: " << file_name;
+ return false;
+ }
+ }
+ } else if (file_name.empty()) {
+ Decompress(std::cin, "stdin", fst);
+ } else {
+ std::ifstream strm(file_name.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "Decompress: Can't open file: " << file_name;
+ return false;
+ }
+ Decompress(strm, file_name, fst);
+ }
+ return true;
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_COMPRESS_COMPRESS_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Compresses and decompresses unweighted FSTs.
+
+#ifndef FST_EXTENSIONS_COMPRESS_ELIAS_H_
+#define FST_EXTENSIONS_COMPRESS_ELIAS_H_
+
+#include <stack>
+#include <vector>
+
+#include <fst/compat.h>
+namespace fst {
+
+template <class Var>
+class Elias {
+ public:
+ // Gamma encoding is a subroutine for Delta encoding
+ static void GammaEncode(const Var &input, std::vector<bool> *code);
+
+ // Elias Delta encoding for a single integer
+ static void DeltaEncode(const Var &input, std::vector<bool> *code);
+
+ // Batch decoding of a set of integers
+ static void BatchDecode(const std::vector<bool> &input,
+ std::vector<Var> *output);
+};
+
+template <class Var>
+void Elias<Var>::GammaEncode(const Var &input, std::vector<bool> *code) {
+ Var input_copy = input;
+ std::stack<bool> reverse_code;
+ while (input_copy > 0) {
+ reverse_code.push(input_copy % 2);
+ input_copy = input_copy / 2;
+ }
+ for (Var auxvar = 0; auxvar < reverse_code.size() - 1; auxvar++)
+ code->push_back(0);
+ while (reverse_code.empty() != 1) {
+ code->push_back(reverse_code.top());
+ reverse_code.pop();
+ }
+}
+template <class Var>
+void Elias<Var>::DeltaEncode(const Var &input, std::vector<bool> *code) {
+ Var input_copy = input + 1;
+ std::stack<bool> reverse_remainder;
+ Var auxvar = 0;
+ while (input_copy != 0) {
+ reverse_remainder.push(input_copy % 2);
+ input_copy = input_copy / 2;
+ auxvar = auxvar + 1;
+ }
+ GammaEncode(auxvar, code);
+ reverse_remainder.pop();
+ while (reverse_remainder.empty() != 1) {
+ code->push_back(reverse_remainder.top());
+ reverse_remainder.pop();
+ }
+}
+
+template <class Var>
+void Elias<Var>::BatchDecode(const std::vector<bool> &input,
+ std::vector<Var> *output) {
+ Var lead_zeros = 0;
+ Var remainder_bits = 0;
+ Var current_word = 1;
+ Var value = 1;
+ std::vector<bool>::const_iterator it = input.begin();
+ while (it != input.end()) {
+ lead_zeros = 0;
+ remainder_bits = 0;
+ current_word = 1;
+ value = 1;
+ while (*it != 1) {
+ it++;
+ lead_zeros++;
+ }
+ it++;
+ while (lead_zeros > 0) {
+ lead_zeros--;
+ current_word = 2 * current_word + *it;
+ it++;
+ }
+ current_word--;
+ while (current_word > 0) {
+ value = 2 * value + *it;
+ current_word--;
+ it++;
+ }
+ output->push_back(value - 1);
+ }
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_COMPRESS_ELIAS_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Resource handles for gzip files written to or read from stringstreams. These
+// are necessary to provide the compression routines with streams reading from
+// or writing to compressed files (or the UNIX standard streams), and are not
+// intended for general use.
+
+#ifndef FST_EXTENSIONS_COMPRESS_GZFILE_H_
+#define FST_EXTENSIONS_COMPRESS_GZFILE_H_
+
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include <fst/compat.h>
+#include <fst/fst.h>
+#include <zlib.h>
+
+using std::stringstream;
+using std::unique_ptr;
+
+namespace fst {
+
+// Gives the zlib gzFile type an OO-like interface. String inputs are all
+// C-style strings. The caller is responsible to get the file modes appropriate
+// for the IO methods being called, and for opening the file descriptors
+// if that constructor is used. The ! operator can be used to check for errors
+// after construction or read/writing.
+class GzFile {
+ public:
+ GzFile(const char *filename, const char *mode)
+ : gzfile_(gzopen(filename, mode)), error_(check_handle()) {
+ }
+ // The caller is responsible to ensure the corresponding FD is open and has
+ // the needed modes ("r" for reading, "w" or "a" for writing).
+ explicit GzFile(const int fd, const char *mode)
+ : gzfile_(gzdopen(fd, mode)), error_(check_handle()), close_me_(false) {
+ }
+ // If the instance was constructed from an FD, flush the buffer; otherwise,
+ // close the file, which flushes the buffer as a side-effect.
+ ~GzFile() { close_me_ ? gzclose(gzfile_) : gzflush(gzfile_, Z_FINISH); }
+
+ inline bool operator!() const { return error_; }
+
+ // Returns false on EOF and sets error if short read does not reach an EOF.
+ int read(void *buf, unsigned int size) {
+ int bytes_read = gzread(gzfile_, buf, size);
+ if ((bytes_read < size) && !gzeof(gzfile_)) error_ = true;
+ return bytes_read;
+ }
+
+ // Sets error on short writes.
+ void write(const char *buf, unsigned int size) {
+ if (gzwrite(gzfile_, buf, size) != size) error_ = true;
+ }
+
+ private:
+ // gzopen and gzdopen signal failure by returning null.
+ bool check_handle() { return gzfile_ == nullptr; }
+
+ gzFile gzfile_ = nullptr;
+ bool error_ = false;
+ bool close_me_ = false;
+};
+
+// Resource handle for writing stringstream to GzFile.
+class OGzFile {
+ public:
+ explicit OGzFile(const string &filename) : OGzFile(filename.c_str()) {}
+ explicit OGzFile(const char *filename) : gz_(GzFile(filename, mode_)) {}
+ explicit OGzFile(const int fd) : gz_(GzFile(fd, mode_)) {}
+ inline bool operator!() const { return !gz_; }
+
+ void write(const stringstream &ssbuf) {
+ string sbuf = ssbuf.str();
+ gz_.write(sbuf.data(), sbuf.size());
+ }
+
+ private:
+ GzFile gz_;
+ static constexpr auto &mode_ = "wb";
+};
+
+// Resource handle for reading stringstream from GzFile.
+class IGzFile {
+ public:
+ explicit IGzFile(const string &filename) : IGzFile(filename.c_str()) {}
+ explicit IGzFile(const char *filename) : gz_(GzFile(filename, mode_)) {}
+ explicit IGzFile(const int fd) : gz_(GzFile(fd, mode_)) {}
+
+ inline bool operator!() const { return !gz_; }
+
+ // This is a great case for "move", but GCC 4 is missing the C+11 standard
+ // move constructor for stringstream, so a unique_ptr is the next best thing.
+ unique_ptr<stringstream> read() {
+ char buf[bufsize_];
+ unique_ptr<stringstream> sstrm(new stringstream);
+ // We always read at least once, and the result of the last read is always
+ // pushed onto the stringstream. We use the "write" member because << onto
+ // a stringstream stops at the null byte, which might be data!
+ int bytes_read;
+ while ((bytes_read = gz_.read(buf, bufsize_)) == bufsize_)
+ sstrm->write(buf, bufsize_);
+ sstrm->write(buf, bytes_read);
+ return sstrm;
+ }
+
+ private:
+ GzFile gz_;
+ static constexpr auto &mode_ = "rb";
+ // This is the same size as the default internal buffer for zlib.
+ static const size_t bufsize_ = 8192;
+};
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_COMPRESS_GZFILE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Generates a random FST according to a class-specific transition model.
+
+#ifndef FST_EXTENSIONS_COMPRESS_RANDMOD_H_
+#define FST_EXTENSIONS_COMPRESS_RANDMOD_H_
+
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/mutable-fst.h>
+
+namespace fst {
+
+template <class Arc, class G>
+class RandMod {
+ public:
+ typedef typename Arc::StateId StateId;
+ typedef typename Arc::Label Label;
+ typedef typename Arc::Weight Weight;
+
+ // Generates random FST with 'nstates' with 'nclasses' in the probability
+ // generation model, and 'nlabels' in the alphabet. If 'trans' = true, then
+ // a transducer is generated; iff 'generate_' is non-null, the output is
+ // randomly weighted.
+ RandMod(StateId nstates, StateId nclasses, Label nlabels, bool trans,
+ const G *generate)
+ : nstates_(nstates),
+ nclasses_(nclasses),
+ nlabels_(nlabels),
+ trans_(trans),
+ generate_(generate) {
+ for (StateId s = 0; s < nstates; ++s) {
+ classes_.push_back(rand() % nclasses); // NOLINT
+ }
+ }
+
+ // Generates a random FST according to a class-specific transition model
+ void Generate(StdMutableFst *fst) {
+ StateId start = rand() % nstates_; // NOLINT
+ fst->DeleteStates();
+ for (StateId s = 0; s < nstates_; ++s) {
+ fst->AddState();
+ if (s == start) fst->SetStart(start);
+ for (StateId n = 0; n <= nstates_; ++n) {
+ Arc arc;
+ StateId d = n == nstates_ ? kNoStateId : n;
+ if (!RandArc(s, d, &arc)) continue;
+ if (d == kNoStateId) { // A super-final transition?
+ fst->SetFinal(s, arc.weight);
+ } else {
+ fst->AddArc(s, arc);
+ }
+ }
+ }
+ }
+
+ private:
+ // Generates a transition from s to d. If d == kNoStateId, a superfinal
+ // transition is generated. Returns false if no transition generated.
+ bool RandArc(StateId s, StateId d, Arc *arc) {
+ StateId sclass = classes_[s];
+ StateId dclass = d != kNoStateId ? classes_[d] : 0;
+
+ int r = sclass + dclass + 2;
+ if ((rand() % r) != 0) // NOLINT
+ return false;
+
+ arc->nextstate = d;
+
+ Label ilabel = kNoLabel;
+ Label olabel = kNoLabel;
+ if (d != kNoStateId) {
+ ilabel = (dclass % nlabels_) + 1;
+ if (trans_)
+ olabel = (sclass % nlabels_) + 1;
+ else
+ olabel = ilabel;
+ }
+
+ Weight weight = Weight::One();
+ if (generate_) weight = (*generate_)();
+
+ arc->ilabel = ilabel;
+ arc->olabel = olabel;
+ arc->weight = weight;
+ return true;
+ }
+
+ StateId nstates_;
+ StateId nclasses_;
+ Label nlabels_;
+ bool trans_;
+ const G *generate_;
+ std::vector<StateId> classes_;
+};
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_COMPRESS_RANDMOD_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_EXTENSIONS_FAR_COMPILE_STRINGS_H_
+#define FST_EXTENSIONS_FAR_COMPILE_STRINGS_H_
+
+#include <libgen.h>
+
+#include <fstream>
+#include <istream>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/far/far.h>
+#include <fstream>
+#include <fst/string.h>
+
+namespace fst {
+
+// Constructs a reader that provides FSTs from a file (stream) either on a
+// line-by-line basis or on a per-stream basis. Note that the freshly
+// constructed reader is already set to the first input.
+//
+// Sample usage:
+//
+// for (StringReader<Arc> reader(...); !reader.Done(); reader.Next()) {
+// auto *fst = reader.GetVectorFst();
+// }
+template <class Arc>
+class StringReader {
+ public:
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+
+ enum EntryType { LINE = 1, FILE = 2 };
+
+ StringReader(std::istream &istrm, const string &source, EntryType entry_type,
+ StringTokenType token_type, bool allow_negative_labels,
+ const SymbolTable *syms = nullptr,
+ Label unknown_label = kNoStateId)
+ : nline_(0),
+ istrm_(istrm),
+ source_(source),
+ entry_type_(entry_type),
+ token_type_(token_type),
+ symbols_(syms),
+ done_(false),
+ compiler_(token_type, syms, unknown_label, allow_negative_labels) {
+ Next(); // Initialize the reader to the first input.
+ }
+
+ bool Done() { return done_; }
+
+ void Next() {
+ VLOG(1) << "Processing source " << source_ << " at line " << nline_;
+ if (!istrm_) { // We're done if we have no more input.
+ done_ = true;
+ return;
+ }
+ if (entry_type_ == LINE) {
+ getline(istrm_, content_);
+ ++nline_;
+ } else {
+ content_.clear();
+ string line;
+ while (getline(istrm_, line)) {
+ ++nline_;
+ content_.append(line);
+ content_.append("\n");
+ }
+ }
+ if (!istrm_ && content_.empty()) // We're also done if we read off all the
+ done_ = true; // whitespace at the end of a file.
+ }
+
+ VectorFst<Arc> *GetVectorFst(bool keep_symbols = false) {
+ std::unique_ptr<VectorFst<Arc>> fst(new VectorFst<Arc>());
+ if (keep_symbols) {
+ fst->SetInputSymbols(symbols_);
+ fst->SetOutputSymbols(symbols_);
+ }
+ if (compiler_(content_, fst.get())) {
+ return fst.release();
+ } else {
+ return nullptr;
+ }
+ }
+
+ CompactStringFst<Arc> *GetCompactFst(bool keep_symbols = false) {
+ std::unique_ptr<CompactStringFst<Arc>> fst;
+ if (keep_symbols) {
+ VectorFst<Arc> tmp;
+ tmp.SetInputSymbols(symbols_);
+ tmp.SetOutputSymbols(symbols_);
+ fst.reset(new CompactStringFst<Arc>(tmp));
+ } else {
+ fst.reset(new CompactStringFst<Arc>());
+ }
+ if (compiler_(content_, fst.get())) {
+ return fst.release();
+ } else {
+ return nullptr;
+ }
+ }
+
+ private:
+ size_t nline_;
+ std::istream &istrm_;
+ string source_;
+ EntryType entry_type_;
+ StringTokenType token_type_;
+ const SymbolTable *symbols_;
+ bool done_;
+ StringCompiler<Arc> compiler_;
+ string content_; // The actual content of the input stream's next FST.
+
+ StringReader(const StringReader &) = delete;
+ StringReader &operator=(const StringReader &) = delete;
+};
+
+// Computes the minimal length required to encode each line number as a decimal
+// number.
+int KeySize(const char *filename);
+
+template <class Arc>
+void FarCompileStrings(const std::vector<string> &in_fnames,
+ const string &out_fname, const string &fst_type,
+ const FarType &far_type, int32 generate_keys,
+ FarEntryType fet, FarTokenType tt,
+ const string &symbols_fname,
+ const string &unknown_symbol, bool keep_symbols,
+ bool initial_symbols, bool allow_negative_labels,
+ const string &key_prefix, const string &key_suffix) {
+ typename StringReader<Arc>::EntryType entry_type;
+ if (fet == FET_LINE) {
+ entry_type = StringReader<Arc>::LINE;
+ } else if (fet == FET_FILE) {
+ entry_type = StringReader<Arc>::FILE;
+ } else {
+ FSTERROR() << "FarCompileStrings: Unknown entry type";
+ return;
+ }
+ StringTokenType token_type;
+ if (tt == FTT_SYMBOL) {
+ token_type = StringTokenType::SYMBOL;
+ } else if (tt == FTT_BYTE) {
+ token_type = StringTokenType::BYTE;
+ } else if (tt == FTT_UTF8) {
+ token_type = StringTokenType::UTF8;
+ } else {
+ FSTERROR() << "FarCompileStrings: Unknown token type";
+ return;
+ }
+ bool compact;
+ if (fst_type.empty() || (fst_type == "vector")) {
+ compact = false;
+ } else if (fst_type == "compact") {
+ compact = true;
+ } else {
+ FSTERROR() << "FarCompileStrings: Unknown FST type: " << fst_type;
+ return;
+ }
+ std::unique_ptr<const SymbolTable> syms;
+ typename Arc::Label unknown_label = kNoLabel;
+ if (!symbols_fname.empty()) {
+ const SymbolTableTextOptions opts(allow_negative_labels);
+ syms.reset(SymbolTable::ReadText(symbols_fname, opts));
+ if (!syms) {
+ LOG(ERROR) << "FarCompileStrings: Error reading symbol table: "
+ << symbols_fname;
+ return;
+ }
+ if (!unknown_symbol.empty()) {
+ unknown_label = syms->Find(unknown_symbol);
+ if (unknown_label == kNoLabel) {
+ FSTERROR() << "FarCompileStrings: Label \"" << unknown_label
+ << "\" missing from symbol table: " << symbols_fname;
+ return;
+ }
+ }
+ }
+ std::unique_ptr<FarWriter<Arc>> far_writer(
+ FarWriter<Arc>::Create(out_fname, far_type));
+ if (!far_writer) return;
+ int n = 0;
+ for (const auto &in_fname : in_fnames) {
+ if (generate_keys == 0 && in_fname.empty()) {
+ FSTERROR() << "FarCompileStrings: Read from a file instead of stdin or"
+ << " set the --generate_keys flags.";
+ return;
+ }
+ int key_size =
+ generate_keys ? generate_keys : (entry_type == StringReader<Arc>::FILE
+ ? 1 : KeySize(in_fname.c_str()));
+ std::ifstream fstrm;
+ if (!in_fname.empty()) {
+ fstrm.open(in_fname);
+ if (!fstrm) {
+ FSTERROR() << "FarCompileStrings: Can't open file: " << in_fname;
+ return;
+ }
+ }
+ std::istream &istrm = fstrm.is_open() ? fstrm : std::cin;
+ bool keep_syms = keep_symbols;
+ for (StringReader<Arc> reader(
+ istrm, in_fname.empty() ? "stdin" : in_fname, entry_type,
+ token_type, allow_negative_labels, syms.get(), unknown_label);
+ !reader.Done(); reader.Next()) {
+ ++n;
+ std::unique_ptr<const Fst<Arc>> fst;
+ if (compact) {
+ fst.reset(reader.GetCompactFst(keep_syms));
+ } else {
+ fst.reset(reader.GetVectorFst(keep_syms));
+ }
+ if (initial_symbols) keep_syms = false;
+ if (!fst) {
+ FSTERROR() << "FarCompileStrings: Compiling string number " << n
+ << " in file " << in_fname << " failed with token_type = "
+ << (tt == FTT_BYTE
+ ? "byte"
+ : (tt == FTT_UTF8
+ ? "utf8"
+ : (tt == FTT_SYMBOL ? "symbol" : "unknown")))
+ << " and entry_type = "
+ << (fet == FET_LINE
+ ? "line"
+ : (fet == FET_FILE ? "file" : "unknown"));
+ return;
+ }
+ std::ostringstream keybuf;
+ keybuf.width(key_size);
+ keybuf.fill('0');
+ keybuf << n;
+ string key;
+ if (generate_keys > 0) {
+ key = keybuf.str();
+ } else {
+ auto *filename = new char[in_fname.size() + 1];
+ strcpy(filename, in_fname.c_str());
+ key = basename(filename);
+ if (entry_type != StringReader<Arc>::FILE) {
+ key += "-";
+ key += keybuf.str();
+ }
+ delete[] filename;
+ }
+ far_writer->Add(key_prefix + key + key_suffix, *fst);
+ }
+ if (generate_keys == 0) n = 0;
+ }
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_COMPILE_STRINGS_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Creates a finite-state archive from component FSTs.
+
+#ifndef FST_EXTENSIONS_FAR_CREATE_H_
+#define FST_EXTENSIONS_FAR_CREATE_H_
+
+#include <libgen.h>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/far/far.h>
+
+namespace fst {
+
+template <class Arc>
+void FarCreate(const std::vector<string> &in_fnames, const string &out_fname,
+ const int32 generate_keys, const FarType &far_type,
+ const string &key_prefix, const string &key_suffix) {
+ std::unique_ptr<FarWriter<Arc>> far_writer(
+ FarWriter<Arc>::Create(out_fname, far_type));
+ if (!far_writer) return;
+ for (size_t i = 0; i < in_fnames.size(); ++i) {
+ std::unique_ptr<Fst<Arc>> ifst(Fst<Arc>::Read(in_fnames[i]));
+ if (!ifst) return;
+ string key;
+ if (generate_keys > 0) {
+ std::ostringstream keybuf;
+ keybuf.width(generate_keys);
+ keybuf.fill('0');
+ keybuf << i + 1;
+ key = keybuf.str();
+ } else {
+ auto *filename = new char[in_fnames[i].size() + 1];
+ strcpy(filename, in_fnames[i].c_str());
+ key = basename(filename);
+ delete[] filename;
+ }
+ far_writer->Add(key_prefix + key + key_suffix, *ifst);
+ }
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_CREATE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_EXTENSIONS_FAR_EQUAL_H_
+#define FST_EXTENSIONS_FAR_EQUAL_H_
+
+#include <memory>
+#include <string>
+
+#include <fst/extensions/far/far.h>
+#include <fst/equal.h>
+
+namespace fst {
+
+template <class Arc>
+bool FarEqual(const string &filename1, const string &filename2,
+ float delta = kDelta, const string &begin_key = string(),
+ const string &end_key = string()) {
+ std::unique_ptr<FarReader<Arc>> reader1(FarReader<Arc>::Open(filename1));
+ if (!reader1) {
+ LOG(ERROR) << "FarEqual: Could not open FAR file " << filename1;
+ return false;
+ }
+ std::unique_ptr<FarReader<Arc>> reader2(FarReader<Arc>::Open(filename2));
+ if (!reader2) {
+ LOG(ERROR) << "FarEqual: Could not open FAR file " << filename2;
+ return false;
+ }
+ if (!begin_key.empty()) {
+ bool find_begin1 = reader1->Find(begin_key);
+ bool find_begin2 = reader2->Find(begin_key);
+ if (!find_begin1 || !find_begin2) {
+ bool ret = !find_begin1 && !find_begin2;
+ if (!ret) {
+ LOG(ERROR) << "FarEqual: 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) << "FarEqual: Mismatched keys " << key1 << " and " << key2;
+ return false;
+ }
+ if (!Equal(*(reader1->GetFst()), *(reader2->GetFst()), delta)) {
+ LOG(ERROR) << "FarEqual: FSTs for key " << key1 << " are not equal";
+ return false;
+ }
+ }
+ if (!reader1->Done() || !reader2->Done()) {
+ LOG(ERROR) << "FarEqual: Key "
+ << (reader1->Done() ? reader2->GetKey() : reader1->GetKey())
+ << " missing from " << (reader2->Done() ? "first" : "second")
+ << " archive";
+ return false;
+ }
+ return true;
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_EQUAL_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Extracts component FSTs from an finite-state archive.
+
+#ifndef FST_EXTENSIONS_FAR_EXTRACT_H_
+#define FST_EXTENSIONS_FAR_EXTRACT_H_
+
+#include <string>
+#include <vector>
+
+#include <fst/extensions/far/far.h>
+
+namespace fst {
+
+template <class Arc>
+inline void FarWriteFst(const Fst<Arc> *fst, string key, string *okey,
+ int *nrep, int32 generate_filenames, int i,
+ const string &filename_prefix,
+ const string &filename_suffix) {
+ if (key == *okey) {
+ ++*nrep;
+ } else {
+ *nrep = 0;
+ }
+ *okey = key;
+ string ofilename;
+ if (generate_filenames) {
+ std::ostringstream tmp;
+ tmp.width(generate_filenames);
+ tmp.fill('0');
+ tmp << i;
+ ofilename = tmp.str();
+ } else {
+ if (*nrep > 0) {
+ std::ostringstream tmp;
+ tmp << '.' << nrep;
+ key.append(tmp.str().data(), tmp.str().size());
+ }
+ ofilename = key;
+ }
+ fst->Write(filename_prefix + ofilename + filename_suffix);
+}
+
+template <class Arc>
+void FarExtract(const std::vector<string> &ifilenames, int32 generate_filenames,
+ const string &keys, const string &key_separator,
+ const string &range_delimiter, const string &filename_prefix,
+ const string &filename_suffix) {
+ FarReader<Arc> *far_reader = FarReader<Arc>::Open(ifilenames);
+ if (!far_reader) return;
+ string okey;
+ int nrep = 0;
+ std::vector<char *> key_vector;
+ // User has specified a set of FSTs to extract, where some of these may in
+ // fact be ranges.
+ if (!keys.empty()) {
+ auto *keys_cstr = new char[keys.size() + 1];
+ strcpy(keys_cstr, keys.c_str());
+ SplitToVector(keys_cstr, key_separator.c_str(), &key_vector, true);
+ int i = 0;
+ for (size_t k = 0; k < key_vector.size(); ++k, ++i) {
+ string key = key_vector[k];
+ auto *key_cstr = new char[key.size() + 1];
+ strcpy(key_cstr, key.c_str());
+ std::vector<char *> range_vector;
+ SplitToVector(key_cstr, range_delimiter.c_str(), &range_vector, false);
+ if (range_vector.size() == 1) { // Not a range
+ if (!far_reader->Find(key)) {
+ LOG(ERROR) << "FarExtract: Cannot find key " << key;
+ return;
+ }
+ const auto *fst = far_reader->GetFst();
+ FarWriteFst(fst, key, &okey, &nrep, generate_filenames, i,
+ filename_prefix, filename_suffix);
+ } else if (range_vector.size() == 2) { // A legal range
+ string begin_key = range_vector[0];
+ string end_key = range_vector[1];
+ if (begin_key.empty() || end_key.empty()) {
+ LOG(ERROR) << "FarExtract: Illegal range specification " << key;
+ return;
+ }
+ if (!far_reader->Find(begin_key)) {
+ LOG(ERROR) << "FarExtract: Cannot find key " << begin_key;
+ return;
+ }
+ for (; !far_reader->Done(); far_reader->Next(), ++i) {
+ const auto &ikey = far_reader->GetKey();
+ if (end_key < ikey) break;
+ const auto *fst = far_reader->GetFst();
+ FarWriteFst(fst, ikey, &okey, &nrep, generate_filenames, i,
+ filename_prefix, filename_suffix);
+ }
+ } else {
+ LOG(ERROR) << "FarExtract: Illegal range specification " << key;
+ return;
+ }
+ delete[] key_cstr;
+ }
+ delete[] keys_cstr;
+ return;
+ }
+ // Nothing specified, so just extracts everything.
+ for (size_t i = 1; !far_reader->Done(); far_reader->Next(), ++i) {
+ const auto &key = far_reader->GetKey();
+ const auto *fst = far_reader->GetFst();
+ FarWriteFst(fst, key, &okey, &nrep, generate_filenames, i, filename_prefix,
+ filename_suffix);
+ }
+ return;
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_EXTRACT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Scripting API support for FarReader and FarWriter.
+
+#ifndef FST_EXTENSIONS_FAR_FAR_CLASS_H_
+#define FST_EXTENSIONS_FAR_FAR_CLASS_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/script/arg-packs.h>
+#include <fst/script/fstscript.h>
+#include <fst/extensions/far/far.h>
+
+
+namespace fst {
+namespace script {
+
+
+// FarReader API.
+
+// Virtual interface implemented by each concrete FarReaderImpl<A>.
+// See the FarReader interface in far.h for the exact semantics.
+class FarReaderImplBase {
+ public:
+ virtual const string &ArcType() const = 0;
+ virtual bool Done() const = 0;
+ virtual bool Error() const = 0;
+ virtual const string &GetKey() const = 0;
+ virtual const FstClass *GetFstClass() const = 0;
+ virtual bool Find(const string &key) = 0;
+ virtual void Next() = 0;
+ virtual void Reset() = 0;
+ virtual FarType Type() const = 0;
+ virtual ~FarReaderImplBase() {}
+};
+
+// Templated implementation.
+template <class Arc>
+class FarReaderClassImpl : public FarReaderImplBase {
+ public:
+ explicit FarReaderClassImpl(const string &filename)
+ : impl_(FarReader<Arc>::Open(filename)) {}
+
+ explicit FarReaderClassImpl(const std::vector<string> &filenames)
+ : impl_(FarReader<Arc>::Open(filenames)) {}
+
+ const string &ArcType() const override { return Arc::Type(); }
+
+ bool Done() const override { return impl_->Done(); }
+
+ bool Error() const override { return impl_->Error(); }
+
+ bool Find(const string &key) override { return impl_->Find(key); }
+
+ const FstClass *GetFstClass() const override {
+ fstc_.reset(new FstClass(*impl_->GetFst()));
+ return fstc_.get();
+ }
+
+ const string &GetKey() const override { return impl_->GetKey(); }
+
+ void Next() override { return impl_->Next(); }
+
+ void Reset() override { impl_->Reset(); }
+
+ FarType Type() const override { return impl_->Type(); }
+
+ const FarReader<Arc> *GetImpl() const { return impl_.get(); }
+
+ FarReader<Arc> *GetImpl() { return impl_.get(); }
+
+ private:
+ std::unique_ptr<FarReader<Arc>> impl_;
+ mutable std::unique_ptr<FstClass> fstc_;
+};
+
+
+class FarReaderClass;
+
+typedef args::WithReturnValue<FarReaderClass *, const string &>
+ OpenFarReaderClassArgs1;
+
+typedef args::WithReturnValue<FarReaderClass *, const std::vector<string> &>
+ OpenFarReaderClassArgs2;
+
+
+// Untemplated user-facing class holding a templated pimpl.
+class FarReaderClass {
+ public:
+ const string &ArcType() const { return impl_->ArcType(); }
+
+ bool Done() const { return impl_->Done(); }
+
+ // Returns True if the impl is null (i.e., due to read failure).
+ // Attempting to call any other function will result in null dereference.
+ bool Error() const { return (impl_) ? impl_->Error() : true; }
+
+ bool Find(const string &key) { return impl_->Find(key); }
+
+ const FstClass *GetFstClass() const { return impl_->GetFstClass(); }
+
+ const string &GetKey() const { return impl_->GetKey(); }
+
+ void Next() { impl_->Next(); }
+
+ void Reset() { impl_->Reset(); }
+
+ FarType Type() const { return impl_->Type(); }
+
+ template <class Arc>
+ const FarReader<Arc> *GetFarReader() const {
+ if (Arc::Type() != ArcType()) return nullptr;
+ const FarReaderClassImpl<Arc> *typed_impl =
+ static_cast<FarReaderClassImpl<Arc> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+
+ template <class Arc>
+ FarReader<Arc> *GetFarReader() {
+ if (Arc::Type() != ArcType()) return nullptr;
+ FarReaderClassImpl<Arc> *typed_impl =
+ static_cast<FarReaderClassImpl<Arc> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+
+ template <class Arc>
+ friend void OpenFarReaderClass(OpenFarReaderClassArgs1 *args);
+
+ template <class Arc>
+ friend void OpenFarReaderClass(OpenFarReaderClassArgs2 *args);
+
+ // Defined in the CC.
+
+ static FarReaderClass *Open(const string &filename);
+
+ static FarReaderClass *Open(const std::vector<string> &filenames);
+
+ private:
+ template <class Arc>
+ explicit FarReaderClass(FarReaderClassImpl<Arc> *impl) : impl_(impl) {}
+
+ std::unique_ptr<FarReaderImplBase> impl_;
+};
+
+// These exist solely for registration purposes; users should call the
+// static method FarReaderClass::Open instead.
+
+template <class Arc>
+void OpenFarReaderClass(OpenFarReaderClassArgs1 *args) {
+ args->retval = new FarReaderClass(new FarReaderClassImpl<Arc>(args->args));
+}
+
+template <class Arc>
+void OpenFarReaderClass(OpenFarReaderClassArgs2 *args) {
+ args->retval = new FarReaderClass(new FarReaderClassImpl<Arc>(args->args));
+}
+
+// FarWriter API.
+
+// Virtual interface implemented by each concrete FarWriterImpl<A>.
+class FarWriterImplBase {
+ public:
+ // Unlike the lower-level library, this returns a boolean to signal failure
+ // due to non-conformant arc types.
+ virtual bool Add(const string &key, const FstClass &fst) = 0;
+ virtual const string &ArcType() const = 0;
+ virtual bool Error() const = 0;
+ virtual FarType Type() const = 0;
+ virtual ~FarWriterImplBase() {}
+};
+
+
+// Templated implementation.
+template <class Arc>
+class FarWriterClassImpl : public FarWriterImplBase {
+ public:
+ explicit FarWriterClassImpl(const string &filename,
+ FarType type = FAR_DEFAULT)
+ : impl_(FarWriter<Arc>::Create(filename, type)) {}
+
+ bool Add(const string &key, const FstClass &fst) override {
+ if (ArcType() != fst.ArcType()) {
+ FSTERROR() << "Cannot write FST with " << fst.ArcType() << " arcs to "
+ << "FAR with " << ArcType() << " arcs";
+ return false;
+ }
+ impl_->Add(key, *(fst.GetFst<Arc>()));
+ return true;
+ }
+
+ const string &ArcType() const override { return Arc::Type(); }
+
+ bool Error() const override { return impl_->Error(); }
+
+ FarType Type() const override { return impl_->Type(); }
+
+ const FarWriter<Arc> *GetImpl() const { return impl_.get(); }
+
+ FarWriter<Arc> *GetImpl() { return impl_.get(); }
+
+ private:
+ std::unique_ptr<FarWriter<Arc>> impl_;
+};
+
+
+class FarWriterClass;
+
+typedef args::Package<const string &, FarType> CreateFarWriterClassInnerArgs;
+
+typedef args::WithReturnValue<FarWriterClass *, CreateFarWriterClassInnerArgs>
+ CreateFarWriterClassArgs;
+
+
+// Untemplated user-facing class holding a templated pimpl.
+class FarWriterClass {
+ public:
+ static FarWriterClass *Create(const string &filename, const string &arc_type,
+ FarType type = FAR_DEFAULT);
+
+ bool Add(const string &key, const FstClass &fst) {
+ return impl_->Add(key, fst);
+ }
+
+ // Returns True if the impl is null (i.e., due to construction failure).
+ // Attempting to call any other function will result in null dereference.
+ bool Error() const { return (impl_) ? impl_->Error() : true; }
+
+ const string &ArcType() const { return impl_->ArcType(); }
+
+ FarType Type() const { return impl_->Type(); }
+
+ template <class Arc>
+ const FarWriter<Arc> *GetFarWriter() const {
+ if (Arc::Type() != ArcType()) return nullptr;
+ const FarWriterClassImpl<Arc> *typed_impl =
+ static_cast<FarWriterClassImpl<Arc> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+
+ template <class Arc>
+ FarWriter<Arc> *GetFarWriter() {
+ if (Arc::Type() != ArcType()) return nullptr;
+ FarWriterClassImpl<Arc> *typed_impl =
+ static_cast<FarWriterClassImpl<Arc> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+
+ template <class Arc>
+ friend void CreateFarWriterClass(CreateFarWriterClassArgs *args);
+
+ private:
+ template <class Arc>
+ explicit FarWriterClass(FarWriterClassImpl<Arc> *impl) : impl_(impl) {}
+
+ std::unique_ptr<FarWriterImplBase> impl_;
+};
+
+// This exists solely for registration purposes; users should call the
+// static method FarWriterClass::Create instead.
+template <class Arc>
+void CreateFarWriterClass(CreateFarWriterClassArgs *args) {
+ args->retval = new FarWriterClass(
+ new FarWriterClassImpl<Arc>(args->args.arg1, args->args.arg2));
+}
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_FAR_CLASS_H_
--- /dev/null
+// 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 <iostream>
+#include <sstream>
+
+#include <fst/extensions/far/stlist.h>
+#include <fst/extensions/far/sttable.h>
+#include <fst/fst.h>
+#include <fst/vector-fst.h>
+#include <fstream>
+
+namespace fst {
+
+enum FarEntryType { FET_LINE, FET_FILE };
+enum FarTokenType { FTT_SYMBOL, FTT_BYTE, FTT_UTF8 };
+
+inline bool IsFst(const string &filename) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) return false;
+ return IsFstHeader(strm, filename);
+}
+
+// FST archive header class
+class FarHeader {
+ public:
+ const string &FarType() const { return fartype_; }
+ const string &ArcType() const { return arctype_; }
+
+ bool Read(const string &filename) {
+ FstHeader fsthdr;
+ if (filename.empty()) {
+ // Header reading unsupported on stdin. Assumes STList and StdArc.
+ fartype_ = "stlist";
+ arctype_ = "standard";
+ return true;
+ } else if (IsSTTable(filename)) { // Check if STTable
+ ReadSTTableHeader(filename, &fsthdr);
+ fartype_ = "sttable";
+ arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType();
+ return true;
+ } else if (IsSTList(filename)) { // Check if STList
+ ReadSTListHeader(filename, &fsthdr);
+ fartype_ = "stlist";
+ arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType();
+ return true;
+ } else if (IsFst(filename)) { // Check if Fst
+ std::ifstream istrm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ fsthdr.Read(istrm, filename);
+ fartype_ = "fst";
+ arctype_ = fsthdr.ArcType().empty() ? "unknown" : fsthdr.ArcType();
+ return true;
+ }
+ return false;
+ }
+
+ private:
+ string fartype_;
+ string arctype_;
+};
+
+enum FarType {
+ FAR_DEFAULT = 0,
+ FAR_STTABLE = 1,
+ FAR_STLIST = 2,
+ FAR_FST = 3,
+};
+
+// This class creates an archive of FSTs.
+template <class A>
+class FarWriter {
+ public:
+ typedef A Arc;
+
+ // Creates a new (empty) FST archive; returns null on error.
+ static FarWriter *Create(const string &filename, FarType type = FAR_DEFAULT);
+
+ // Adds an FST to the end of an archive. Keys must be non-empty and
+ // in lexicographic order. FSTs must have a suitable write method.
+ virtual void Add(const string &key, const Fst<A> &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 A>
+class FarReader {
+ public:
+ typedef A Arc;
+
+ // Opens an existing FST archive in a single file; returns null on error.
+ // Sets current position to the beginning of the achive.
+ static FarReader *Open(const string &filename);
+
+ // Opens an existing FST archive in multiple files; returns null on error.
+ // Sets current position to the beginning of the achive.
+ static FarReader *Open(const std::vector<string> &filenames);
+
+ // Resets current position to beginning of archive.
+ virtual void Reset() = 0;
+
+ // Sets current position to first entry >= key. Returns true if a match.
+ virtual bool Find(const string &key) = 0;
+
+ // Current position at end of archive?
+ virtual bool Done() const = 0;
+
+ // Move current position to next FST.
+ virtual void Next() = 0;
+
+ // Returns key at the current position. This reference is invalidated if
+ // the current position in the archive is changed.
+ virtual const string &GetKey() const = 0;
+
+ // Returns pointer to FST at the current position. This is invalidated if
+ // the current position in the archive is changed.
+ virtual const Fst<A> *GetFst() const = 0;
+
+ virtual FarType Type() const = 0;
+
+ virtual bool Error() const = 0;
+
+ virtual ~FarReader() {}
+
+ protected:
+ FarReader() {}
+};
+
+template <class A>
+class FstWriter {
+ public:
+ void operator()(std::ostream &strm, const Fst<A> &fst) const {
+ fst.Write(strm, FstWriteOptions());
+ }
+};
+
+template <class A>
+class STTableFarWriter : public FarWriter<A> {
+ public:
+ typedef A Arc;
+
+ static STTableFarWriter *Create(const string &filename) {
+ STTableWriter<Fst<A>, FstWriter<A>> *writer =
+ STTableWriter<Fst<A>, FstWriter<A>>::Create(filename);
+ return new STTableFarWriter(writer);
+ }
+
+ void Add(const string &key, const Fst<A> &fst) override {
+ writer_->Add(key, fst);
+ }
+
+ FarType Type() const override { return FAR_STTABLE; }
+
+ bool Error() const override { return writer_->Error(); }
+
+ private:
+ explicit STTableFarWriter(STTableWriter<Fst<A>, FstWriter<A>> *writer)
+ : writer_(writer) {}
+
+ std::unique_ptr<STTableWriter<Fst<A>, FstWriter<A>>> writer_;
+};
+
+template <class A>
+class STListFarWriter : public FarWriter<A> {
+ public:
+ typedef A Arc;
+
+ static STListFarWriter *Create(const string &filename) {
+ STListWriter<Fst<A>, FstWriter<A>> *writer =
+ STListWriter<Fst<A>, FstWriter<A>>::Create(filename);
+ return new STListFarWriter(writer);
+ }
+
+ void Add(const string &key, const Fst<A> &fst) override {
+ writer_->Add(key, fst);
+ }
+
+ FarType Type() const override { return FAR_STLIST; }
+
+ bool Error() const override { return writer_->Error(); }
+
+ private:
+ explicit STListFarWriter(STListWriter<Fst<A>, FstWriter<A>> *writer)
+ : writer_(writer) {}
+
+ std::unique_ptr<STListWriter<Fst<A>, FstWriter<A>>> writer_;
+};
+
+template <class A>
+class FstFarWriter : public FarWriter<A> {
+ public:
+ typedef A Arc;
+
+ explicit FstFarWriter(const string &filename)
+ : filename_(filename), error_(false), written_(false) {}
+
+ static FstFarWriter *Create(const string &filename) {
+ return new FstFarWriter(filename);
+ }
+
+ void Add(const string &key, const Fst<A> &fst) override {
+ if (written_) {
+ LOG(WARNING) << "FstFarWriter::Add: only one Fst supported,"
+ << " subsequent entries discarded.";
+ } else {
+ error_ = !fst.Write(filename_);
+ written_ = true;
+ }
+ }
+
+ FarType Type() const override { return FAR_FST; }
+
+ bool Error() const override { return error_; }
+
+ ~FstFarWriter() override {}
+
+ private:
+ string filename_;
+ bool error_;
+ bool written_;
+};
+
+template <class A>
+FarWriter<A> *FarWriter<A>::Create(const string &filename, FarType type) {
+ switch (type) {
+ case FAR_DEFAULT:
+ if (filename.empty()) return STListFarWriter<A>::Create(filename);
+ case FAR_STTABLE:
+ return STTableFarWriter<A>::Create(filename);
+ case FAR_STLIST:
+ return STListFarWriter<A>::Create(filename);
+ case FAR_FST:
+ return FstFarWriter<A>::Create(filename);
+ default:
+ LOG(ERROR) << "FarWriter::Create: Unknown FAR type";
+ return nullptr;
+ }
+}
+
+template <class A>
+class FstReader {
+ public:
+ Fst<A> *operator()(std::istream &strm) const {
+ return Fst<A>::Read(strm, FstReadOptions());
+ }
+};
+
+template <class A>
+class STTableFarReader : public FarReader<A> {
+ public:
+ typedef A Arc;
+
+ static STTableFarReader *Open(const string &filename) {
+ STTableReader<Fst<A>, FstReader<A>> *reader =
+ STTableReader<Fst<A>, FstReader<A>>::Open(filename);
+ // TODO: error check
+ return new STTableFarReader(reader);
+ }
+
+ static STTableFarReader *Open(const std::vector<string> &filenames) {
+ STTableReader<Fst<A>, FstReader<A>> *reader =
+ STTableReader<Fst<A>, FstReader<A>>::Open(filenames);
+ // TODO: error check
+ return new STTableFarReader(reader);
+ }
+
+ void Reset() override { reader_->Reset(); }
+
+ bool Find(const string &key) override { return reader_->Find(key); }
+
+ bool Done() const override { return reader_->Done(); }
+
+ void Next() override { return reader_->Next(); }
+
+ const string &GetKey() const override { return reader_->GetKey(); }
+
+ const Fst<A> *GetFst() const override { return reader_->GetEntry(); }
+
+ FarType Type() const override { return FAR_STTABLE; }
+
+ bool Error() const override { return reader_->Error(); }
+
+ private:
+ explicit STTableFarReader(STTableReader<Fst<A>, FstReader<A>> *reader)
+ : reader_(reader) {}
+
+ std::unique_ptr<STTableReader<Fst<A>, FstReader<A>>> reader_;
+};
+
+template <class A>
+class STListFarReader : public FarReader<A> {
+ public:
+ typedef A Arc;
+
+ static STListFarReader *Open(const string &filename) {
+ STListReader<Fst<A>, FstReader<A>> *reader =
+ STListReader<Fst<A>, FstReader<A>>::Open(filename);
+ // TODO: error check
+ return new STListFarReader(reader);
+ }
+
+ static STListFarReader *Open(const std::vector<string> &filenames) {
+ STListReader<Fst<A>, FstReader<A>> *reader =
+ STListReader<Fst<A>, FstReader<A>>::Open(filenames);
+ // TODO: error check
+ return new STListFarReader(reader);
+ }
+
+ void Reset() override { reader_->Reset(); }
+
+ bool Find(const string &key) override { return reader_->Find(key); }
+
+ bool Done() const override { return reader_->Done(); }
+
+ void Next() override { return reader_->Next(); }
+
+ const string &GetKey() const override { return reader_->GetKey(); }
+
+ const Fst<A> *GetFst() const override { return reader_->GetEntry(); }
+
+ FarType Type() const override { return FAR_STLIST; }
+
+ bool Error() const override { return reader_->Error(); }
+
+ private:
+ explicit STListFarReader(STListReader<Fst<A>, FstReader<A>> *reader)
+ : reader_(reader) {}
+
+ std::unique_ptr<STListReader<Fst<A>, FstReader<A>>> reader_;
+};
+
+template <class A>
+class FstFarReader : public FarReader<A> {
+ public:
+ typedef A Arc;
+
+ static FstFarReader *Open(const string &filename) {
+ std::vector<string> filenames;
+ filenames.push_back(filename);
+ return new FstFarReader<A>(filenames);
+ }
+
+ static FstFarReader *Open(const std::vector<string> &filenames) {
+ return new FstFarReader<A>(filenames);
+ }
+
+ explicit FstFarReader(const std::vector<string> &filenames)
+ : keys_(filenames), has_stdin_(false), pos_(0), error_(false) {
+ std::sort(keys_.begin(), keys_.end());
+ streams_.resize(keys_.size(), 0);
+ for (size_t i = 0; i < keys_.size(); ++i) {
+ if (keys_[i].empty()) {
+ if (!has_stdin_) {
+ streams_[i] = &std::cin;
+ // sources_[i] = "stdin";
+ has_stdin_ = true;
+ } else {
+ FSTERROR() << "FstFarReader::FstFarReader: stdin should only "
+ << "appear once in the input file list.";
+ error_ = true;
+ return;
+ }
+ } else {
+ streams_[i] = new std::ifstream(
+ keys_[i].c_str(), std::ios_base::in | std::ios_base::binary);
+ }
+ }
+ if (pos_ >= keys_.size()) return;
+ ReadFst();
+ }
+
+ void Reset() override {
+ if (has_stdin_) {
+ FSTERROR() << "FstFarReader::Reset: Operation not supported on stdin";
+ error_ = true;
+ return;
+ }
+ pos_ = 0;
+ ReadFst();
+ }
+
+ bool Find(const string &key) override {
+ if (has_stdin_) {
+ FSTERROR() << "FstFarReader::Find: Operation not supported on stdin";
+ error_ = true;
+ return false;
+ }
+ pos_ = 0; // TODO
+ ReadFst();
+ return true;
+ }
+
+ bool Done() const override { return error_ || pos_ >= keys_.size(); }
+
+ void Next() override {
+ ++pos_;
+ ReadFst();
+ }
+
+ const string &GetKey() const override { return keys_[pos_]; }
+
+ const Fst<A> *GetFst() const override { return fst_.get(); }
+
+ FarType Type() const override { return FAR_FST; }
+
+ bool Error() const override { return error_; }
+
+ ~FstFarReader() override {
+ 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<A>::Read(*streams_[pos_], FstReadOptions()));
+ if (!fst_) {
+ FSTERROR() << "FstFarReader: Error reading Fst from: " << keys_[pos_];
+ error_ = true;
+ }
+ }
+
+ std::vector<string> keys_;
+ std::vector<std::istream *> streams_;
+ bool has_stdin_;
+ size_t pos_;
+ mutable std::unique_ptr<Fst<A>> fst_;
+ mutable bool error_;
+};
+
+template <class A>
+FarReader<A> *FarReader<A>::Open(const string &filename) {
+ if (filename.empty())
+ return STListFarReader<A>::Open(filename);
+ else if (IsSTTable(filename))
+ return STTableFarReader<A>::Open(filename);
+ else if (IsSTList(filename))
+ return STListFarReader<A>::Open(filename);
+ else if (IsFst(filename))
+ return FstFarReader<A>::Open(filename);
+ return nullptr;
+}
+
+template <class A>
+FarReader<A> *FarReader<A>::Open(const std::vector<string> &filenames) {
+ if (!filenames.empty() && filenames[0].empty())
+ return STListFarReader<A>::Open(filenames);
+ else if (!filenames.empty() && IsSTTable(filenames[0]))
+ return STTableFarReader<A>::Open(filenames);
+ else if (!filenames.empty() && IsSTList(filenames[0]))
+ return STListFarReader<A>::Open(filenames);
+ else if (!filenames.empty() && IsFst(filenames[0]))
+ return FstFarReader<A>::Open(filenames);
+ return nullptr;
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_FAR_H_
--- /dev/null
+// 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 <fst/extensions/far/compile-strings.h>
+#include <fst/extensions/far/create.h>
+#include <fst/extensions/far/extract.h>
+#include <fst/extensions/far/far.h>
+#include <fst/extensions/far/getters.h>
+#include <fst/extensions/far/info.h>
+#include <fst/extensions/far/print-strings.h>
+
+#endif // FST_EXTENSIONS_FAR_FARLIB_H_
--- /dev/null
+// 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 <string>
+#include <vector>
+
+#include <fst/types.h>
+#include <fst/extensions/far/compile-strings.h>
+#include <fst/extensions/far/create.h>
+#include <fst/extensions/far/equal.h>
+#include <fst/extensions/far/extract.h>
+#include <fst/extensions/far/far.h>
+#include <fst/extensions/far/far-class.h>
+#include <fst/extensions/far/info.h>
+#include <fst/extensions/far/isomorphic.h>
+#include <fst/extensions/far/print-strings.h>
+#include <fst/extensions/far/script-impl.h>
+#include <fst/script/arg-packs.h>
+
+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<string> &in_fnames;
+ const string &out_fname;
+ const string &fst_type;
+ const FarType &far_type;
+ const int32 generate_keys;
+ const FarEntryType fet;
+ const FarTokenType tt;
+ const string &symbols_fname;
+ const string &unknown_symbol;
+ const bool keep_symbols;
+ const bool initial_symbols;
+ const bool allow_negative_labels;
+ const string &key_prefix;
+ const string &key_suffix;
+
+ FarCompileStringsArgs(const std::vector<string> &in_fnames,
+ const string &out_fname, const string &fst_type,
+ const FarType &far_type, int32 generate_keys,
+ FarEntryType fet, FarTokenType tt,
+ const string &symbols_fname,
+ const string &unknown_symbol, bool keep_symbols,
+ bool initial_symbols, bool allow_negative_labels,
+ const string &key_prefix, const string &key_suffix)
+ : in_fnames(in_fnames),
+ out_fname(out_fname),
+ fst_type(fst_type),
+ far_type(far_type),
+ generate_keys(generate_keys),
+ fet(fet),
+ tt(tt),
+ symbols_fname(symbols_fname),
+ unknown_symbol(unknown_symbol),
+ keep_symbols(keep_symbols),
+ initial_symbols(initial_symbols),
+ allow_negative_labels(allow_negative_labels),
+ key_prefix(key_prefix),
+ key_suffix(key_suffix) {}
+};
+
+template <class Arc>
+void FarCompileStrings(FarCompileStringsArgs *args) {
+ FarCompileStrings<Arc>(
+ args->in_fnames, args->out_fname, args->fst_type, args->far_type,
+ args->generate_keys, args->fet, args->tt, args->symbols_fname,
+ args->unknown_symbol, args->keep_symbols, args->initial_symbols,
+ args->allow_negative_labels, args->key_prefix, args->key_suffix);
+}
+
+void FarCompileStrings(const std::vector<string> &in_fnames,
+ const string &out_fname, const string &arc_type,
+ const string &fst_type, const FarType &far_type,
+ int32 generate_keys, FarEntryType fet, FarTokenType tt,
+ const string &symbols_fname,
+ const string &unknown_symbol, bool keep_symbols,
+ bool initial_symbols, bool allow_negative_labels,
+ const string &key_prefix, const string &key_suffix);
+
+// Note: it is safe to pass these strings as references because this struct is
+// only used to pass them deeper in the call graph. Be sure you understand why
+// this is so before using this struct for anything else!
+struct FarCreateArgs {
+ const std::vector<string> &in_fnames;
+ const string &out_fname;
+ const int32 generate_keys;
+ const FarType &far_type;
+ const string &key_prefix;
+ const string &key_suffix;
+
+ FarCreateArgs(const std::vector<string> &in_fnames, const string &out_fname,
+ const int32 generate_keys, const FarType &far_type,
+ const string &key_prefix, const string &key_suffix)
+ : in_fnames(in_fnames),
+ out_fname(out_fname),
+ generate_keys(generate_keys),
+ far_type(far_type),
+ key_prefix(key_prefix),
+ key_suffix(key_suffix) {}
+};
+
+template <class Arc>
+void FarCreate(FarCreateArgs *args) {
+ FarCreate<Arc>(args->in_fnames, args->out_fname, args->generate_keys,
+ args->far_type, args->key_prefix, args->key_suffix);
+}
+
+void FarCreate(const std::vector<string> &in_fnames, const string &out_fname,
+ const string &arc_type, const int32 generate_keys,
+ const FarType &far_type, const string &key_prefix,
+ const string &key_suffix);
+
+using FarEqualInnerArgs = args::Package<const string &, const string &, float,
+ const string &, const string &>;
+
+using FarEqualArgs = args::WithReturnValue<bool, FarEqualInnerArgs>;
+
+template <class Arc>
+void FarEqual(FarEqualArgs *args) {
+ args->retval =
+ fst::FarEqual<Arc>(args->args.arg1, args->args.arg2, args->args.arg3,
+ args->args.arg4, args->args.arg5);
+}
+
+bool FarEqual(const string &filename1, const string &filename2,
+ const string &arc_type, float delta = kDelta,
+ const string &begin_key = string(),
+ const string &end_key = string());
+
+using FarExtractArgs =
+ args::Package<const std::vector<string> &, int32, const string &,
+ const string &, const string &, const string &,
+ const string &>;
+
+template <class Arc>
+void FarExtract(FarExtractArgs *args) {
+ fst::FarExtract<Arc>(args->arg1, args->arg2, args->arg3, args->arg4,
+ args->arg5, args->arg6, args->arg7);
+}
+
+void FarExtract(const std::vector<string> &ifilenames, const string &arc_type,
+ int32 generate_filenames, const string &keys,
+ const string &key_separator, const string &range_delimiter,
+ const string &filename_prefix, const string &filename_suffix);
+
+using FarInfoArgs = args::Package<const std::vector<string> &, const string &,
+ const string &, const bool>;
+
+template <class Arc>
+void FarInfo(FarInfoArgs *args) {
+ fst::FarInfo<Arc>(args->arg1, args->arg2, args->arg3, args->arg4);
+}
+
+void FarInfo(const std::vector<string> &filenames, const string &arc_type,
+ const string &begin_key, const string &end_key,
+ const bool list_fsts);
+
+using FarIsomorphicInnerArgs =
+ args::Package<const string &, const string &, float, const string &,
+ const string &>;
+using FarIsomorphicArgs = args::WithReturnValue<bool, FarIsomorphicInnerArgs>;
+
+template <class Arc>
+void FarIsomorphic(FarIsomorphicArgs *args) {
+ args->retval = fst::FarIsomorphic<Arc>(args->args.arg1, args->args.arg2,
+ args->args.arg3, args->args.arg4,
+ args->args.arg5);
+}
+
+bool FarIsomorphic(const string &filename1, const string &filename2,
+ const string &arc_type, float delta = kDelta,
+ const string &begin_key = string(),
+ const string &end_key = string());
+
+struct FarPrintStringsArgs {
+ const std::vector<string> &ifilenames;
+ const FarEntryType entry_type;
+ const FarTokenType token_type;
+ const string &begin_key;
+ const string &end_key;
+ const bool print_key;
+ const bool print_weight;
+ const string &symbols_fname;
+ const bool initial_symbols;
+ const int32 generate_filenames;
+ const string &filename_prefix;
+ const string &filename_suffix;
+
+ FarPrintStringsArgs(const std::vector<string> &ifilenames,
+ const FarEntryType entry_type,
+ const FarTokenType token_type, const string &begin_key,
+ const string &end_key, const bool print_key,
+ const bool print_weight, const string &symbols_fname,
+ const bool initial_symbols,
+ const int32 generate_filenames,
+ const string &filename_prefix,
+ const string &filename_suffix)
+ : ifilenames(ifilenames),
+ entry_type(entry_type),
+ token_type(token_type),
+ begin_key(begin_key),
+ end_key(end_key),
+ print_key(print_key),
+ print_weight(print_weight),
+ symbols_fname(symbols_fname),
+ initial_symbols(initial_symbols),
+ generate_filenames(generate_filenames),
+ filename_prefix(filename_prefix),
+ filename_suffix(filename_suffix) {}
+};
+
+template <class Arc>
+void FarPrintStrings(FarPrintStringsArgs *args) {
+ fst::FarPrintStrings<Arc>(
+ args->ifilenames, args->entry_type, args->token_type, args->begin_key,
+ args->end_key, args->print_key, args->print_weight, args->symbols_fname,
+ args->initial_symbols, args->generate_filenames, args->filename_prefix,
+ args->filename_suffix);
+}
+
+void FarPrintStrings(const std::vector<string> &ifilenames,
+ const string &arc_type, const FarEntryType entry_type,
+ const FarTokenType token_type, const string &begin_key,
+ const string &end_key, const bool print_key,
+ const bool print_weight, const string &symbols_fname,
+ const bool initial_symbols, const int32 generate_filenames,
+ const string &filename_prefix,
+ const string &filename_suffix);
+
+} // namespace script
+} // namespace fst
+
+#define REGISTER_FST_FAR_OPERATIONS(ArcType) \
+ REGISTER_FST_OPERATION(FarCompileStrings, ArcType, FarCompileStringsArgs); \
+ REGISTER_FST_OPERATION(FarCreate, ArcType, FarCreateArgs); \
+ REGISTER_FST_OPERATION(FarEqual, ArcType, FarEqualArgs); \
+ REGISTER_FST_OPERATION(FarExtract, ArcType, FarExtractArgs); \
+ REGISTER_FST_OPERATION(FarInfo, ArcType, FarInfoArgs); \
+ REGISTER_FST_OPERATION(FarIsomorphic, ArcType, FarIsomorphicArgs); \
+ REGISTER_FST_OPERATION(FarPrintStrings, ArcType, FarPrintStringsArgs)
+
+#endif // FST_EXTENSIONS_FAR_FARSCRIPT_H_
--- /dev/null
+// 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 <fst/extensions/far/far.h>
+
+namespace fst {
+namespace script {
+
+FarType GetFarType(const string &str);
+
+bool GetFarEntryType(const string &str, FarEntryType *entry_type);
+
+bool GetFarTokenType(const string &str, FarTokenType *token_type);
+
+void ExpandArgs(int argc, char **argv, int *argcp, char ***argvp);
+
+} // namespace script
+
+string GetFarTypeString(FarType type);
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_GETTERS_H_
--- /dev/null
+// 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 <iomanip>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <fst/extensions/far/far.h>
+#include <fst/extensions/far/getters.h>
+
+namespace fst {
+
+template <class Arc>
+void AccumulateStatesAndArcs(const Fst<Arc> &fst, size_t *nstate, size_t *narc,
+ size_t *nfinal) {
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done();
+ siter.Next(), ++(*nstate)) {
+ ArcIterator<Fst<Arc>> aiter(fst, siter.Value());
+ for (; !aiter.Done(); aiter.Next(), ++(*narc)) {
+ }
+ if (fst.Final(siter.Value()) != Arc::Weight::Zero()) ++(*nfinal);
+ }
+}
+
+struct KeyInfo {
+ string key;
+ string type;
+ size_t nstate;
+ size_t narc;
+ size_t nfinal;
+
+ KeyInfo(string k, string t, int64 ns = 0, int64 na = 0, int nf = 0)
+ : key(std::move(k)),
+ type(std::move(t)),
+ nstate(ns),
+ narc(na),
+ nfinal(nf) {}
+};
+
+template <class Arc>
+void FarInfo(const std::vector<string> &filenames, const string &begin_key,
+ const string &end_key, const bool list_fsts) {
+ std::unique_ptr<FarReader<Arc>> reader(FarReader<Arc>::Open(filenames));
+ if (!reader) return;
+ if (!begin_key.empty()) reader->Find(begin_key);
+ auto *infos = list_fsts ? new std::vector<KeyInfo>() : nullptr;
+ size_t nfst = 0;
+ size_t nstate = 0;
+ size_t narc = 0;
+ size_t nfinal = 0;
+ std::set<string> fst_types;
+ for (; !reader->Done(); reader->Next()) {
+ const auto &key = reader->GetKey();
+ if (!end_key.empty() && end_key < key) break;
+ ++nfst;
+ const auto *fst = reader->GetFst();
+ fst_types.insert(fst->Type());
+ if (infos) {
+ KeyInfo info(key, fst->Type());
+ AccumulateStatesAndArcs(*fst, &info.nstate, &info.narc, &info.nfinal);
+ nstate += info.nstate;
+ narc += info.narc;
+ nfinal += info.nfinal;
+ infos->push_back(info);
+ } else {
+ AccumulateStatesAndArcs(*fst, &nstate, &narc, &nfinal);
+ }
+ }
+ if (!infos) {
+ std::cout << std::left << std::setw(50) << "far type"
+ << GetFarTypeString(reader->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 (std::set<string>::const_iterator iter = fst_types.begin();
+ iter != fst_types.end(); ++iter) {
+ if (iter != fst_types.begin()) std::cout << ",";
+ std::cout << *iter;
+ }
+ std::cout << std::endl;
+ std::cout << std::left << std::setw(50) << "# of FSTs" << nfst << std::endl;
+ std::cout << std::left << std::setw(50) << "total # of states" << nstate
+ << std::endl;
+ std::cout << std::left << std::setw(50) << "total # of arcs" << narc
+ << std::endl;
+ std::cout << std::left << std::setw(50) << "total # of final states"
+ << 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 (size_t i = 0; i < infos->size(); ++i) {
+ const auto &info = (*infos)[i];
+ if (info.key.size() + 2 > wkey) wkey = info.key.size() + 2;
+ if (info.type.size() + 2 > wtype) wtype = info.type.size() + 2;
+ if (ceil(log10(info.nstate)) + 2 > wnstate) {
+ wnstate = ceil(log10(info.nstate)) + 2;
+ }
+ if (ceil(log10(info.narc)) + 2 > wnarc) {
+ wnarc = ceil(log10(info.narc)) + 2;
+ }
+ if (ceil(log10(info.nfinal)) + 2 > wnfinal) {
+ wnfinal = ceil(log10(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 (size_t i = 0; i < infos->size(); ++i) {
+ const auto &info = (*infos)[i];
+ std::cout << std::left << std::setw(wkey) << info.key << std::setw(wtype)
+ << info.type << std::right << std::setw(wnstate) << info.nstate
+ << std::setw(wnarc) << info.narc << std::setw(wnfinal)
+ << info.nfinal << std::endl;
+ }
+ }
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_INFO_H_
--- /dev/null
+// 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 <memory>
+#include <string>
+
+#include <fst/extensions/far/far.h>
+#include <fst/isomorphic.h>
+
+namespace fst {
+
+template <class Arc>
+bool FarIsomorphic(const string &filename1, const string &filename2,
+ float delta = kDelta, const string &begin_key = string(),
+ const string &end_key = string()) {
+ std::unique_ptr<FarReader<Arc>> reader1(FarReader<Arc>::Open(filename1));
+ if (!reader1) {
+ LOG(ERROR) << "FarIsomorphic: Cannot open FAR file " << filename1;
+ return false;
+ }
+ std::unique_ptr<FarReader<Arc>> reader2(FarReader<Arc>::Open(filename2));
+ if (!reader2) {
+ LOG(ERROR) << "FarIsomorphic: Cannot open FAR file " << filename2;
+ return false;
+ }
+ if (!begin_key.empty()) {
+ bool find_begin1 = reader1->Find(begin_key);
+ bool find_begin2 = reader2->Find(begin_key);
+ if (!find_begin1 || !find_begin2) {
+ bool ret = !find_begin1 && !find_begin2;
+ if (!ret) {
+ VLOG(1) << "FarIsomorphic: Key " << begin_key << " missing from "
+ << (find_begin1 ? "second" : "first") << " archive.";
+ }
+ return ret;
+ }
+ }
+ for (; !reader1->Done() && !reader2->Done();
+ reader1->Next(), reader2->Next()) {
+ const auto &key1 = reader1->GetKey();
+ const auto &key2 = reader2->GetKey();
+ if (!end_key.empty() && end_key < key1 && end_key < key2) return true;
+ if (key1 != key2) {
+ LOG(ERROR) << "FarIsomorphic: Mismatched keys " << key1 << " and "
+ << key2;
+ return false;
+ }
+ if (!Isomorphic(*(reader1->GetFst()), *(reader2->GetFst()), delta)) {
+ LOG(ERROR) << "FarIsomorphic: FSTs for key " << key1
+ << " are not isomorphic";
+ return false;
+ }
+ }
+ if (!reader1->Done() || !reader2->Done()) {
+ LOG(ERROR) << "FarIsomorphic: Key "
+ << (reader1->Done() ? reader2->GetKey() : reader1->GetKey())
+ << " missing form " << (reader2->Done() ? "first" : "second")
+ << " archive";
+ return false;
+ }
+ return true;
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_ISOMORPHIC_H_
--- /dev/null
+// 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 <iomanip>
+#include <string>
+#include <vector>
+
+#include <fst/extensions/far/far.h>
+#include <fstream>
+#include <fst/shortest-distance.h>
+#include <fst/string.h>
+
+DECLARE_string(far_field_separator);
+
+namespace fst {
+
+template <class Arc>
+void FarPrintStrings(const std::vector<string> &ifilenames,
+ FarEntryType entry_type, FarTokenType far_token_type,
+ const string &begin_key, const string &end_key,
+ bool print_key, bool print_weight,
+ const string &symbols_fname, bool initial_symbols,
+ int32 generate_filenames, const string &filename_prefix,
+ const string &filename_suffix) {
+ StringTokenType token_type;
+ if (far_token_type == FTT_SYMBOL) {
+ token_type = StringTokenType::SYMBOL;
+ } else if (far_token_type == FTT_BYTE) {
+ token_type = StringTokenType::BYTE;
+ } else if (far_token_type == FTT_UTF8) {
+ token_type = StringTokenType::UTF8;
+ } else {
+ FSTERROR() << "FarPrintStrings: Unknown token type";
+ return;
+ }
+ std::unique_ptr<const SymbolTable> syms;
+ if (!symbols_fname.empty()) {
+ // TODO(kbg): Allow negative flag?
+ const SymbolTableTextOptions opts(true);
+ syms.reset(SymbolTable::ReadText(symbols_fname, opts));
+ if (!syms) {
+ LOG(ERROR) << "FarPrintStrings: Error reading symbol table "
+ << symbols_fname;
+ return;
+ }
+ }
+ std::unique_ptr<FarReader<Arc>> far_reader(FarReader<Arc>::Open(ifilenames));
+ if (!far_reader) return;
+ if (!begin_key.empty()) far_reader->Find(begin_key);
+ string okey;
+ int nrep = 0;
+ for (int i = 1; !far_reader->Done(); far_reader->Next(), ++i) {
+ const auto &key = far_reader->GetKey();
+ if (!end_key.empty() && end_key < key) break;
+ if (okey == key) {
+ ++nrep;
+ } else {
+ nrep = 0;
+ }
+ okey = key;
+ const auto *fst = far_reader->GetFst();
+ if (i == 1 && initial_symbols && !syms && fst->InputSymbols())
+ syms.reset(fst->InputSymbols()->Copy());
+ string str;
+ VLOG(2) << "Handling key: " << key;
+ StringPrinter<Arc> string_printer(token_type,
+ syms ? syms.get() : fst->InputSymbols());
+ string_printer(*fst, &str);
+ if (entry_type == FET_LINE) {
+ if (print_key) std::cout << key << FLAGS_far_field_separator[0];
+ std::cout << str;
+ if (print_weight)
+ std::cout << FLAGS_far_field_separator[0] << ShortestDistance(*fst);
+ std::cout << std::endl;
+ } else if (entry_type == FET_FILE) {
+ std::stringstream sstrm;
+ if (generate_filenames) {
+ sstrm.fill('0');
+ sstrm << std::right << std::setw(generate_filenames) << i;
+ } else {
+ sstrm << key;
+ if (nrep > 0) sstrm << "." << nrep;
+ }
+ string filename;
+ filename = filename_prefix + sstrm.str() + filename_suffix;
+ std::ofstream ostrm(filename);
+ if (!ostrm) {
+ LOG(ERROR) << "FarPrintStrings: Can't open file: " << filename;
+ return;
+ }
+ ostrm << str;
+ if (token_type == StringTokenType::SYMBOL) ostrm << "\n";
+ }
+ }
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_PRINT_STRINGS_H_
--- /dev/null
+// 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 <string>
+
+#include <fst/compat.h>
+namespace fst {
+namespace script {
+
+string LoadArcTypeFromFar(const string &far_fname);
+
+string LoadArcTypeFromFst(const string &fst_fname);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_SCRIPT_IMPL_H_
--- /dev/null
+// 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 <algorithm>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <queue>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <fstream>
+#include <fst/util.h>
+
+namespace fst {
+
+static const int32 kSTListMagicNumber = 5656924;
+static const int32 kSTListFileVersion = 1;
+
+// String-type list writing class for object of type T using a functor Writer.
+// Write must provide at least the following interface:
+//
+// struct Writer {
+// void operator()(std::ostream &, const T &) const;
+// };
+template <class T, class Writer>
+class STListWriter {
+ public:
+ explicit STListWriter(const string &filename)
+ : stream_(filename.empty() ? &std::cout : new std::ofstream(
+ filename.c_str(),
+ std::ios_base::out |
+ std::ios_base::binary)),
+ error_(false) {
+ WriteType(*stream_, kSTListMagicNumber);
+ WriteType(*stream_, kSTListFileVersion);
+ if (!stream_) {
+ FSTERROR() << "STListWriter::STListWriter: Error writing to file: "
+ << filename;
+ error_ = true;
+ }
+ }
+
+ static STListWriter<T, Writer> *Create(const string &filename) {
+ return new STListWriter<T, Writer>(filename);
+ }
+
+ void Add(const string &key, const T &t) {
+ if (key == "") {
+ FSTERROR() << "STListWriter::Add: Key empty: " << key;
+ error_ = true;
+ } else if (key < last_key_) {
+ FSTERROR() << "STListWriter::Add: Key out of order: " << key;
+ error_ = true;
+ }
+ if (error_) return;
+ last_key_ = key;
+ WriteType(*stream_, key);
+ entry_writer_(*stream_, t);
+ }
+
+ bool Error() const { return error_; }
+
+ ~STListWriter() {
+ WriteType(*stream_, string());
+ if (stream_ != &std::cout) delete stream_;
+ }
+
+ private:
+ Writer entry_writer_; // Write functor.
+ std::ostream *stream_; // Output stream.
+ string last_key_; // Last key.
+ bool error_;
+
+ STListWriter(const STListWriter &) = delete;
+ STListWriter &operator=(const STListWriter &) = delete;
+};
+
+// String-type list reading class for object of type T using a functor Reader.
+// Reader must provide at least the following interface:
+//
+// struct Reader {
+// T *operator()(std::istream &) const;
+// };
+template <class T, class Reader>
+class STListReader {
+ public:
+ explicit STListReader(const std::vector<string> &filenames)
+ : sources_(filenames), error_(false) {
+ streams_.resize(filenames.size(), 0);
+ bool has_stdin = false;
+ for (size_t i = 0; i < filenames.size(); ++i) {
+ if (filenames[i].empty()) {
+ if (!has_stdin) {
+ streams_[i] = &std::cin;
+ sources_[i] = "stdin";
+ has_stdin = true;
+ } else {
+ FSTERROR() << "STListReader::STListReader: Cannot read multiple "
+ << "inputs from standard input";
+ error_ = true;
+ return;
+ }
+ } else {
+ streams_[i] = new std::ifstream(
+ filenames[i].c_str(), std::ios_base::in | std::ios_base::binary);
+ }
+ int32 magic_number = 0, file_version = 0;
+ ReadType(*streams_[i], &magic_number);
+ ReadType(*streams_[i], &file_version);
+ if (magic_number != kSTListMagicNumber) {
+ FSTERROR() << "STListReader::STListReader: Wrong file type: "
+ << filenames[i];
+ error_ = true;
+ return;
+ }
+ if (file_version != kSTListFileVersion) {
+ FSTERROR() << "STListReader::STListReader: Wrong file version: "
+ << filenames[i];
+ error_ = true;
+ return;
+ }
+ string key;
+ ReadType(*streams_[i], &key);
+ if (!key.empty()) heap_.push(std::make_pair(key, i));
+ if (!*streams_[i]) {
+ FSTERROR() << "STListReader: Error reading file: " << sources_[i];
+ error_ = true;
+ return;
+ }
+ }
+ if (heap_.empty()) return;
+ const auto current = heap_.top().second;
+ entry_.reset(entry_reader_(*streams_[current]));
+ if (!entry_ || !*streams_[current]) {
+ FSTERROR() << "STListReader: Error reading entry for key "
+ << heap_.top().first << ", file " << sources_[current];
+ error_ = true;
+ }
+ }
+
+ ~STListReader() {
+ for (auto &stream : streams_) {
+ if (stream != &std::cin) delete stream;
+ }
+ }
+
+ static STListReader<T, Reader> *Open(const string &filename) {
+ std::vector<string> filenames;
+ filenames.push_back(filename);
+ return new STListReader<T, Reader>(filenames);
+ }
+
+ static STListReader<T, Reader> *Open(const std::vector<string> &filenames) {
+ return new STListReader<T, Reader>(filenames);
+ }
+
+ void Reset() {
+ FSTERROR()
+ << "STListReader::Reset: stlist does not support reset operation";
+ error_ = true;
+ }
+
+ bool Find(const string &key) {
+ FSTERROR() << "STListReader::Find: stlist does not support find operation";
+ error_ = true;
+ return false;
+ }
+
+ bool Done() const { return error_ || heap_.empty(); }
+
+ void Next() {
+ if (error_) return;
+ auto current = heap_.top().second;
+ string key;
+ heap_.pop();
+ ReadType(*(streams_[current]), &key);
+ if (!*streams_[current]) {
+ FSTERROR() << "STListReader: Error reading file: " << sources_[current];
+ error_ = true;
+ return;
+ }
+ if (!key.empty()) heap_.push(std::make_pair(key, current));
+ if (!heap_.empty()) {
+ current = heap_.top().second;
+ entry_.reset(entry_reader_(*streams_[current]));
+ if (!entry_ || !*streams_[current]) {
+ FSTERROR() << "STListReader: Error reading entry for key: "
+ << heap_.top().first << ", file: " << sources_[current];
+ error_ = true;
+ }
+ }
+ }
+
+ const string &GetKey() const { return heap_.top().first; }
+
+ const T *GetEntry() const { return entry_.get(); }
+
+ bool Error() const { return error_; }
+
+ private:
+ Reader entry_reader_; // Read functor.
+ std::vector<std::istream *> streams_; // Input streams.
+ std::vector<string> sources_; // Corresponding filenames.
+ std::priority_queue<
+ std::pair<string, size_t>, std::vector<std::pair<string, size_t>>,
+ std::greater<std::pair<string, size_t>>> heap_; // (Key, stream id) heap
+ mutable std::unique_ptr<T> entry_; // The currently read entry.
+ bool error_;
+
+ STListReader(const STListReader &) = delete;
+ STListReader &operator=(const STListReader &) = delete;
+};
+
+// String-type list header reading function template on the entry header
+// type Header having a member function:
+//
+// Read(std::istream &strm, const string &filename);
+//
+// Checks that the input filename is an STList and calls Header::Read() on the
+// last
+// entry in the STList. Reading from standard input is not supported.
+template <class Header>
+bool ReadSTListHeader(const string &filename, Header *header) {
+ if (filename.empty()) {
+ LOG(ERROR) << "ReadSTListHeader: Can't read header from standard input";
+ return false;
+ }
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ int32 magic_number = 0;
+ int32 file_version = 0;
+ ReadType(strm, &magic_number);
+ ReadType(strm, &file_version);
+ if (magic_number != kSTListMagicNumber) {
+ LOG(ERROR) << "ReadSTListHeader: Wrong file type: " << filename;
+ return false;
+ }
+ if (file_version != kSTListFileVersion) {
+ LOG(ERROR) << "ReadSTListHeader: Wrong file version: " << filename;
+ return false;
+ }
+ string key;
+ ReadType(strm, &key);
+ header->Read(strm, filename + ":" + key);
+ if (!strm) {
+ LOG(ERROR) << "ReadSTListHeader: Error reading file: " << filename;
+ return false;
+ }
+ return true;
+}
+
+bool IsSTList(const string &filename);
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_STLIST_H_
--- /dev/null
+// 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 <algorithm>
+#include <istream>
+#include <memory>
+
+#include <fstream>
+#include <fst/util.h>
+
+namespace fst {
+
+static const int32 kSTTableMagicNumber = 2125656924;
+static const int32 kSTTableFileVersion = 1;
+
+// String-to-type table writing class for object of type 'T' using functor 'W'
+// to write an object of type 'T' from a stream. 'W' must conform to the
+// following interface:
+//
+// struct Writer {
+// void operator()(std::ostream &, const T &) const;
+// };
+//
+template <class T, class W>
+class STTableWriter {
+ public:
+ typedef T EntryType;
+ typedef W EntryWriter;
+
+ explicit STTableWriter(const string &filename)
+ : stream_(filename.c_str(), std::ios_base::out | std::ios_base::binary),
+ error_(false) {
+ WriteType(stream_, kSTTableMagicNumber);
+ WriteType(stream_, kSTTableFileVersion);
+ if (stream_.fail()) {
+ FSTERROR() << "STTableWriter::STTableWriter: Error writing to file: "
+ << filename;
+ error_ = true;
+ }
+ }
+
+ static STTableWriter<T, W> *Create(const string &filename) {
+ if (filename.empty()) {
+ LOG(ERROR) << "STTableWriter: Writing to standard out unsupported.";
+ return nullptr;
+ }
+ return new STTableWriter<T, W>(filename);
+ }
+
+ void Add(const string &key, const T &t) {
+ if (key == "") {
+ FSTERROR() << "STTableWriter::Add: Key empty: " << key;
+ error_ = true;
+ } else if (key < last_key_) {
+ FSTERROR() << "STTableWriter::Add: Key out of order: " << key;
+ error_ = true;
+ }
+ if (error_) return;
+ last_key_ = key;
+ positions_.push_back(stream_.tellp());
+ WriteType(stream_, key);
+ entry_writer_(stream_, t);
+ }
+
+ bool Error() const { return error_; }
+
+ ~STTableWriter() {
+ WriteType(stream_, positions_);
+ WriteType(stream_, static_cast<int64>(positions_.size()));
+ }
+
+ private:
+ EntryWriter entry_writer_; // Write functor for 'EntryType'
+ std::ofstream stream_; // Output stream
+ std::vector<int64> positions_; // Position in file of each key-entry pair
+ string last_key_; // Last key
+ bool error_;
+
+ STTableWriter(const STTableWriter &) = delete;
+ STTableWriter &operator=(const STTableWriter &) = delete;
+};
+
+// String-to-type table reading class for object of type 'T' using functor 'R'
+// to read an object of type 'T' form a stream. 'R' must conform to the
+// following interface:
+//
+// struct Reader {
+// T *operator()(std::istream &) const;
+// };
+//
+template <class T, class R>
+class STTableReader {
+ public:
+ typedef T EntryType;
+ typedef R EntryReader;
+
+ explicit STTableReader(const std::vector<string> &filenames)
+ : sources_(filenames), error_(false) {
+ compare_.reset(new Compare(&keys_));
+ keys_.resize(filenames.size());
+ streams_.resize(filenames.size(), 0);
+ positions_.resize(filenames.size());
+ for (size_t i = 0; i < filenames.size(); ++i) {
+ streams_[i] = new std::ifstream(
+ filenames[i].c_str(), std::ios_base::in | std::ios_base::binary);
+ int32 magic_number = 0, file_version = 0;
+ ReadType(*streams_[i], &magic_number);
+ ReadType(*streams_[i], &file_version);
+ if (magic_number != kSTTableMagicNumber) {
+ FSTERROR() << "STTableReader::STTableReader: Wrong file type: "
+ << filenames[i];
+ error_ = true;
+ return;
+ }
+ if (file_version != kSTTableFileVersion) {
+ FSTERROR() << "STTableReader::STTableReader: Wrong file version: "
+ << filenames[i];
+ error_ = true;
+ return;
+ }
+ int64 num_entries;
+ streams_[i]->seekg(-static_cast<int>(sizeof(int64)), ios_base::end);
+ ReadType(*streams_[i], &num_entries);
+ if (num_entries > 0) {
+ streams_[i]->seekg(-static_cast<int>(sizeof(int64)) * (num_entries + 1),
+ ios_base::end);
+ positions_[i].resize(num_entries);
+ for (size_t j = 0; (j < num_entries) && (!streams_[i]->fail()); ++j)
+ ReadType(*streams_[i], &(positions_[i][j]));
+ streams_[i]->seekg(positions_[i][0]);
+ if (streams_[i]->fail()) {
+ FSTERROR() << "STTableReader::STTableReader: Error reading file: "
+ << filenames[i];
+ error_ = true;
+ return;
+ }
+ }
+ }
+ MakeHeap();
+ }
+
+ ~STTableReader() {
+ for (size_t i = 0; i < streams_.size(); ++i) delete streams_[i];
+ }
+
+ static STTableReader<T, R> *Open(const string &filename) {
+ if (filename.empty()) {
+ LOG(ERROR) << "STTableReader: operation not supported on stdin";
+ return nullptr;
+ }
+ std::vector<string> filenames;
+ filenames.push_back(filename);
+ return new STTableReader<T, R>(filenames);
+ }
+
+ static STTableReader<T, R> *Open(const std::vector<string> &filenames) {
+ return new STTableReader<T, R>(filenames);
+ }
+
+ void Reset() {
+ if (error_) return;
+ for (size_t i = 0; i < streams_.size(); ++i)
+ streams_[i]->seekg(positions_[i].front());
+ MakeHeap();
+ }
+
+ bool Find(const string &key) {
+ if (error_) return false;
+ for (size_t i = 0; i < streams_.size(); ++i) LowerBound(i, key);
+ MakeHeap();
+ if (heap_.empty()) return false;
+ return keys_[current_] == key;
+ }
+
+ bool Done() const { return error_ || heap_.empty(); }
+
+ void Next() {
+ if (error_) return;
+ if (streams_[current_]->tellg() <= positions_[current_].back()) {
+ ReadType(*(streams_[current_]), &(keys_[current_]));
+ if (streams_[current_]->fail()) {
+ FSTERROR() << "STTableReader: Error reading file: "
+ << sources_[current_];
+ error_ = true;
+ return;
+ }
+ std::push_heap(heap_.begin(), heap_.end(), *compare_);
+ } else {
+ heap_.pop_back();
+ }
+ if (!heap_.empty()) PopHeap();
+ }
+
+ const string &GetKey() const { return keys_[current_]; }
+
+ const EntryType *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<string> *k) : keys(k) {}
+
+ bool operator()(size_t i, size_t j) const {
+ return (*keys)[i] > (*keys)[j];
+ };
+
+ private:
+ const std::vector<string> *keys;
+ };
+
+ // Position the stream with ID 'id' at the position corresponding
+ // to the lower bound for key 'find_key'
+ void LowerBound(size_t id, const string &find_key) {
+ std::istream *strm = streams_[id];
+ const std::vector<int64> &positions = positions_[id];
+ if (positions.empty()) return;
+ size_t low = 0;
+ size_t high = positions.size() - 1;
+
+ while (low < high) {
+ size_t mid = (low + high) / 2;
+ strm->seekg(positions[mid]);
+ string key;
+ ReadType(*strm, &key);
+ if (key > find_key) {
+ high = mid;
+ } else if (key < find_key) {
+ low = mid + 1;
+ } else {
+ for (size_t i = mid; i > low; --i) {
+ strm->seekg(positions[i - 1]);
+ ReadType(*strm, &key);
+ if (key != find_key) {
+ strm->seekg(positions[i]);
+ return;
+ }
+ }
+ strm->seekg(positions[low]);
+ return;
+ }
+ }
+ strm->seekg(positions[low]);
+ }
+
+ // Add 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();
+ }
+
+ // Position the stream with the lowest key at the top
+ // of the heap, set 'current_' to the ID of that stream
+ // and read 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;
+ }
+ }
+
+ EntryReader entry_reader_; // Read functor for 'EntryType'
+ std::vector<std::istream *> streams_; // Input streams
+ std::vector<string> sources_; // and corresponding file names
+ std::vector<std::vector<int64>> positions_; // Index of positions
+ std::vector<string> keys_; // Lowest unread key for each stream
+ std::vector<int64> heap_; // Heap containing ID of streams with unread keys
+ int64 current_; // Id of current stream to be read
+ std::unique_ptr<Compare> compare_; // Functor comparing stream IDs
+ mutable std::unique_ptr<EntryType> entry_; // the currently read entry
+ bool error_;
+};
+
+// String-to-type table header reading function template on the entry header
+// type 'H' having a member function:
+// Read(std::istream &strm, const string &filename);
+// Checks that 'filename' is an STTable and call the H::Read() on the last
+// entry in the STTable.
+template <class H>
+bool ReadSTTableHeader(const string &filename, H *header) {
+ std::ifstream strm(filename);
+ int32 magic_number = 0;
+ int32 file_version = 0;
+ ReadType(strm, &magic_number);
+ ReadType(strm, &file_version);
+ if (magic_number != kSTTableMagicNumber) {
+ LOG(ERROR) << "ReadSTTableHeader: Wrong file type: " << filename;
+ return false;
+ }
+ if (file_version != kSTTableFileVersion) {
+ LOG(ERROR) << "ReadSTTableHeader: Wrong file version: " << filename;
+ return false;
+ }
+ int64 i = -1;
+ strm.seekg(-static_cast<int>(sizeof(int64)), ios_base::end);
+ ReadType(strm, &i); // Read number of entries
+ if (strm.fail()) {
+ LOG(ERROR) << "ReadSTTableHeader: Error reading file: " << filename;
+ return false;
+ }
+ if (i == 0) return true; // No entry header to read
+ strm.seekg(-2 * static_cast<int>(sizeof(int64)), ios_base::end);
+ ReadType(strm, &i); // Read position for last entry in file
+ strm.seekg(i);
+ string key;
+ ReadType(strm, &key);
+ header->Read(strm, filename + ":" + key);
+ if (strm.fail()) {
+ LOG(ERROR) << "ReadSTTableHeader: Error reading file: " << filename;
+ return false;
+ }
+ return true;
+}
+
+bool IsSTTable(const string &filename);
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_FAR_STTABLE_H_
--- /dev/null
+// 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 <map>
+#include <queue>
+#include <set>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/fst.h>
+#include <fst/symbol-table.h>
+#include <fst/util.h>
+
+#include <fst/extensions/linear/linear-fst-data.h>
+
+namespace fst {
+
+// Forward declaration
+template <class A>
+class FeatureGroupBuilder;
+
+// For logging purposes
+inline string TranslateLabel(int64 label, const SymbolTable *syms);
+template <class Iterator>
+string JoinLabels(Iterator begin, Iterator end, const SymbolTable *syms);
+template <class Label>
+string JoinLabels(const std::vector<Label> &labels, const SymbolTable *syms);
+
+// Guesses the appropriate boundary label (start- or end-of-sentence)
+// for all labels equal to `boundary` and modifies the `sequence`
+// in-place. Returns the number of positions that are still uncertain.
+template <class A>
+typename A::Label GuessStartOrEnd(std::vector<typename A::Label> *sequence,
+ typename A::Label boundary);
+
+// Builds a `LinearFstData` object by adding words and feature
+// weights. A few conventions:
+//
+// - Input labels forms a dense non-empty range from 1 to `MaxInputLabel()`.
+// - Feature labels, output labels are > 0.
+// - Being a discriminative linear model, it only makes sense to use tropical
+// semirings.
+template <class A>
+class LinearFstDataBuilder {
+ public:
+ typedef typename A::Label Label;
+ typedef typename A::Weight Weight;
+
+ // Constructs a builder with associated symbol tables for diagonstic
+ // output. Each of these symbol tables may also be nullptr.
+ explicit LinearFstDataBuilder(const SymbolTable *isyms = nullptr,
+ const SymbolTable *fsyms = nullptr,
+ const SymbolTable *osyms = nullptr)
+ : error_(false),
+ max_future_size_(0),
+ max_input_label_(1),
+ isyms_(isyms),
+ fsyms_(fsyms),
+ osyms_(osyms) {}
+
+ // 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 word and its feature labels to the vocabulary; this
+ // version allows the word to have any output label. Returns true
+ // iff the word is added.
+ //
+ // This may fail if the word is added twice or if the feature labels
+ // are non-positive.
+ bool AddWord(Label word, const std::vector<Label> &features);
+
+ // Adds a word and its feature labels to the vocabulary; this
+ // version puts constraint on possible output labels the word can
+ // have. `possible_output` must not be empty. Returns true iff the
+ // word is added.
+ //
+ // In addition to the reasons above in the two-parameter version,
+ // this may also fail if `possible_output` is empty or any output
+ // label in it is non-positive.
+ bool AddWord(Label word, const std::vector<Label> &word_features,
+ const std::vector<Label> &possible_output);
+
+ // Creates a new feature group with specified future size (size of
+ // the look-ahead window), returns the group id to be used for
+ // adding actual feature weights or a negative number when called at
+ // error state.
+ //
+ // This does not fail unless called at error state.
+ int AddGroup(size_t future_size);
+
+ // Adds an instance of feature weight to the specified feature
+ // group. If some weight has already been added with the same
+ // feature, the product of the old and new weights are
+ // stored. Returns true iff the weight is added. A weight is not
+ // added when the context has ill-formed context involving start-,
+ // end-of-sentence marks.
+ //
+ // For two features to be within the same group, it must satisfy
+ // that (1) they have the same future size; (2) the two either have
+ // disjoint context or one is the back-off context of the
+ // other. Furthermore, for all features in a single group, there
+ // must be one and only one other context (not necessarily an active
+ // feature) that the feature immediately backs off to (i.e. there is
+ // no other context that is the back-off of the first and backs off
+ // to the second).
+ //
+ // Consider for example features with zero look-ahead of the form
+ // (input, OUTPUT).
+ //
+ // - The following two features can be put in the same group because
+ // their context is disjoint: (a a a, A A), (b, B B);
+ //
+ // - The following two features can be put in the same group because
+ // one is the back-off context of the other: (a a a, A A), (a a, A
+ // A);
+ //
+ // - The following two features can NOT be put in the same group
+ // because there is overlap but neither is the other's back-off: (a
+ // a a, A), (a a, A A);
+ //
+ // - Finally, the following three features cannot be in a same group
+ // because the first one can immediately back off to either of the
+ // rest: (a a a, A A), (a a, A A), (a a a, A).
+ //
+ // The easiest way to satisfy the constraints is to create a feature
+ // group for each feature template. However, better feature grouping
+ // may help improve speed.
+ //
+ // This may fail if any of input or output labels are non-positive,
+ // or if any call to `FeatureGroupBuilder<>::AddWeight()` fails.
+ bool AddWeight(size_t group, const std::vector<Label> &input,
+ const std::vector<Label> &output, Weight weight);
+
+ // Returns a newly created `LinearFstData` object or nullptr in case
+ // of failure. The caller takes the ownership of the memory. No
+ // other methods shall be called after this --- this is enforced by
+ // putting the builder at error state, even when a
+ // `LinearFstData<>` object is successfully built.
+ //
+ // This may fail if the call to any `FeatureGroupBuilder<>::Dump()`
+ // fails.
+ LinearFstData<A> *Dump();
+
+ private:
+ bool error_;
+ CompactSet<Label, kNoLabel> all_output_labels_;
+ std::map<Label, std::set<Label>> word_output_map_, word_feat_map_;
+ std::map<Label, std::set<size_t>> feat_groups_;
+ std::vector<std::unique_ptr<FeatureGroupBuilder<A>>> 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 A>
+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<Label> &features);
+
+ // Adds a logical feature group. Similar to
+ // LinearFstDataBuilder<>::AddGroup(), with the exception that the
+ // returned group id is the logical group id. Also there is no need
+ // for "future" in a classifier.
+ int AddGroup();
+
+ // Adds an instance of feature weight to the specified logical
+ // feature group. Instead of a vector of output, only a single
+ // prediction is needed as the output.
+ //
+ // This may fail if `pred` is not in the range of [1, num_classes_].
+ bool AddWeight(size_t group, const std::vector<Label> &input, Label pred,
+ Weight weight);
+
+ // Returns a newly created `LinearFstData` object or nullptr in case of
+ // failure.
+ LinearFstData<A> *Dump();
+
+ private:
+ std::vector<Label> empty_;
+ bool error_;
+ size_t num_classes_, num_groups_;
+ LinearFstDataBuilder<A> builder_;
+};
+
+// Builds a single feature group. Usually used in
+// `LinearFstDataBuilder::AddWeight()`. See that method for the
+// constraints on grouping features.
+template <class A>
+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<Label> &input,
+ const std::vector<Label> &output, Weight weight);
+
+ // Creates an actual FeatureGroup<> object. Connects back-off links;
+ // pre-accumulates weights from back-off features. Returns nullptr if
+ // there is any violation in unique immediate back-off
+ // constraints.
+ //
+ // Regardless of whether the call succeeds or not, the error flag is
+ // always set before this returns, to prevent repeated dumping.
+ //
+ // TODO(wuke): check overlapping top-level contexts (see
+ // `DumpOverlappingContext()` in tests).
+ FeatureGroup<A> *Dump(size_t max_future_size);
+
+ private:
+ typedef typename FeatureGroup<A>::InputOutputLabel InputOutputLabel;
+ typedef typename FeatureGroup<A>::InputOutputLabelHash InputOutputLabelHash;
+ typedef typename FeatureGroup<A>::WeightBackLink WeightBackLink;
+ // Nested trie topology uses more memory but we can traverse a
+ // node's children easily, which is required in `BuildBackLinks()`.
+ typedef NestedTrieTopology<InputOutputLabel, InputOutputLabelHash> Topology;
+ typedef MutableTrie<InputOutputLabel, WeightBackLink, Topology> 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<InputOutputLabel> *path) const;
+ string TriePath(int node, const Topology &topology) const;
+
+ bool error_;
+ size_t future_size_;
+ Trie trie_;
+ int start_;
+ const SymbolTable *fsyms_, *osyms_;
+
+ FeatureGroupBuilder(const FeatureGroupBuilder &) = delete;
+ FeatureGroupBuilder &operator=(const FeatureGroupBuilder &) = delete;
+};
+
+//
+// Implementation of methods in `LinearFstDataBuilder`
+//
+template <class A>
+bool LinearFstDataBuilder<A>::AddWord(Label word,
+ const std::vector<Label> &features) {
+ if (error_) {
+ FSTERROR() << "Calling LinearFstDataBuilder<>::AddWord() at error state";
+ return false;
+ }
+ if (word == LinearFstData<A>::kStartOfSentence ||
+ word == LinearFstData<A>::kEndOfSentence) {
+ LOG(WARNING) << "Ignored: adding boundary label: "
+ << TranslateLabel(word, isyms_)
+ << "(start-of-sentence=" << LinearFstData<A>::kStartOfSentence
+ << ", end-of-sentence=" << LinearFstData<A>::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<Label> *feats = &word_feat_map_[word];
+ for (size_t i = 0; i < features.size(); ++i) {
+ Label feat = features[i];
+ if (feat <= 0) {
+ error_ = true;
+ FSTERROR() << "Feature label must be > 0; got " << feat;
+ return false;
+ }
+ feats->insert(feat);
+ }
+ return true;
+}
+
+template <class A>
+bool LinearFstDataBuilder<A>::AddWord(
+ Label word, const std::vector<Label> &word_features,
+ const std::vector<Label> &possible_output) {
+ if (error_) {
+ FSTERROR() << "Calling LinearFstDataBuilder<>::AddWord() at error state";
+ return false;
+ }
+ if (!AddWord(word, word_features)) return false;
+ // Store possible output constraint
+ if (possible_output.empty()) {
+ error_ = true;
+ FSTERROR() << "Empty possible output constraint; "
+ << "use the two-parameter version if no constraint is need.";
+ return false;
+ }
+ std::set<Label> *outputs = &word_output_map_[word];
+ for (size_t i = 0; i < possible_output.size(); ++i) {
+ Label output = possible_output[i];
+ if (output == LinearFstData<A>::kStartOfSentence ||
+ output == LinearFstData<A>::kEndOfSentence) {
+ LOG(WARNING) << "Ignored: word = " << TranslateLabel(word, isyms_)
+ << ": adding boundary label as possible output: " << output
+ << "(start-of-sentence="
+ << LinearFstData<A>::kStartOfSentence
+ << ", end-of-sentence=" << LinearFstData<A>::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 <class A>
+inline int LinearFstDataBuilder<A>::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<A>(future_size, fsyms_, osyms_));
+ if (future_size > max_future_size_) max_future_size_ = future_size;
+ return ret;
+}
+
+template <class A>
+bool LinearFstDataBuilder<A>::AddWeight(size_t group,
+ const std::vector<Label> &input,
+ const std::vector<Label> &output,
+ Weight weight) {
+ if (error_) {
+ FSTERROR() << "Calling LinearFstDataBuilder<>::AddWeight() at error state";
+ return false;
+ }
+ // Check well-formedness of boundary marks on the input.
+ {
+ bool start_in_middle = false, end_in_middle = false;
+ for (int i = 1; i < input.size(); ++i) {
+ if (input[i] == LinearFstData<A>::kStartOfSentence &&
+ input[i - 1] != LinearFstData<A>::kStartOfSentence)
+ start_in_middle = true;
+ if (input[i - 1] == LinearFstData<A>::kEndOfSentence &&
+ input[i] != LinearFstData<A>::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<A>::kStartOfSentence)
+ non_first_start = true;
+ if (output[i - 1] == LinearFstData<A>::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<A>::kStartOfSentence &&
+ feat != LinearFstData<A>::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<A>::kStartOfSentence &&
+ label != LinearFstData<A>::kEndOfSentence && label <= 0) {
+ error_ = true;
+ FSTERROR() << "Output label must be > 0; got " << label;
+ return false;
+ }
+ if (label != LinearFstData<A>::kStartOfSentence &&
+ label != LinearFstData<A>::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 <class A>
+LinearFstData<A> *LinearFstDataBuilder<A>::Dump() {
+ if (error_) {
+ FSTERROR() << "Calling LinearFstDataBuilder<>::Dump() at error state";
+ return nullptr;
+ }
+
+ std::unique_ptr<LinearFstData<A>> data(new LinearFstData<A>());
+ 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<A> *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<Label, std::set<Label>>::const_iterator it =
+ word_feat_map_.find(word);
+ if (it == word_feat_map_.end()) continue;
+ for (typename std::set<Label>::const_iterator oit = it->second.begin();
+ oit != it->second.end(); ++oit) {
+ Label feat = *oit;
+ typename std::map<Label, std::set<size_t>>::const_iterator jt =
+ feat_groups_.find(feat);
+ if (jt == feat_groups_.end()) continue;
+ for (std::set<size_t>::const_iterator git = jt->second.begin();
+ git != jt->second.end(); ++git) {
+ size_t group_id = *git;
+ if (!data->group_feat_map_.Set(group_id, word, feat)) {
+ error_ = true;
+ return nullptr;
+ }
+ }
+ }
+ }
+
+ // Possible output labels
+ {
+ std::vector<typename LinearFstData<A>::InputAttribute> *input_attribs =
+ &data->input_attribs_;
+ std::vector<Label> *output_pool = &data->output_pool_;
+ input_attribs->resize(max_input_label_ + 1);
+ for (Label word = 0; word <= max_input_label_; ++word) {
+ typename std::map<Label, std::set<Label>>::const_iterator it =
+ word_output_map_.find(word);
+ if (it == word_output_map_.end()) {
+ (*input_attribs)[word].output_begin = 0;
+ (*input_attribs)[word].output_length = 0;
+ } else {
+ (*input_attribs)[word].output_begin = output_pool->size();
+ (*input_attribs)[word].output_length = it->second.size();
+ for (typename std::set<Label>::const_iterator oit = it->second.begin();
+ oit != it->second.end(); ++oit) {
+ Label olabel = *oit;
+ output_pool->push_back(olabel);
+ }
+ }
+ }
+ }
+
+ for (typename CompactSet<Label, kNoLabel>::const_iterator it =
+ all_output_labels_.Begin();
+ it != all_output_labels_.End(); ++it)
+ data->output_set_.push_back(*it);
+
+ error_ = true; // prevent future calls on this object
+ return data.release();
+}
+
+//
+// Implementation of methods in `LinearClassifierFstDataBuilder`
+//
+template <class A>
+inline bool LinearClassifierFstDataBuilder<A>::AddWord(
+ Label word, const std::vector<Label> &features) {
+ if (error_) {
+ FSTERROR() << "Calling LinearClassifierFstDataBuilder<>::AddWord() at "
+ "error state";
+ return false;
+ }
+ bool added = builder_.AddWord(word, features);
+ if (builder_.Error()) error_ = true;
+ return added;
+}
+
+template <class A>
+inline int LinearClassifierFstDataBuilder<A>::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 <class A>
+inline bool LinearClassifierFstDataBuilder<A>::AddWeight(
+ size_t group, const std::vector<Label> &input, Label pred, Weight weight) {
+ if (error_) {
+ FSTERROR() << "Calling LinearClassifierFstDataBuilder<>::AddWeight() at "
+ "error state";
+ return false;
+ }
+ if (pred <= 0 || pred > num_classes_) {
+ FSTERROR() << "Out-of-range prediction label: " << pred
+ << " (num classes = " << num_classes_ << ")";
+ error_ = true;
+ return false;
+ }
+ size_t real_group = group * num_classes_ + pred - 1;
+ bool added = builder_.AddWeight(real_group, input, empty_, weight);
+ if (builder_.Error()) error_ = true;
+ return added;
+}
+
+template <class A>
+inline LinearFstData<A> *LinearClassifierFstDataBuilder<A>::Dump() {
+ if (error_) {
+ FSTERROR()
+ << "Calling LinearClassifierFstDataBuilder<>::Dump() at error state";
+ return nullptr;
+ }
+ LinearFstData<A> *data = builder_.Dump();
+ error_ = true;
+ return data;
+}
+
+//
+// Implementation of methods in `FeatureGroupBuilder`
+//
+template <class A>
+bool FeatureGroupBuilder<A>::AddWeight(const std::vector<Label> &input,
+ const std::vector<Label> &output,
+ Weight weight) {
+ if (error_) {
+ FSTERROR() << "Calling FeatureGroupBuilder<>::AddWeight() at error state";
+ return false;
+ }
+
+ // `LinearFstDataBuilder<>::AddWeight()` ensures prefix/suffix
+ // properties for us. We can directly count.
+ int num_input_start = 0;
+ while (num_input_start < input.size() &&
+ input[num_input_start] == LinearFstData<A>::kStartOfSentence)
+ ++num_input_start;
+ int num_output_start = 0;
+ while (num_output_start < output.size() &&
+ output[num_output_start] == LinearFstData<A>::kStartOfSentence)
+ ++num_output_start;
+ int num_input_end = 0;
+ for (int i = input.size() - 1;
+ i >= 0 && input[i] == LinearFstData<A>::kEndOfSentence; --i)
+ ++num_input_end;
+ int num_output_end = 0;
+ for (int i = output.size() - 1;
+ i >= 0 && output[i] == LinearFstData<A>::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 <class A>
+FeatureGroup<A> *FeatureGroupBuilder<A>::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<A> *ret =
+ new FeatureGroup<A>(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<A>::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 <class A>
+int FeatureGroupBuilder<A>::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 <class A>
+void FeatureGroupBuilder<A>::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<int> 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<InputOutputLabel, int> &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 <class A>
+void FeatureGroupBuilder<A>::PreAccumulateWeights() {
+ std::vector<bool> visited(trie_.NumNodes(), false);
+ visited[trie_.Root()] = true;
+
+ for (size_t i = 0; i != trie_.NumNodes(); ++i) {
+ std::stack<int> 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 <class A>
+bool FeatureGroupBuilder<A>::TrieDfs(
+ const Topology &topology, int cur, int target,
+ std::vector<InputOutputLabel> *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<InputOutputLabel, int> &edge = *eit;
+ path->push_back(edge.first);
+ if (TrieDfs(topology, edge.second, target, path)) return true;
+ path->pop_back();
+ }
+ return false;
+}
+
+template <class A>
+string FeatureGroupBuilder<A>::TriePath(int node,
+ const Topology &topology) const {
+ std::vector<InputOutputLabel> labels;
+ TrieDfs(topology, topology.Root(), node, &labels);
+ bool first = true;
+ std::ostringstream strm;
+ for (typename std::vector<InputOutputLabel>::const_iterator it =
+ labels.begin();
+ it != labels.end(); ++it) {
+ InputOutputLabel i = *it;
+ if (first)
+ first = false;
+ else
+ strm << ", ";
+ strm << "(" << TranslateLabel(i.input, fsyms_) << ", "
+ << TranslateLabel(i.output, osyms_) << ")";
+ }
+ return strm.str();
+}
+
+inline string TranslateLabel(int64 label, const SymbolTable *syms) {
+ string ret;
+ if (syms != nullptr) ret += syms->Find(label);
+ if (ret.empty()) {
+ std::ostringstream strm;
+ strm << '<' << label << '>';
+ ret = strm.str();
+ }
+ return ret;
+}
+
+template <class Iterator>
+string JoinLabels(Iterator begin, Iterator end, const SymbolTable *syms) {
+ if (begin == end) return "<empty>";
+ 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 <class Label>
+string JoinLabels(const std::vector<Label> &labels, const SymbolTable *syms) {
+ return JoinLabels(labels.begin(), labels.end(), syms);
+}
+
+template <class A>
+typename A::Label GuessStartOrEnd(std::vector<typename A::Label> *sequence,
+ typename A::Label boundary) {
+ const size_t length = sequence->size();
+ std::vector<bool> non_boundary_on_left(length, false),
+ non_boundary_on_right(length, false);
+ for (size_t i = 1; i < length; ++i) {
+ non_boundary_on_left[i] =
+ non_boundary_on_left[i - 1] || (*sequence)[i - 1] != boundary;
+ non_boundary_on_right[length - 1 - i] = non_boundary_on_right[length - i] ||
+ (*sequence)[length - i] != boundary;
+ }
+ int unresolved = 0;
+ for (size_t i = 0; i < length; ++i) {
+ if ((*sequence)[i] != boundary) continue;
+ const bool left = non_boundary_on_left[i], right = non_boundary_on_right[i];
+ if (left && right) {
+ // Boundary in the middle
+ LOG(WARNING) << "Boundary label in the middle of the sequence! position: "
+ << i << "; boundary: " << boundary
+ << "; sequence: " << JoinLabels(*sequence, nullptr);
+ LOG(WARNING)
+ << "This is an invalid sequence anyway so I will set it to start.";
+ (*sequence)[i] = LinearFstData<A>::kStartOfSentence;
+ } else if (left && !right) {
+ // Can only be end
+ (*sequence)[i] = LinearFstData<A>::kEndOfSentence;
+ } else if (!left && right) {
+ // Can only be start
+ (*sequence)[i] = LinearFstData<A>::kStartOfSentence;
+ } else {
+ // !left && !right; can't really tell
+ ++unresolved;
+ }
+ }
+ return unresolved;
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_LINEAR_LINEAR_FST_DATA_BUILDER_H_
--- /dev/null
+// 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 <memory>
+#include <numeric>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/fst.h>
+
+#include <fst/extensions/linear/trie.h>
+
+namespace fst {
+
+// Forward declarations
+template <class A>
+class LinearFstDataBuilder;
+template <class A>
+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 A>
+class LinearFstData {
+ public:
+ friend class LinearFstDataBuilder<A>; // 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<Label> *output) const {
+ for (int i = 0; i < NumGroups(); ++i) output->push_back(GroupStartState(i));
+ }
+
+ // Takes a transition from the trie states stored in
+ // `(trie_state_begin, trie_state_end)` with input label `ilabel`
+ // and output label `olabel`; appends the destination state tuple to
+ // `next` and multiplies the weight of the transition onto
+ // `weight`. `next` should be the shifted input buffer of the caller
+ // in `LinearTaggerFstImpl` (i.e. of size `LinearTaggerFstImpl::delay_`;
+ // the last element is `ilabel`).
+ template <class Iterator>
+ void TakeTransition(Iterator buffer_end, Iterator trie_state_begin,
+ Iterator trie_state_end, Label ilabel, Label olabel,
+ std::vector<Label> *next, Weight *weight) const;
+
+ // Returns the final weight of the given trie state sequence.
+ template <class Iterator>
+ Weight FinalWeight(Iterator trie_state_begin, Iterator trie_state_end) const;
+
+ // Returns the start trie state of the given group.
+ Label GroupStartState(int group_id) const {
+ return groups_[group_id]->Start();
+ }
+
+ // Takes a transition only within the given group. Returns the
+ // destination trie state and multiplies the weight onto `weight`.
+ Label GroupTransition(int group_id, int trie_state, Label ilabel,
+ Label olabel, Weight *weight) const;
+
+ // Returns the final weight of the given trie state in the given group.
+ Weight GroupFinalWeight(int group_id, int trie_state) const {
+ return groups_[group_id]->FinalWeight(trie_state);
+ }
+
+ Label MinInputLabel() const { return 1; }
+
+ Label MaxInputLabel() const { return max_input_label_; }
+
+ // Returns the maximum future size of all feature groups. Future is
+ // the look-ahead window of a feature, e.g. if a feature looks at
+ // the next 2 words after the current input, then the future size is
+ // 2. There is no look-ahead for output. Features inside a single
+ // `FeatureGroup` must have equal future size.
+ size_t MaxFutureSize() const { return max_future_size_; }
+
+ // Returns the number of feature groups
+ size_t NumGroups() const { return groups_.size(); }
+
+ // Returns the range of possible output labels for an input label.
+ std::pair<typename std::vector<Label>::const_iterator,
+ typename std::vector<Label>::const_iterator>
+ PossibleOutputLabels(Label word) const;
+
+ static LinearFstData<A> *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<std::unique_ptr<const FeatureGroup<A>>> groups_;
+ std::vector<InputAttribute> input_attribs_;
+ std::vector<Label> output_pool_, output_set_;
+ GroupFeatureMap group_feat_map_;
+
+ LinearFstData(const LinearFstData &) = delete;
+ LinearFstData &operator=(const LinearFstData &) = delete;
+};
+
+template <class A>
+const typename A::Label LinearFstData<A>::kStartOfSentence = -3;
+template <class A>
+const typename A::Label LinearFstData<A>::kEndOfSentence = -2;
+
+template <class A>
+template <class Iterator>
+void LinearFstData<A>::TakeTransition(Iterator buffer_end,
+ Iterator trie_state_begin,
+ Iterator trie_state_end, Label ilabel,
+ Label olabel, std::vector<Label> *next,
+ Weight *weight) const {
+ DCHECK_EQ(trie_state_end - trie_state_begin, groups_.size());
+ DCHECK(ilabel > 0 || ilabel == kEndOfSentence);
+ DCHECK(olabel > 0 || olabel == kStartOfSentence);
+ size_t group_id = 0;
+ for (Iterator it = trie_state_begin; it != trie_state_end; ++it, ++group_id) {
+ size_t delay = groups_[group_id]->Delay();
+ // On the buffer, there may also be `kStartOfSentence` from the
+ // initial empty buffer.
+ Label real_ilabel = delay == 0 ? ilabel : *(buffer_end - delay);
+ next->push_back(
+ GroupTransition(group_id, *it, real_ilabel, olabel, weight));
+ }
+}
+
+template <class A>
+typename A::Label LinearFstData<A>::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 <class A>
+template <class Iterator>
+inline typename A::Weight LinearFstData<A>::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 <class A>
+inline std::pair<typename std::vector<typename A::Label>::const_iterator,
+ typename std::vector<typename A::Label>::const_iterator>
+LinearFstData<A>::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 <class A>
+inline LinearFstData<A> *LinearFstData<A>::Read(std::istream &strm) { // NOLINT
+ std::unique_ptr<LinearFstData<A>> data(new LinearFstData<A>());
+ 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<A>::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 <class A>
+inline std::ostream &LinearFstData<A>::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 <class A>
+typename A::Label LinearFstData<A>::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 <class A>
+inline std::istream &LinearFstData<A>::InputAttribute::Read(
+ std::istream &strm) { // NOLINT
+ ReadType(strm, &output_begin);
+ ReadType(strm, &output_length);
+ return strm;
+}
+
+template <class A>
+inline std::ostream &LinearFstData<A>::InputAttribute::Write(
+ std::ostream &strm) const { // NOLINT
+ WriteType(strm, output_begin);
+ WriteType(strm, output_length);
+ return strm;
+}
+
+// Forward declaration
+template <class A>
+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 A>
+class FeatureGroup {
+ public:
+ friend class FeatureGroupBuilder<A>; // 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<A> *Read(std::istream &strm) { // NOLINT
+ size_t delay;
+ ReadType(strm, &delay);
+ int start;
+ ReadType(strm, &start);
+ Trie trie;
+ ReadType(strm, &trie);
+ std::unique_ptr<FeatureGroup<A>> ret(new FeatureGroup<A>(delay, start));
+ ret->trie_.swap(trie);
+ ReadType(strm, &ret->next_state_);
+ if (strm) {
+ return ret.release();
+ } else {
+ return nullptr;
+ }
+ }
+
+ std::ostream &Write(std::ostream &strm) const { // NOLINT
+ WriteType(strm, delay_);
+ WriteType(strm, start_);
+ WriteType(strm, trie_);
+ WriteType(strm, next_state_);
+ return strm;
+ }
+
+ size_t Delay() const { return delay_; }
+
+ string Stats() const;
+
+ private:
+ // Label along the arcs on the trie. `kNoLabel` means anything
+ // (non-negative label) can match; both sides holding `kNoLabel`
+ // is not allow; otherwise the label is > 0 (enforced by
+ // `LinearFstDataBuilder::AddWeight()`).
+ struct InputOutputLabel;
+ struct InputOutputLabelHash;
+
+ // Data to be stored on the trie
+ struct WeightBackLink {
+ int back_link;
+ Weight weight, final_weight;
+
+ WeightBackLink()
+ : back_link(kNoTrieNodeId),
+ weight(Weight::One()),
+ final_weight(Weight::One()) {}
+
+ std::istream &Read(std::istream &strm) { // NOLINT
+ ReadType(strm, &back_link);
+ ReadType(strm, &weight);
+ ReadType(strm, &final_weight);
+ return strm;
+ }
+
+ std::ostream &Write(std::ostream &strm) const { // NOLINT
+ WriteType(strm, back_link);
+ WriteType(strm, weight);
+ WriteType(strm, final_weight);
+ return strm;
+ }
+ };
+
+ typedef FlatTrieTopology<InputOutputLabel, InputOutputLabelHash> Topology;
+ typedef MutableTrie<InputOutputLabel, WeightBackLink, Topology> 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<int> next_state_;
+
+ FeatureGroup(const FeatureGroup &) = delete;
+ FeatureGroup &operator=(const FeatureGroup &) = delete;
+};
+
+template <class A>
+struct FeatureGroup<A>::InputOutputLabel {
+ Label input, output;
+
+ InputOutputLabel(Label i = kNoLabel, Label o = kNoLabel)
+ : input(i), output(o) {}
+
+ bool operator==(InputOutputLabel that) const {
+ return input == that.input && output == that.output;
+ }
+
+ std::istream &Read(std::istream &strm) { // NOLINT
+ ReadType(strm, &input);
+ ReadType(strm, &output);
+ return strm;
+ }
+
+ std::ostream &Write(std::ostream &strm) const { // NOLINT
+ WriteType(strm, input);
+ WriteType(strm, output);
+ return strm;
+ }
+};
+
+template <class A>
+struct FeatureGroup<A>::InputOutputLabelHash {
+ size_t operator()(InputOutputLabel label) const {
+ return static_cast<size_t>(label.input * 7853 + label.output);
+ }
+};
+
+template <class A>
+int FeatureGroup<A>::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<A>::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 <class A>
+inline int FeatureGroup<A>::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 <class A>
+inline string FeatureGroup<A>::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 A>
+class LinearFstData<A>::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<Label> pool_;
+};
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_LINEAR_LINEAR_FST_DATA_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Classes for building, storing and representing log-linear models as FSTs.
+
+#ifndef FST_EXTENSIONS_LINEAR_LINEAR_FST_H_
+#define FST_EXTENSIONS_LINEAR_LINEAR_FST_H_
+
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/extensions/pdt/collection.h>
+#include <fst/bi-table.h>
+#include <fst/cache.h>
+#include <fstream>
+#include <fst/fst.h>
+#include <fst/matcher.h>
+#include <fst/symbol-table.h>
+
+#include <fst/extensions/linear/linear-fst-data.h>
+
+namespace fst {
+
+// Forward declaration of the specialized matcher for both
+// LinearTaggerFst and LinearClassifierFst.
+template <class F>
+class LinearFstMatcherTpl;
+
+namespace internal {
+
+// Implementation class for on-the-fly generated LinearTaggerFst with
+// special optimization in matching.
+template <class A>
+class LinearTaggerFstImpl : public CacheImpl<A> {
+ public:
+ using FstImpl<A>::SetType;
+ using FstImpl<A>::SetProperties;
+ using FstImpl<A>::SetInputSymbols;
+ using FstImpl<A>::SetOutputSymbols;
+ using FstImpl<A>::WriteHeader;
+
+ using CacheBaseImpl<CacheState<A>>::PushArc;
+ using CacheBaseImpl<CacheState<A>>::HasArcs;
+ using CacheBaseImpl<CacheState<A>>::HasFinal;
+ using CacheBaseImpl<CacheState<A>>::HasStart;
+ using CacheBaseImpl<CacheState<A>>::SetArcs;
+ using CacheBaseImpl<CacheState<A>>::SetFinal;
+ using CacheBaseImpl<CacheState<A>>::SetStart;
+
+ typedef A Arc;
+ typedef typename A::Label Label;
+ typedef typename A::Weight Weight;
+ typedef typename A::StateId StateId;
+ typedef typename Collection<StateId, Label>::SetIterator NGramIterator;
+
+ // Constructs an empty FST by default.
+ LinearTaggerFstImpl()
+ : CacheImpl<A>(CacheOptions()),
+ data_(std::make_shared<LinearFstData<A>>()),
+ 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<Arc> *data, const SymbolTable *isyms,
+ const SymbolTable *osyms, CacheOptions opts)
+ : CacheImpl<A>(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<A>(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<A>::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<A>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<A>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<A>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<A>::NumOutputEpsilons(s);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<A> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<A>::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<Arc> *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<A>::kStartOfSentence`
+ // (resp. `LinearFstData<A>::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<Label>::const_iterator BufferBegin(
+ const std::vector<Label> &state) const {
+ return state.begin();
+ }
+
+ typename std::vector<Label>::const_iterator BufferEnd(
+ const std::vector<Label> &state) const {
+ return state.begin() + delay_;
+ }
+
+ typename std::vector<Label>::const_iterator InternalBegin(
+ const std::vector<Label> &state) const {
+ return state.begin() + delay_;
+ }
+
+ typename std::vector<Label>::const_iterator InternalEnd(
+ const std::vector<Label> &state) const {
+ return state.end();
+ }
+
+ // The size of state tuples are fixed, reserve them in stubs
+ void ReserveStubSpace() {
+ state_stub_.reserve(delay_ + data_->NumGroups());
+ next_stub_.reserve(delay_ + data_->NumGroups());
+ }
+
+ // Computes the start state tuple and maps it to the start state id.
+ StateId FindStartState() {
+ // Empty buffer with start-of-sentence paddings
+ state_stub_.clear();
+ state_stub_.resize(delay_, LinearFstData<A>::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<Label>::const_iterator begin,
+ typename std::vector<Label>::const_iterator end) const {
+ // The following is guanranteed by `ShiftBuffer()`:
+ // - buffer[i] == LinearFstData<A>::kEndOfSentence =>
+ // buffer[i+x] == LinearFstData<A>::kEndOfSentence
+ // - buffer[i] == LinearFstData<A>::kStartOfSentence =>
+ // buffer[i-x] == LinearFstData<A>::kStartOfSentence
+ return delay_ == 0 || *(end - 1) == LinearFstData<A>::kStartOfSentence ||
+ *begin == LinearFstData<A>::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<Label> &state) {
+ return IsEmptyBuffer(BufferBegin(state), BufferEnd(state));
+ }
+
+ // Finds state corresponding to an n-gram. Creates new state if n-gram not
+ // found.
+ StateId FindState(const std::vector<Label> &ngram) {
+ StateId sparse = ngrams_.FindId(ngram, true);
+ StateId dense = condensed_.FindId(sparse, true);
+ return dense;
+ }
+
+ // Appends after `output` the state tuple corresponding to the state id. The
+ // state id must exist.
+ void FillState(StateId s, std::vector<Label> *output) {
+ s = condensed_.FindEntry(s);
+ for (NGramIterator it = ngrams_.FindSet(s); !it.Done(); it.Next()) {
+ Label label = it.Element();
+ output->push_back(label);
+ }
+ }
+
+ // Shifts the buffer in `state` by appending `ilabel` and popping
+ // the one in the front as the return value. `next_stub_` is a
+ // shifted buffer of size `delay_` where the first `delay_ - 1`
+ // elements are the last `delay_ - 1` elements in the buffer of
+ // `state`. The last (if any) element in `next_stub_` will be
+ // `ilabel` after the call returns.
+ Label ShiftBuffer(const std::vector<Label> &state, Label ilabel,
+ std::vector<Label> *next_stub_);
+
+ // Builds an arc from state tuple `state` consuming `ilabel` and
+ // `olabel`. `next_stub_` is the buffer filled in `ShiftBuffer`.
+ Arc MakeArc(const std::vector<Label> &state, Label ilabel, Label olabel,
+ std::vector<Label> *next_stub_);
+
+ // Expands arcs from state `s`, equivalent to state tuple `state`,
+ // with input `ilabel`. `next_stub_` is the buffer filled in
+ // `ShiftBuffer`.
+ void ExpandArcs(StateId s, const std::vector<Label> &state, Label ilabel,
+ std::vector<Label> *next_stub_);
+
+ // Appends arcs from state `s`, equivalent to state tuple `state`,
+ // with input `ilabel` to `arcs`. `next_stub_` is the buffer filled
+ // in `ShiftBuffer`.
+ void AppendArcs(StateId s, const std::vector<Label> &state, Label ilabel,
+ std::vector<Label> *next_stub_, std::vector<Arc> *arcs);
+
+ std::shared_ptr<const LinearFstData<A>> data_;
+ size_t delay_;
+ // Mapping from internal state tuple to *non-consecutive* ids
+ Collection<StateId, Label> ngrams_;
+ // Mapping from non-consecutive id to actual state id
+ CompactHashBiTable<StateId, StateId, std::hash<StateId>> condensed_;
+ // Two frequently used vectors, reuse to avoid repeated heap
+ // allocation
+ std::vector<Label> state_stub_, next_stub_;
+
+ LinearTaggerFstImpl &operator=(const LinearTaggerFstImpl &) = delete;
+};
+
+template <class A>
+const int LinearTaggerFstImpl<A>::kMinFileVersion = 1;
+
+template <class A>
+const int LinearTaggerFstImpl<A>::kFileVersion = 1;
+
+template <class A>
+inline typename A::Label LinearTaggerFstImpl<A>::ShiftBuffer(
+ const std::vector<Label> &state, Label ilabel,
+ std::vector<Label> *next_stub_) {
+ DCHECK(ilabel > 0 || ilabel == LinearFstData<A>::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 <class A>
+inline A LinearTaggerFstImpl<A>::MakeArc(const std::vector<Label> &state,
+ Label ilabel, Label olabel,
+ std::vector<Label> *next_stub_) {
+ DCHECK(ilabel > 0 || ilabel == LinearFstData<A>::kEndOfSentence);
+ DCHECK(olabel > 0 || olabel == LinearFstData<A>::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<A>::kEndOfSentence ? 0 : ilabel,
+ olabel == LinearFstData<A>::kStartOfSentence ? 0 : olabel, weight,
+ nextstate);
+}
+
+template <class A>
+inline void LinearTaggerFstImpl<A>::ExpandArcs(StateId s,
+ const std::vector<Label> &state,
+ Label ilabel,
+ std::vector<Label> *next_stub_) {
+ // Input label to constrain the output with, observed `delay_` steps
+ // back. `ilabel` is the input label to be put on the arc, which
+ // fires features.
+ Label obs_ilabel = ShiftBuffer(state, ilabel, next_stub_);
+ if (obs_ilabel == LinearFstData<A>::kStartOfSentence) {
+ // This happens when input is shorter than `delay_`.
+ PushArc(s, MakeArc(state, ilabel, LinearFstData<A>::kStartOfSentence,
+ next_stub_));
+ } else {
+ std::pair<typename std::vector<typename A::Label>::const_iterator,
+ typename std::vector<typename A::Label>::const_iterator> range =
+ data_->PossibleOutputLabels(obs_ilabel);
+ for (typename std::vector<typename A::Label>::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 <class A>
+inline void LinearTaggerFstImpl<A>::AppendArcs(StateId /*s*/,
+ const std::vector<Label> &state,
+ Label ilabel,
+ std::vector<Label> *next_stub_,
+ std::vector<Arc> *arcs) {
+ // Input label to constrain the output with, observed `delay_` steps
+ // back. `ilabel` is the input label to be put on the arc, which
+ // fires features.
+ Label obs_ilabel = ShiftBuffer(state, ilabel, next_stub_);
+ if (obs_ilabel == LinearFstData<A>::kStartOfSentence) {
+ // This happens when input is shorter than `delay_`.
+ arcs->push_back(
+ MakeArc(state, ilabel, LinearFstData<A>::kStartOfSentence, next_stub_));
+ } else {
+ std::pair<typename std::vector<typename A::Label>::const_iterator,
+ typename std::vector<typename A::Label>::const_iterator> range =
+ data_->PossibleOutputLabels(obs_ilabel);
+ for (typename std::vector<typename A::Label>::const_iterator it =
+ range.first;
+ it != range.second; ++it)
+ arcs->push_back(MakeArc(state, ilabel, *it, next_stub_));
+ }
+}
+
+template <class A>
+void LinearTaggerFstImpl<A>::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<A>::kEndOfSentence, &next_stub_);
+
+ // Non-epsilon input when we haven't flushed
+ if (delay_ == 0 ||
+ *(BufferEnd(state_stub_) - 1) != LinearFstData<A>::kEndOfSentence)
+ for (Label ilabel = data_->MinInputLabel();
+ ilabel <= data_->MaxInputLabel(); ++ilabel)
+ ExpandArcs(s, state_stub_, ilabel, &next_stub_);
+
+ SetArcs(s);
+}
+
+template <class A>
+void LinearTaggerFstImpl<A>::MatchInput(StateId s, Label ilabel,
+ std::vector<Arc> *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<A>::kEndOfSentence, &next_stub_,
+ arcs);
+ } else {
+ // Non-epsilon input when we haven't flushed
+ if (delay_ == 0 ||
+ *(BufferEnd(state_stub_) - 1) != LinearFstData<A>::kEndOfSentence)
+ AppendArcs(s, state_stub_, ilabel, &next_stub_, arcs);
+ }
+}
+
+template <class A>
+inline LinearTaggerFstImpl<A> *LinearTaggerFstImpl<A>::Read(
+ std::istream &strm, const FstReadOptions &opts) { // NOLINT
+ std::unique_ptr<LinearTaggerFstImpl<A>> impl(new LinearTaggerFstImpl<A>());
+ FstHeader header;
+ if (!impl->ReadHeader(strm, opts, kMinFileVersion, &header)) {
+ return nullptr;
+ }
+ impl->data_ = std::shared_ptr<LinearFstData<A>>(LinearFstData<A>::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 A>
+class LinearTaggerFst : public ImplToFst<internal::LinearTaggerFstImpl<A>> {
+ public:
+ friend class ArcIterator<LinearTaggerFst<A>>;
+ friend class StateIterator<LinearTaggerFst<A>>;
+ friend class LinearFstMatcherTpl<LinearTaggerFst<A>>;
+
+ typedef A Arc;
+ typedef typename A::Label Label;
+ typedef typename A::Weight Weight;
+ typedef typename A::StateId StateId;
+ typedef DefaultCacheStore<A> Store;
+ typedef typename Store::State State;
+ using Impl = internal::LinearTaggerFstImpl<A>;
+
+ LinearTaggerFst() : ImplToFst<Impl>(std::make_shared<Impl>()) {}
+
+ explicit LinearTaggerFst(LinearFstData<A> *data,
+ const SymbolTable *isyms = nullptr,
+ const SymbolTable *osyms = nullptr,
+ CacheOptions opts = CacheOptions())
+ : ImplToFst<Impl>(std::make_shared<Impl>(data, isyms, osyms, opts)) {}
+
+ explicit LinearTaggerFst(const Fst<A> &fst)
+ : ImplToFst<Impl>(std::make_shared<Impl>()) {
+ LOG(FATAL) << "LinearTaggerFst: no constructor from arbitrary FST.";
+ }
+
+ // See Fst<>::Copy() for doc.
+ LinearTaggerFst(const LinearTaggerFst<A> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this LinearTaggerFst. See Fst<>::Copy() for further doc.
+ LinearTaggerFst<A> *Copy(bool safe = false) const override {
+ return new LinearTaggerFst<A>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<A> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<A> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ MatcherBase<A> *InitMatcher(MatchType match_type) const override {
+ return new LinearFstMatcherTpl<LinearTaggerFst<A>>(*this, match_type);
+ }
+
+ static LinearTaggerFst<A> *Read(const string &filename) {
+ if (!filename.empty()) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "LinearTaggerFst::Read: Can't open file: " << filename;
+ return nullptr;
+ }
+ return Read(strm, FstReadOptions(filename));
+ } else {
+ return Read(std::cin, FstReadOptions("standard input"));
+ }
+ }
+
+ static LinearTaggerFst<A> *Read(std::istream &in, // NOLINT
+ const FstReadOptions &opts) {
+ auto *impl = Impl::Read(in, opts);
+ return impl ? new LinearTaggerFst<A>(std::shared_ptr<Impl>(impl)) : nullptr;
+ }
+
+ bool Write(const string &filename) const override {
+ if (!filename.empty()) {
+ std::ofstream strm(filename.c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "LinearTaggerFst::Write: Can't open file: " << filename;
+ return false;
+ }
+ return Write(strm, FstWriteOptions(filename));
+ } else {
+ return Write(std::cout, FstWriteOptions("standard output"));
+ }
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return GetImpl()->Write(strm, opts);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ explicit LinearTaggerFst(std::shared_ptr<Impl> impl)
+ : ImplToFst<Impl>(impl) {}
+
+ void operator=(const LinearTaggerFst<A> &fst) = delete;
+};
+
+// Specialization for LinearTaggerFst.
+template <class Arc>
+class StateIterator<LinearTaggerFst<Arc>>
+ : public CacheStateIterator<LinearTaggerFst<Arc>> {
+ public:
+ explicit StateIterator(const LinearTaggerFst<Arc> &fst)
+ : CacheStateIterator<LinearTaggerFst<Arc>>(fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for LinearTaggerFst.
+template <class Arc>
+class ArcIterator<LinearTaggerFst<Arc>>
+ : public CacheArcIterator<LinearTaggerFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const LinearTaggerFst<Arc> &fst, StateId s)
+ : CacheArcIterator<LinearTaggerFst<Arc>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class Arc>
+inline void LinearTaggerFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<LinearTaggerFst<Arc>>(*this);
+}
+
+namespace internal {
+
+// Implementation class for on-the-fly generated LinearClassifierFst with
+// special optimization in matching.
+template <class A>
+class LinearClassifierFstImpl : public CacheImpl<A> {
+ public:
+ using FstImpl<A>::SetType;
+ using FstImpl<A>::SetProperties;
+ using FstImpl<A>::SetInputSymbols;
+ using FstImpl<A>::SetOutputSymbols;
+ using FstImpl<A>::WriteHeader;
+
+ using CacheBaseImpl<CacheState<A>>::PushArc;
+ using CacheBaseImpl<CacheState<A>>::HasArcs;
+ using CacheBaseImpl<CacheState<A>>::HasFinal;
+ using CacheBaseImpl<CacheState<A>>::HasStart;
+ using CacheBaseImpl<CacheState<A>>::SetArcs;
+ using CacheBaseImpl<CacheState<A>>::SetFinal;
+ using CacheBaseImpl<CacheState<A>>::SetStart;
+
+ typedef A Arc;
+ typedef typename A::Label Label;
+ typedef typename A::Weight Weight;
+ typedef typename A::StateId StateId;
+ typedef typename Collection<StateId, Label>::SetIterator NGramIterator;
+
+ // Constructs an empty FST by default.
+ LinearClassifierFstImpl()
+ : CacheImpl<A>(CacheOptions()),
+ data_(std::make_shared<LinearFstData<A>>()) {
+ 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<Arc> *data, size_t num_classes,
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ CacheOptions opts)
+ : CacheImpl<A>(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<A>(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<A>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) {
+ state_stub_.clear();
+ FillState(s, &state_stub_);
+ SetFinal(s, FinalWeight(state_stub_));
+ }
+ return CacheImpl<A>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<A>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<A>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<A>::NumOutputEpsilons(s);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<A> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<A>::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<Arc> *arcs);
+
+ static LinearClassifierFstImpl<A> *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<Label> &state) { return state[0]; } // NOLINT
+ Label Prediction(const std::vector<Label> &state) const { return state[0]; }
+
+ Label &InternalAt(std::vector<Label> &state, int index) { // NOLINT
+ return state[index + 1];
+ }
+ Label InternalAt(const std::vector<Label> &state, int index) const {
+ return state[index + 1];
+ }
+
+ // The size of state tuples are fixed, reserve them in stubs
+ void ReserveStubSpace() {
+ size_t size = 1 + num_groups_;
+ state_stub_.reserve(size);
+ next_stub_.reserve(size);
+ }
+
+ // Computes the start state tuple and maps it to the start state id.
+ StateId FindStartState() {
+ // A start state tuple has no prediction
+ state_stub_.clear();
+ state_stub_.push_back(kNoLabel);
+ // For a start state, we don't yet know where we are in the tries.
+ for (size_t i = 0; i < num_groups_; ++i)
+ state_stub_.push_back(kNoTrieNodeId);
+ return FindState(state_stub_);
+ }
+
+ // Tests if the state tuple represents the start state.
+ bool IsStartState(const std::vector<Label> &state) const {
+ return state[0] == kNoLabel;
+ }
+
+ // Computes the actual group id in the data storage.
+ int GroupId(Label pred, int group) const {
+ return group * num_classes_ + pred - 1;
+ }
+
+ // Finds out the final weight of the given state. A state is final
+ // iff it is not the start.
+ Weight FinalWeight(const std::vector<Label> &state) const {
+ if (IsStartState(state)) {
+ return Weight::Zero();
+ }
+ Label pred = Prediction(state);
+ DCHECK_GT(pred, 0);
+ DCHECK_LE(pred, num_classes_);
+ Weight final_weight = Weight::One();
+ for (size_t group = 0; group < num_groups_; ++group) {
+ int group_id = GroupId(pred, group);
+ int trie_state = InternalAt(state, group);
+ final_weight =
+ Times(final_weight, data_->GroupFinalWeight(group_id, trie_state));
+ }
+ return final_weight;
+ }
+
+ // Finds state corresponding to an n-gram. Creates new state if n-gram not
+ // found.
+ StateId FindState(const std::vector<Label> &ngram) {
+ StateId sparse = ngrams_.FindId(ngram, true);
+ StateId dense = condensed_.FindId(sparse, true);
+ return dense;
+ }
+
+ // Appends after `output` the state tuple corresponding to the state id. The
+ // state id must exist.
+ void FillState(StateId s, std::vector<Label> *output) {
+ s = condensed_.FindEntry(s);
+ for (NGramIterator it = ngrams_.FindSet(s); !it.Done(); it.Next()) {
+ Label label = it.Element();
+ output->push_back(label);
+ }
+ }
+
+ std::shared_ptr<const LinearFstData<A>> data_;
+ // Division of groups in `data_`; num_classes_ * num_groups_ ==
+ // data_->NumGroups().
+ size_t num_classes_, num_groups_;
+ // Mapping from internal state tuple to *non-consecutive* ids
+ Collection<StateId, Label> ngrams_;
+ // Mapping from non-consecutive id to actual state id
+ CompactHashBiTable<StateId, StateId, std::hash<StateId>> condensed_;
+ // Two frequently used vectors, reuse to avoid repeated heap
+ // allocation
+ std::vector<Label> state_stub_, next_stub_;
+
+ void operator=(const LinearClassifierFstImpl<A> &) = delete;
+};
+
+template <class A>
+const int LinearClassifierFstImpl<A>::kMinFileVersion = 0;
+
+template <class A>
+const int LinearClassifierFstImpl<A>::kFileVersion = 0;
+
+template <class A>
+void LinearClassifierFstImpl<A>::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 <class A>
+void LinearClassifierFstImpl<A>::MatchInput(StateId s, Label ilabel,
+ std::vector<Arc> *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 <class A>
+inline LinearClassifierFstImpl<A> *LinearClassifierFstImpl<A>::Read(
+ std::istream &strm, const FstReadOptions &opts) {
+ std::unique_ptr<LinearClassifierFstImpl<A>> impl(
+ new LinearClassifierFstImpl<A>());
+ FstHeader header;
+ if (!impl->ReadHeader(strm, opts, kMinFileVersion, &header)) {
+ return nullptr;
+ }
+ impl->data_ = std::shared_ptr<LinearFstData<A>>(LinearFstData<A>::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 A>
+class LinearClassifierFst
+ : public ImplToFst<internal::LinearClassifierFstImpl<A>> {
+ public:
+ friend class ArcIterator<LinearClassifierFst<A>>;
+ friend class StateIterator<LinearClassifierFst<A>>;
+ friend class LinearFstMatcherTpl<LinearClassifierFst<A>>;
+
+ typedef A Arc;
+ typedef typename A::Label Label;
+ typedef typename A::Weight Weight;
+ typedef typename A::StateId StateId;
+ typedef DefaultCacheStore<A> Store;
+ typedef typename Store::State State;
+ using Impl = internal::LinearClassifierFstImpl<A>;
+
+ LinearClassifierFst() : ImplToFst<Impl>(std::make_shared<Impl>()) {}
+
+ explicit LinearClassifierFst(LinearFstData<A> *data, size_t num_classes,
+ const SymbolTable *isyms = nullptr,
+ const SymbolTable *osyms = nullptr,
+ CacheOptions opts = CacheOptions())
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(data, num_classes, isyms, osyms, opts)) {}
+
+ explicit LinearClassifierFst(const Fst<A> &fst)
+ : ImplToFst<Impl>(std::make_shared<Impl>()) {
+ LOG(FATAL) << "LinearClassifierFst: no constructor from arbitrary FST.";
+ }
+
+ // See Fst<>::Copy() for doc.
+ LinearClassifierFst(const LinearClassifierFst<A> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this LinearClassifierFst. See Fst<>::Copy() for further doc.
+ LinearClassifierFst<A> *Copy(bool safe = false) const override {
+ return new LinearClassifierFst<A>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<A> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<A> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ MatcherBase<A> *InitMatcher(MatchType match_type) const override {
+ return new LinearFstMatcherTpl<LinearClassifierFst<A>>(*this, match_type);
+ }
+
+ static LinearClassifierFst<A> *Read(const string &filename) {
+ if (!filename.empty()) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "LinearClassifierFst::Read: Can't open file: "
+ << filename;
+ return nullptr;
+ }
+ return Read(strm, FstReadOptions(filename));
+ } else {
+ return Read(std::cin, FstReadOptions("standard input"));
+ }
+ }
+
+ static LinearClassifierFst<A> *Read(std::istream &in,
+ const FstReadOptions &opts) {
+ auto *impl = Impl::Read(in, opts);
+ return impl ? new LinearClassifierFst<A>(std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ bool Write(const string &filename) const override {
+ if (!filename.empty()) {
+ std::ofstream strm(filename.c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "ProdLmFst::Write: Can't open file: " << filename;
+ return false;
+ }
+ return Write(strm, FstWriteOptions(filename));
+ } else {
+ return Write(std::cout, FstWriteOptions("standard output"));
+ }
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return GetImpl()->Write(strm, opts);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ explicit LinearClassifierFst(std::shared_ptr<Impl> impl)
+ : ImplToFst<Impl>(impl) {}
+
+ void operator=(const LinearClassifierFst<A> &fst) = delete;
+};
+
+// Specialization for LinearClassifierFst.
+template <class Arc>
+class StateIterator<LinearClassifierFst<Arc>>
+ : public CacheStateIterator<LinearClassifierFst<Arc>> {
+ public:
+ explicit StateIterator(const LinearClassifierFst<Arc> &fst)
+ : CacheStateIterator<LinearClassifierFst<Arc>>(fst,
+ fst.GetMutableImpl()) {}
+};
+
+// Specialization for LinearClassifierFst.
+template <class Arc>
+class ArcIterator<LinearClassifierFst<Arc>>
+ : public CacheArcIterator<LinearClassifierFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const LinearClassifierFst<Arc> &fst, StateId s)
+ : CacheArcIterator<LinearClassifierFst<Arc>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class Arc>
+inline void LinearClassifierFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<LinearClassifierFst<Arc>>(*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 F>
+class LinearFstMatcherTpl : public MatcherBase<typename F::Arc> {
+ public:
+ typedef typename F::Arc Arc;
+ typedef typename Arc::Label Label;
+ typedef typename Arc::Weight Weight;
+ typedef typename Arc::StateId StateId;
+ typedef F FST;
+
+ LinearFstMatcherTpl(const FST &fst, MatchType match_type)
+ : fst_(fst.Copy()),
+ 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;
+ }
+ }
+
+ LinearFstMatcherTpl(const LinearFstMatcherTpl<F> &matcher, bool safe = false)
+ : fst_(matcher.fst_->Copy(safe)),
+ match_type_(matcher.match_type_),
+ s_(kNoStateId),
+ current_loop_(false),
+ loop_(matcher.loop_),
+ cur_arc_(0),
+ error_(matcher.error_) {}
+
+ LinearFstMatcherTpl<F> *Copy(bool safe = false) const override {
+ return new LinearFstMatcherTpl<F>(*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) {
+ 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) {
+ 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 { return !(current_loop_ || cur_arc_ < arcs_.size()); }
+
+ const Arc &Value() const { return current_loop_ ? loop_ : arcs_[cur_arc_]; }
+
+ void Next() {
+ if (current_loop_)
+ current_loop_ = false;
+ else
+ ++cur_arc_;
+ }
+
+ ssize_t Priority_(StateId s) override { 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:
+ void SetState_(StateId s) override { SetState(s); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ std::unique_ptr<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<Arc> 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_
--- /dev/null
+// 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 <istream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/extensions/linear/linear-fst-data-builder.h>
+#include <fst/extensions/linear/linear-fst.h>
+#include <fstream>
+#include <fst/symbol-table.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/script-impl.h>
+
+DECLARE_string(delimiter);
+DECLARE_string(empty_symbol);
+DECLARE_string(start_symbol);
+DECLARE_string(end_symbol);
+DECLARE_bool(classifier);
+
+namespace fst {
+namespace script {
+typedef args::Package<const string &, const string &, const string &, char **,
+ int, const string &, const string &, const string &,
+ const string &> LinearCompileArgs;
+
+bool ValidateDelimiter();
+bool ValidateEmptySymbol();
+
+// Returns the proper label given the symbol. For symbols other than
+// `FLAGS_start_symbol` or `FLAGS_end_symbol`, looks up the symbol
+// table to decide the label. Depending on whether
+// `FLAGS_start_symbol` and `FLAGS_end_symbol` are identical, it
+// either returns `kNoLabel` for later processing or decides the label
+// right away.
+template <class Arc>
+inline typename Arc::Label LookUp(const string &str, SymbolTable *syms) {
+ if (str == FLAGS_start_symbol)
+ return str == FLAGS_end_symbol ? kNoLabel
+ : LinearFstData<Arc>::kStartOfSentence;
+ else if (str == FLAGS_end_symbol)
+ return LinearFstData<Arc>::kEndOfSentence;
+ else
+ return syms->AddSymbol(str);
+}
+
+// Splits `str` with `delim` as the delimiter and stores the labels in
+// `output`.
+template <class Arc>
+void SplitAndPush(const string &str, const char delim, SymbolTable *syms,
+ std::vector<typename Arc::Label> *output) {
+ if (str == FLAGS_empty_symbol) return;
+ std::istringstream strm(str);
+ string buf;
+ while (std::getline(strm, buf, delim))
+ output->push_back(LookUp<Arc>(buf, syms));
+}
+
+// Like `std::replace_copy` but returns the number of modifications
+template <class InputIterator, class OutputIterator, class T>
+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 <class Arc>
+bool GetVocabRecord(const string &vocab, std::istream &strm, // NOLINT
+ SymbolTable *isyms, SymbolTable *fsyms, SymbolTable *osyms,
+ typename Arc::Label *word,
+ std::vector<typename Arc::Label> *feature_labels,
+ std::vector<typename Arc::Label> *possible_labels,
+ size_t *num_line);
+
+template <class Arc>
+bool GetModelRecord(const string &model, std::istream &strm, // NOLINT
+ SymbolTable *fsyms, SymbolTable *osyms,
+ std::vector<typename Arc::Label> *input_labels,
+ std::vector<typename Arc::Label> *output_labels,
+ typename Arc::Weight *weight, size_t *num_line);
+
+// Reads in vocabulary file. Each line is in the following format
+//
+// word <whitespace> features [ <whitespace> possible output ]
+//
+// where features and possible output are `FLAGS_delimiter`-delimited lists of
+// tokens
+template <class Arc>
+void AddVocab(const string &vocab, SymbolTable *isyms, SymbolTable *fsyms,
+ SymbolTable *osyms, LinearFstDataBuilder<Arc> *builder) {
+ std::ifstream in(vocab);
+ if (!in) LOG(FATAL) << "Can't open file: " << vocab;
+ size_t num_line = 0, num_added = 0;
+ std::vector<string> fields;
+ std::vector<typename Arc::Label> feature_labels, possible_labels;
+ typename Arc::Label word;
+ while (GetVocabRecord<Arc>(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 <class Arc>
+void AddVocab(const string &vocab, SymbolTable *isyms, SymbolTable *fsyms,
+ SymbolTable *osyms,
+ LinearClassifierFstDataBuilder<Arc> *builder) {
+ std::ifstream in(vocab);
+ if (!in) LOG(FATAL) << "Can't open file: " << vocab;
+ size_t num_line = 0, num_added = 0;
+ std::vector<string> fields;
+ std::vector<typename Arc::Label> feature_labels, possible_labels;
+ typename Arc::Label word;
+ while (GetVocabRecord<Arc>(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 <whitespace> output sequence <whitespace> 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 <class Arc>
+void AddModel(const string &model, SymbolTable *fsyms, SymbolTable *osyms,
+ LinearFstDataBuilder<Arc> *builder) {
+ std::ifstream in(model);
+ if (!in) LOG(FATAL) << "Can't open file: " << model;
+ string line;
+ std::getline(in, line);
+ if (!in) LOG(FATAL) << "Empty file: " << model;
+ size_t future_size;
+ {
+ std::istringstream strm(line);
+ strm >> future_size;
+ if (!strm) LOG(FATAL) << "Can't read future size: " << model;
+ }
+ size_t num_line = 1, num_added = 0;
+ const int group = builder->AddGroup(future_size);
+ CHECK_GE(group, 0);
+ VLOG(1) << "Group " << group << ": from " << model << "; future size is "
+ << future_size << ".";
+ // Add the rest of lines as a single feature group
+ std::vector<string> fields;
+ std::vector<typename Arc::Label> input_labels, output_labels;
+ typename Arc::Weight weight;
+ while (GetModelRecord<Arc>(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<Arc>::kStartOfSentence,
+ LinearFstData<Arc>::kEndOfSentence};
+
+ std::vector<typename Arc::Label> 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 <class Arc>
+void AddModel(const string &model, SymbolTable *fsyms, SymbolTable *osyms,
+ LinearClassifierFstDataBuilder<Arc> *builder) {
+ std::ifstream in(model);
+ if (!in) LOG(FATAL) << "Can't open file: " << model;
+ string line;
+ std::getline(in, line);
+ if (!in) LOG(FATAL) << "Empty file: " << model;
+ size_t future_size;
+ {
+ std::istringstream strm(line);
+ strm >> future_size;
+ if (!strm) LOG(FATAL) << "Can't read future size: " << model;
+ }
+ if (future_size != 0)
+ LOG(FATAL) << "Classifier model must have future size = 0; got "
+ << future_size << " from " << model;
+ size_t num_line = 1, num_added = 0;
+ const int group = builder->AddGroup();
+ CHECK_GE(group, 0);
+ VLOG(1) << "Group " << group << ": from " << model << "; future size is "
+ << future_size << ".";
+ // Add the rest of lines as a single feature group
+ std::vector<string> fields;
+ std::vector<typename Arc::Label> input_labels, output_labels;
+ typename Arc::Weight weight;
+ while (GetModelRecord<Arc>(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<Arc>::kStartOfSentence,
+ LinearFstData<Arc>::kEndOfSentence};
+
+ typename Arc::Label pred = output_labels[0];
+
+ std::vector<typename Arc::Label> copy_input(input_labels.size());
+ for (int i = 0; i < 2; ++i) {
+ size_t num_input_changes =
+ ReplaceCopy(input_labels.begin(), input_labels.end(),
+ copy_input.begin(), kNoLabel, marks[i]);
+ if (num_input_changes > 0 || i == 0)
+ num_added += builder->AddWeight(group, copy_input, pred, weight);
+ }
+ }
+ VLOG(1) << "Group " << group << ": read " << num_added << " weight(s) in "
+ << num_line << " lines.";
+}
+
+void SplitByWhitespace(const string &str, std::vector<string> *out);
+int ScanNumClasses(char **models, int models_length);
+
+template <class Arc>
+void LinearCompileTpl(LinearCompileArgs *args) {
+ const string &epsilon_symbol = args->arg1;
+ const string &unknown_symbol = args->arg2;
+ const string &vocab = args->arg3;
+ char **models = args->arg4;
+ const int models_length = args->arg5;
+ const string &out = args->arg6;
+ const string &save_isymbols = args->arg7;
+ const string &save_fsymbols = args->arg8;
+ const string &save_osymbols = args->arg9;
+
+ 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<Arc>::kStartOfSentence;
+ VLOG(1) << "end-of-sentence label is " << LinearFstData<Arc>::kEndOfSentence;
+
+ if (FLAGS_classifier) {
+ int num_classes = ScanNumClasses(models, models_length);
+ LinearClassifierFstDataBuilder<Arc> 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<Arc> fst(builder.Dump(), num_classes, &isyms, &osyms);
+ fst.Write(out);
+ } else {
+ LinearFstDataBuilder<Arc> 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<Arc> fst(builder.Dump(), &isyms, &osyms);
+ fst.Write(out);
+ }
+
+ if (!save_isymbols.empty()) isyms.WriteText(save_isymbols);
+ if (!save_fsymbols.empty()) fsyms.WriteText(save_fsymbols);
+ if (!save_osymbols.empty()) osyms.WriteText(save_osymbols);
+}
+
+void LinearCompile(const string &arc_type, const string &epsilon_symbol,
+ const string &unknown_symbol, const string &vocab,
+ char **models, int models_len, const string &out,
+ const string &save_isymbols, const string &save_fsymbols,
+ const string &save_osymbols);
+
+template <class Arc>
+bool GetVocabRecord(const string &vocab, std::istream &strm, // NOLINT
+ SymbolTable *isyms, SymbolTable *fsyms, SymbolTable *osyms,
+ typename Arc::Label *word,
+ std::vector<typename Arc::Label> *feature_labels,
+ std::vector<typename Arc::Label> *possible_labels,
+ size_t *num_line) {
+ string line;
+ if (!std::getline(strm, line)) return false;
+ ++(*num_line);
+
+ std::vector<string> 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<Arc>(fields[0], isyms);
+
+ const char delim = FLAGS_delimiter[0];
+ SplitAndPush<Arc>(fields[1], delim, fsyms, feature_labels);
+ SplitAndPush<Arc>(fields[2], delim, osyms, possible_labels);
+
+ return true;
+}
+
+template <class Arc>
+bool GetModelRecord(const string &model, std::istream &strm, // NOLINT
+ SymbolTable *fsyms, SymbolTable *osyms,
+ std::vector<typename Arc::Label> *input_labels,
+ std::vector<typename Arc::Label> *output_labels,
+ typename Arc::Weight *weight, size_t *num_line) {
+ string line;
+ if (!std::getline(strm, line)) return false;
+ ++(*num_line);
+
+ std::vector<string> 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<Arc>(fields[0], delim, fsyms, input_labels);
+ SplitAndPush<Arc>(fields[1], delim, osyms, output_labels);
+
+ *weight = StrToWeight<typename Arc::Weight>(fields[2], model, *num_line);
+
+ GuessStartOrEnd<Arc>(input_labels, kNoLabel);
+ GuessStartOrEnd<Arc>(output_labels, kNoLabel);
+
+ return true;
+}
+} // namespace script
+} // namespace fst
+
+#define REGISTER_FST_LINEAR_OPERATIONS(Arc) \
+ REGISTER_FST_OPERATION(LinearCompileTpl, Arc, LinearCompileArgs);
+
+#endif // FST_EXTENSIONS_LINEAR_LINEARSCRIPT_H_
--- /dev/null
+// 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 <fst/compat.h>
+#include <fst/arc.h>
+#include <fst/arc-map.h>
+#include <fst/compose.h>
+#include <fst/determinize.h>
+#include <fst/float-weight.h>
+#include <fst/fst.h>
+#include <fst/minimize.h>
+#include <fst/mutable-fst.h>
+#include <fst/project.h>
+#include <fst/rmepsilon.h>
+#include <fst/vector-fst.h>
+
+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 <class A>
+void LogLinearApply(const Fst<A> &ifst, const Fst<A> &lfst, MutableFst<A> *ofst,
+ bool normalize = true) {
+ LogLinearApply<A, LogArc>(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 <class A, class B>
+void LogLinearApply(const Fst<A> &ifst, const Fst<A> &lfst, MutableFst<A> *ofst,
+ bool normalize = true) {
+ if (normalize) {
+ VectorFst<A> unnormalized_ofst, rescored_ifsa;
+ Compose(ifst, lfst, &unnormalized_ofst);
+ {
+ VectorFst<A> tropical_ifsa(unnormalized_ofst);
+ Project(&tropical_ifsa, PROJECT_INPUT);
+ {
+ VectorFst<B> minimal_log_ifsa;
+ {
+ VectorFst<B> log_ifsa;
+ ArcMap(tropical_ifsa, &log_ifsa, WeightConvertMapper<A, B>());
+ RmEpsilon(&log_ifsa);
+ Determinize(log_ifsa, &minimal_log_ifsa);
+ }
+ Minimize(&minimal_log_ifsa);
+ ArcMap(&minimal_log_ifsa, InvertWeightMapper<B>());
+ ArcMap(minimal_log_ifsa, &tropical_ifsa, WeightConvertMapper<B, A>());
+ }
+ ArcSort(&tropical_ifsa, OLabelCompare<A>());
+ Compose(tropical_ifsa, ifst, &rescored_ifsa);
+ }
+ ArcSort(&rescored_ifsa, OLabelCompare<A>());
+ Compose(rescored_ifsa, unnormalized_ofst, ofst);
+ } else {
+ Compose(ifst, lfst, ofst);
+ }
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_LINEAR_LOGLINEAR_APPLY_H_
--- /dev/null
+// 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 <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/util.h>
+
+namespace fst {
+
+const int kNoTrieNodeId = -1;
+
+// Forward declarations of all available trie topologies.
+template <class L, class H>
+class NestedTrieTopology;
+template <class L, class H>
+class FlatTrieTopology;
+
+// A pair of parent node id and label, part of a trie edge
+template <class L>
+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 <class L, class H>
+struct ParentLabelHash {
+ size_t operator()(const ParentLabel<L> &pl) const {
+ return static_cast<size_t>(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 L, class H>
+class NestedTrieTopology {
+ public:
+ typedef L Label;
+ typedef H Hash;
+ typedef std::unordered_map<L, int, H> NextMap;
+
+ class const_iterator {
+ public:
+ typedef std::forward_iterator_tag iterator_category;
+ typedef std::pair<ParentLabel<L>, int> value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type *pointer;
+ typedef const value_type &reference;
+
+ friend class NestedTrieTopology<L, H>;
+
+ 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<L>(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<NextMap *>
+ nodes_; // Use pointers to avoid copying the maps when the
+ // vector grows
+};
+
+template <class L, class H>
+NestedTrieTopology<L, H>::NestedTrieTopology() {
+ nodes_.push_back(new NextMap);
+}
+
+template <class L, class H>
+NestedTrieTopology<L, H>::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 <class L, class H>
+NestedTrieTopology<L, H>::~NestedTrieTopology() {
+ for (size_t i = 0; i < nodes_.size(); ++i) {
+ NextMap *node = nodes_[i];
+ delete node;
+ }
+}
+
+// TODO(wuke): std::swap compatibility
+template <class L, class H>
+inline void NestedTrieTopology<L, H>::swap(NestedTrieTopology &that) {
+ nodes_.swap(that.nodes_);
+}
+
+template <class L, class H>
+inline NestedTrieTopology<L, H> &NestedTrieTopology<L, H>::operator=(
+ const NestedTrieTopology &that) {
+ NestedTrieTopology copy(that);
+ swap(copy);
+ return *this;
+}
+
+template <class L, class H>
+inline bool NestedTrieTopology<L, H>::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 <class L, class H>
+inline bool NestedTrieTopology<L, H>::operator!=(
+ const NestedTrieTopology &that) const {
+ return !(*this == that);
+}
+
+template <class L, class H>
+inline int NestedTrieTopology<L, H>::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 <class L, class H>
+inline int NestedTrieTopology<L, H>::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 <class L, class H>
+inline std::istream &NestedTrieTopology<L, H>::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 <class L, class H>
+inline std::ostream &NestedTrieTopology<L, H>::Write(
+ std::ostream &strm) const { // NOLINT
+ WriteType(strm, NumNodes());
+ for (size_t i = 0; i < NumNodes(); ++i) WriteType(strm, *nodes_[i]);
+ return strm;
+}
+
+template <class L, class H>
+inline typename NestedTrieTopology<L, H>::const_iterator
+ &NestedTrieTopology<L, H>::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 <class L, class H>
+inline typename NestedTrieTopology<L, H>::const_iterator
+ &NestedTrieTopology<L, H>::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 L, class H>
+class FlatTrieTopology {
+ private:
+ typedef std::unordered_map<ParentLabel<L>, int, ParentLabelHash<L, H>>
+ NextMap;
+
+ public:
+ // Iterator over edges as std::pair<ParentLabel<L>, int>
+ typedef typename NextMap::const_iterator const_iterator;
+ typedef L Label;
+ typedef H Hash;
+
+ FlatTrieTopology() {}
+ FlatTrieTopology(const FlatTrieTopology &that) : next_(that.next_) {}
+ template <class T>
+ 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 <class L, class H>
+template <class T>
+FlatTrieTopology<L, H>::FlatTrieTopology(const T &that)
+ : next_(that.begin(), that.end()) {}
+
+template <class L, class H>
+inline int FlatTrieTopology<L, H>::Insert(int parent, const L &label) {
+ int ret = Find(parent, label);
+ if (ret == kNoTrieNodeId) {
+ ret = NumNodes();
+ next_[ParentLabel<L>(parent, label)] = ret;
+ }
+ return ret;
+}
+
+template <class L, class H>
+inline int FlatTrieTopology<L, H>::Find(int parent, const L &label) const {
+ typename NextMap::const_iterator it =
+ next_.find(ParentLabel<L>(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<char, bool> 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<char, bool>::kNoNodeId) {
+// ++prefix_length;
+// cur = dict.Find(cur, query[prefix_length]);
+// }
+template <class L, class V, class T>
+class MutableTrie {
+ public:
+ template <class LL, class VV, class TT>
+ 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 <class S>
+ explicit MutableTrie(const MutableTrie<L, V, S> &that)
+ : topology_(that.topology_), values_(that.values_) {}
+
+ // TODO(wuke): std::swap compatibility
+ void swap(MutableTrie &that) {
+ topology_.swap(that.topology_);
+ values_.swap(that.values_);
+ DCHECK_EQ(topology_.NumNodes(), values_.size());
+ }
+
+ 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<V> values_;
+};
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_LINEAR_TRIE_H_
--- /dev/null
+// 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 <list>
+
+#include <fst/extensions/mpdt/mpdt.h>
+#include <fst/extensions/pdt/compose.h>
+#include <fst/compose.h>
+
+namespace fst {
+
+template <class Filter>
+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<StackId, Label>;
+ using FilterState1 = typename Filter::FilterState;
+ using FilterState2 = IntegerFilterState<StackId>;
+ using FilterState = PairFilterState<FilterState1, FilterState2>;
+
+ MPdtParenFilter(const FST1 &fst1, const FST2 &fst2,
+ Matcher1 *matcher1 = nullptr, Matcher2 *matcher2 = nullptr,
+ const std::vector<std::pair<Label, Label>> *parens = nullptr,
+ const std::vector<Label> *assignments = nullptr,
+ bool expand = false, bool keep_parens = true)
+ : filter_(fst1, fst2, matcher1, matcher2),
+ parens_(parens ? *parens : std::vector<std::pair<Label, Label>>()),
+ assignments_(assignments ? *assignments : std::vector<Label>()),
+ expand_(expand),
+ keep_parens_(keep_parens),
+ fs_(FilterState::NoState()),
+ stack_(parens_, assignments_),
+ 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);
+ }
+ }
+ }
+ }
+
+ MPdtParenFilter(const MPdtParenFilter &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_, filter.assignments_),
+ 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;
+ const auto 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 {
+ const auto oprops = filter_.Properties(iprops);
+ return oprops & 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<std::pair<Label, Label>> parens_;
+ std::vector<Label> assignments_;
+ 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 MPDT composition. Default is to take
+// the MPDT as the first composition argument.
+template <class Arc, bool left_pdt = true>
+class MPdtComposeFstOptions
+ : public ComposeFstOptions<Arc, ParenMatcher<Fst<Arc>>,
+ MPdtParenFilter<AltSequenceComposeFilter<
+ ParenMatcher<Fst<Arc>> >> > {
+ public:
+ using Label = typename Arc::Label;
+ using MPdtMatcher = ParenMatcher<Fst<Arc>>;
+ using MPdtFilter = MPdtParenFilter<AltSequenceComposeFilter<MPdtMatcher>>;
+
+ using ComposeFstOptions<Arc, MPdtMatcher, MPdtFilter>::matcher1;
+ using ComposeFstOptions<Arc, MPdtMatcher, MPdtFilter>::matcher2;
+ using ComposeFstOptions<Arc, MPdtMatcher, MPdtFilter>::filter;
+
+ MPdtComposeFstOptions(const Fst<Arc> &ifst1,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const std::vector<typename Arc::Label> &assignments,
+ const Fst<Arc> &ifst2, bool expand = false,
+ bool keep_parens = true) {
+ matcher1 = new MPdtMatcher(ifst1, MATCH_OUTPUT, kParenList);
+ matcher2 = new MPdtMatcher(ifst2, MATCH_INPUT, kParenLoop);
+ filter = new MPdtFilter(ifst1, ifst2, matcher1, matcher2, &parens,
+ &assignments, 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 Arc>
+class MPdtComposeFstOptions<Arc, false>
+ : public ComposeFstOptions<
+ Arc, ParenMatcher<Fst<Arc>>,
+ MPdtParenFilter<SequenceComposeFilter<ParenMatcher<Fst<Arc>> >> > {
+ public:
+ using Label = typename Arc::Label;
+ using MPdtMatcher = ParenMatcher<Fst<Arc>>;
+ using MPdtFilter = MPdtParenFilter<SequenceComposeFilter<MPdtMatcher>>;
+
+ using ComposeFstOptions<Arc, MPdtMatcher, MPdtFilter>::matcher1;
+ using ComposeFstOptions<Arc, MPdtMatcher, MPdtFilter>::matcher2;
+ using ComposeFstOptions<Arc, MPdtMatcher, MPdtFilter>::filter;
+
+ MPdtComposeFstOptions(const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const std::vector<typename Arc::Label> &assignments,
+ bool expand = false, bool keep_parens = true) {
+ matcher1 = new MPdtMatcher(ifst1, MATCH_OUTPUT, kParenLoop);
+ matcher2 = new MPdtMatcher(ifst2, MATCH_INPUT, kParenList);
+ filter = new MPdtFilter(ifst1, ifst2, matcher1, matcher2, &parens,
+ &assignments, expand, keep_parens);
+ }
+};
+
+struct MPdtComposeOptions {
+ bool connect; // Connect output?
+ PdtComposeFilter filter_type; // Which pre-defined filter to use.
+
+ explicit MPdtComposeOptions(bool connect = true,
+ PdtComposeFilter filter_type = PAREN_FILTER)
+ : connect(connect), filter_type(filter_type) {}
+};
+
+// Composes multi-pushdown transducer (MPDT) encoded as an FST (1st arg) and an
+// FST (2nd arg) with the result also an MPDT encoded as an FST (3rd arg). In
+// theMPDTs, some transitions are labeled with open or close parentheses (and
+// associated with a stack). To be interpreted as an MPDT, the parents on each
+// stack must balance on a path (see MPdtExpand()). The open-close parenthesis
+// label pairs are passed using the parens arguments, and the stack assignments
+// are passed using the assignments argument.
+template <class Arc>
+void Compose(
+ const Fst<Arc> &ifst1,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens,
+ const std::vector<typename Arc::Label> &assignments, const Fst<Arc> &ifst2,
+ MutableFst<Arc> *ofst,
+ const MPdtComposeOptions &opts = MPdtComposeOptions()) {
+ bool expand = opts.filter_type != PAREN_FILTER;
+ bool keep_parens = opts.filter_type != EXPAND_FILTER;
+ MPdtComposeFstOptions<Arc, true> copts(ifst1, parens, assignments, ifst2,
+ expand, keep_parens);
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ if (opts.connect) Connect(ofst);
+}
+
+// Composes an FST (1st arg) and a multi-pushdown transducer (MPDT) encoded as
+// an FST (2nd arg) with the result also an MPDT encoded as an FST (3rd arg).
+// In the MPDTs, some transitions are labeled with open or close parentheses
+// (and associated with a stack). To be interpreted as an MPDT, the parents on
+// each stack must balance on a path (see MPdtExpand()). The open-close
+// parenthesis label pairs are passed using the parens arguments, and the stack
+// assignments are passed using the assignments argument.
+template <class Arc>
+void Compose(
+ const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens,
+ const std::vector<typename Arc::Label> &assignments, MutableFst<Arc> *ofst,
+ const MPdtComposeOptions &opts = MPdtComposeOptions()) {
+ bool expand = opts.filter_type != PAREN_FILTER;
+ bool keep_parens = opts.filter_type != EXPAND_FILTER;
+ MPdtComposeFstOptions<Arc, false> copts(ifst1, ifst2, parens, assignments,
+ expand, keep_parens);
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ if (opts.connect) Connect(ofst);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_MPDT_COMPOSE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Expands an MPDT to an FST.
+
+#ifndef FST_EXTENSIONS_MPDT_EXPAND_H_
+#define FST_EXTENSIONS_MPDT_EXPAND_H_
+
+#include <vector>
+
+#include <fst/extensions/mpdt/mpdt.h>
+#include <fst/extensions/pdt/paren.h>
+#include <fst/cache.h>
+#include <fst/mutable-fst.h>
+#include <fst/queue.h>
+#include <fst/state-table.h>
+#include <fst/test-properties.h>
+
+namespace fst {
+
+template <class Arc>
+struct MPdtExpandFstOptions : public CacheOptions {
+ bool keep_parentheses;
+ internal::MPdtStack<typename Arc::StateId, typename Arc::Label> *stack;
+ PdtStateTable<typename Arc::StateId, typename Arc::StateId> *state_table;
+
+ MPdtExpandFstOptions(
+ const CacheOptions &opts = CacheOptions(), bool kp = false,
+ internal::MPdtStack<typename Arc::StateId, typename Arc::Label> *s =
+ nullptr,
+ PdtStateTable<typename Arc::StateId, typename Arc::StateId> *st = nullptr)
+ : CacheOptions(opts), keep_parentheses(kp), stack(s), state_table(st) {}
+};
+
+// Properties for an expanded PDT.
+inline uint64 MPdtExpandProperties(uint64 inprops) {
+ return inprops & (kAcceptor | kAcyclic | kInitialAcyclic | kUnweighted);
+}
+
+namespace internal {
+
+// Implementation class for ExpandFst
+template <class Arc>
+class MPdtExpandFstImpl : public CacheImpl<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using StackId = StateId;
+ using StateTuple = PdtStateTuple<StateId, StackId>;
+ using ParenStack = internal::MPdtStack<StateId, Label>;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::Properties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheBaseImpl<CacheState<Arc>>::PushArc;
+ using CacheBaseImpl<CacheState<Arc>>::HasArcs;
+ using CacheBaseImpl<CacheState<Arc>>::HasFinal;
+ using CacheBaseImpl<CacheState<Arc>>::HasStart;
+ using CacheBaseImpl<CacheState<Arc>>::SetArcs;
+ using CacheBaseImpl<CacheState<Arc>>::SetFinal;
+ using CacheBaseImpl<CacheState<Arc>>::SetStart;
+
+ MPdtExpandFstImpl(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const std::vector<Label> &assignments,
+ const MPdtExpandFstOptions<Arc> &opts)
+ : CacheImpl<Arc>(opts),
+ fst_(fst.Copy()),
+ stack_(opts.stack ? opts.stack : new ParenStack(parens, assignments)),
+ state_table_(opts.state_table ? opts.state_table
+ : new PdtStateTable<StateId, StackId>()),
+ own_stack_(!opts.stack),
+ own_state_table_(!opts.state_table),
+ keep_parentheses_(opts.keep_parentheses) {
+ SetType("expand");
+ const auto props = fst.Properties(kFstProperties, false);
+ SetProperties(MPdtExpandProperties(props), kCopyProperties);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ }
+
+ MPdtExpandFstImpl(const MPdtExpandFstImpl &impl)
+ : CacheImpl<Arc>(impl),
+ fst_(impl.fst_->Copy(true)),
+ stack_(new ParenStack(*impl.stack_)),
+ state_table_(new PdtStateTable<StateId, StackId>()),
+ own_stack_(true),
+ own_state_table_(true),
+ keep_parentheses_(impl.keep_parentheses_) {
+ SetType("expand");
+ SetProperties(impl.Properties(), kCopyProperties);
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ ~MPdtExpandFstImpl() 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;
+ const StateTuple tuple(s, 0);
+ const auto start = state_table_->FindState(tuple);
+ SetStart(start);
+ }
+ return CacheImpl<Arc>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) {
+ const auto &tuple = state_table_->Tuple(s);
+ const auto weight = fst_->Final(tuple.state_id);
+ SetFinal(s,
+ (weight != Weight::Zero() && tuple.stack_id == 0)
+ ? weight
+ : Weight::Zero());
+ }
+ return CacheImpl<Arc>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) ExpandState(s);
+ return CacheImpl<Arc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) ExpandState(s);
+ return CacheImpl<Arc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) ExpandState(s);
+ return CacheImpl<Arc>::NumOutputEpsilons(s);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) ExpandState(s);
+ CacheImpl<Arc>::InitArcIterator(s, data);
+ }
+
+ // Computes the outgoing transitions from a state, creating new destination
+ // states as needed.
+ void ExpandState(StateId s) {
+ const auto tuple = state_table_->Tuple(s);
+ for (ArcIterator<Fst<Arc>> 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) {
+ continue; // Non-matching close parenthesis.
+ } else if ((stack_id != tuple.stack_id) && !keep_parentheses_) {
+ arc.ilabel = arc.olabel = 0; // Stack push/pop.
+ }
+ const StateTuple ntuple(arc.nextstate, stack_id);
+ arc.nextstate = state_table_->FindState(ntuple);
+ PushArc(s, arc);
+ }
+ SetArcs(s);
+ }
+
+ const ParenStack &GetStack() const { return *stack_; }
+
+ const PdtStateTable<StateId, StackId> &GetStateTable() const {
+ return *state_table_;
+ }
+
+ private:
+ std::unique_ptr<const Fst<Arc>> fst_;
+ ParenStack *stack_;
+ PdtStateTable<StateId, StackId> *state_table_;
+ const bool own_stack_;
+ const bool own_state_table_;
+ const bool keep_parentheses_;
+
+ MPdtExpandFstImpl &operator=(const MPdtExpandFstImpl &) = delete;
+};
+
+} // namespace internal
+
+// Expands a multi-pushdown transducer (MPDT) encoded as an FST into an FST.
+// This version is a delayed 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
+// pairs are passed using the parens argument, and the assignment of those pairs
+// to stacks is passed using the assignments argument. Expansion enforces the
+// parenthesis constraints. The MPDT must be
+// expandable as an FST.
+//
+// This class attaches interface to implementation and handles
+// reference counting, delegating most methods to ImplToFst.
+template <class A>
+class MPdtExpandFst : public ImplToFst<internal::MPdtExpandFstImpl<A>> {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using StackId = StateId;
+ using ParenStack = internal::MPdtStack<StackId, Label>;
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::MPdtExpandFstImpl<Arc>;
+
+ friend class ArcIterator<MPdtExpandFst<Arc>>;
+ friend class StateIterator<MPdtExpandFst<Arc>>;
+
+ MPdtExpandFst(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const std::vector<Label> &assignments)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, parens, assignments,
+ MPdtExpandFstOptions<Arc>())) {}
+
+ MPdtExpandFst(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const std::vector<Label> &assignments,
+ const MPdtExpandFstOptions<Arc> &opts)
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, parens, assignments, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ MPdtExpandFst(const MPdtExpandFst<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this ExpandFst. See Fst<>::Copy() for further doc.
+ MPdtExpandFst<Arc> *Copy(bool safe = false) const override {
+ return new MPdtExpandFst<A>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ const ParenStack &GetStack() const { return GetImpl()->GetStack(); }
+
+ const PdtStateTable<StateId, StackId> &GetStateTable() const {
+ return GetImpl()->GetStateTable();
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ void operator=(const MPdtExpandFst &) = delete;
+};
+
+// Specialization for MPdtExpandFst.
+template <class Arc>
+class StateIterator<MPdtExpandFst<Arc>>
+ : public CacheStateIterator<MPdtExpandFst<Arc>> {
+ public:
+ explicit StateIterator(const MPdtExpandFst<Arc> &fst)
+ : CacheStateIterator<MPdtExpandFst<Arc>>(fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for MPdtExpandFst.
+template <class Arc>
+class ArcIterator<MPdtExpandFst<Arc>>
+ : public CacheArcIterator<MPdtExpandFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const MPdtExpandFst<Arc> &fst, StateId s)
+ : CacheArcIterator<MPdtExpandFst<Arc>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->ExpandState(s);
+ }
+};
+
+template <class Arc>
+inline void MPdtExpandFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<MPdtExpandFst<Arc>>(*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 <class Arc>
+void Expand(const Fst<Arc> &ifst,
+ const std::vector<
+ std::pair<typename Arc::Label, typename Arc::Label>> &parens,
+ const std::vector<typename Arc::Label> &assignments,
+ MutableFst<Arc> *ofst, const MPdtExpandOptions &opts) {
+ MPdtExpandFstOptions<Arc> eopts;
+ eopts.gc_limit = 0;
+ eopts.keep_parentheses = opts.keep_parentheses;
+ *ofst = MPdtExpandFst<Arc>(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 <class Arc>
+void Expand(const Fst<Arc> &ifst,
+ const std::vector<std::pair<typename Arc::Label,
+ typename Arc::Label>> &parens,
+ const std::vector<typename Arc::Label> &assignments,
+ MutableFst<Arc> *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_
--- /dev/null
+// 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 <unordered_map>
+#include <vector>
+
+#include <fst/extensions/mpdt/mpdt.h>
+#include <fst/fst.h>
+
+namespace fst {
+
+// Compute various information about MPDTs, helper class for mpdtinfo.cc.
+template <class Arc, typename Arc::Label nlevels = 2>
+class MPdtInfo {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ MPdtInfo(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const std::vector<Label> &assignments);
+
+ const string &FstType() const { return fst_type_; }
+
+ const string &ArcType() const { return Arc::Type(); }
+
+ int64 NumStates() const { return nstates_; }
+
+ int64 NumArcs() const { return narcs_; }
+
+ int64 NumLevels() const { return nlevels; }
+
+ int64 NumOpenParens(Label level) const { return nopen_parens_[level]; }
+
+ int64 NumCloseParens(Label level) const { return nclose_parens_[level]; }
+
+ int64 NumUniqueOpenParens(Label level) const {
+ return nuniq_open_parens_[level];
+ }
+
+ int64 NumUniqueCloseParens(Label level) const {
+ return nuniq_close_parens_[level];
+ }
+ int64 NumOpenParenStates(Label level) const {
+ return nopen_paren_states_[level];
+ }
+
+ int64 NumCloseParenStates(Label level) const {
+ return nclose_paren_states_[level];
+ }
+
+ void Print();
+
+ private:
+ string fst_type_;
+ int64 nstates_;
+ int64 narcs_;
+ int64 nopen_parens_[nlevels];
+ int64 nclose_parens_[nlevels];
+ int64 nuniq_open_parens_[nlevels];
+ int64 nuniq_close_parens_[nlevels];
+ int64 nopen_paren_states_[nlevels];
+ int64 nclose_paren_states_[nlevels];
+ bool error_;
+};
+
+template <class Arc, typename Arc::Label nlevels>
+MPdtInfo<Arc, nlevels>::MPdtInfo(
+ const Fst<Arc> &fst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens,
+ const std::vector<typename Arc::Label> &assignments)
+ : fst_type_(fst.Type()), nstates_(0), narcs_(0), error_(false) {
+ std::unordered_map<Label, size_t> paren_map;
+ std::unordered_set<Label> paren_set;
+ std::unordered_map<Label, int> paren_levels;
+ std::unordered_set<StateId> open_paren_state_set;
+ std::unordered_set<StateId> close_paren_state_set;
+ if (parens.size() != assignments.size()) {
+ FSTERROR() << "MPdtInfo: Parens of different size from assignments";
+ error_ = true;
+ return;
+ }
+ for (Label i = 0; i < assignments.size(); ++i) {
+ // Assignments here start at 0, so assuming the human-readable version has
+ // them starting at 1, we should subtract 1 here.
+ Label level = assignments[i] - 1;
+ if (level < 0 || level >= nlevels) {
+ FSTERROR() << "MPdtInfo: Specified level " << level << " out of bounds";
+ error_ = true;
+ return;
+ }
+ const auto &pair = parens[i];
+ paren_levels[pair.first] = level;
+ paren_levels[pair.second] = level;
+ paren_map[pair.first] = i;
+ paren_map[pair.second] = i;
+ }
+ for (Label i = 0; i < nlevels; ++i) {
+ nopen_parens_[i] = 0;
+ nclose_parens_[i] = 0;
+ nuniq_open_parens_[i] = 0;
+ nuniq_close_parens_[i] = 0;
+ nopen_paren_states_[i] = 0;
+ nclose_paren_states_[i] = 0;
+ }
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ ++nstates_;
+ const auto s = siter.Value();
+ for (ArcIterator<Fst<Arc>> aiter(fst, s); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ ++narcs_;
+ const auto it = paren_map.find(arc.ilabel);
+ if (it != paren_map.end()) {
+ const auto open_paren = parens[it->second].first;
+ const auto close_paren = parens[it->second].second;
+ const auto level = paren_levels[arc.ilabel];
+ if (arc.ilabel == open_paren) {
+ ++nopen_parens_[level];
+ if (!paren_set.count(open_paren)) {
+ ++nuniq_open_parens_[level];
+ paren_set.insert(open_paren);
+ }
+ if (!open_paren_state_set.count(arc.nextstate)) {
+ ++nopen_paren_states_[level];
+ open_paren_state_set.insert(arc.nextstate);
+ }
+ } else {
+ ++nclose_parens_[level];
+ if (!paren_set.count(close_paren)) {
+ ++nuniq_close_parens_[level];
+ paren_set.insert(close_paren);
+ }
+ if (!close_paren_state_set.count(s)) {
+ ++nclose_paren_states_[level];
+ close_paren_state_set.insert(s);
+ }
+ }
+ }
+ }
+ }
+}
+
+template <class Arc, typename Arc::Label nlevels>
+void MPdtInfo<Arc, nlevels>::Print() {
+ const auto old = std::cout.setf(std::ios::left);
+ std::cout.width(50);
+ std::cout << "fst type" << FstType().c_str() << std::endl;
+ std::cout.width(50);
+ std::cout << "arc type" << ArcType().c_str() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of states" << NumStates() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of arcs" << NumArcs() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of levels" << NumLevels() << std::endl;
+ std::cout.width(50);
+ for (typename Arc::Label i = 0; i < nlevels; ++i) {
+ int level = i + 1;
+ std::cout << "# of open parentheses at levelel " << level << "\t"
+ << NumOpenParens(i) << std::endl;
+ std::cout.width(50);
+ std::cout << "# of close parentheses at levelel " << level << "\t"
+ << NumCloseParens(i) << std::endl;
+ std::cout.width(50);
+ std::cout << "# of unique open parentheses at levelel " << level << "\t"
+ << NumUniqueOpenParens(i) << std::endl;
+ std::cout.width(50);
+ std::cout << "# of unique close parentheses at levelel " << level << "\t"
+ << NumUniqueCloseParens(i) << std::endl;
+ std::cout.width(50);
+ std::cout << "# of open parenthesis dest. states at levelel " << level
+ << "\t" << NumOpenParenStates(i) << std::endl;
+ std::cout.width(50);
+ std::cout << "# of close parenthesis source states at levelel " << level
+ << "\t" << NumCloseParenStates(i) << std::endl;
+ std::cout.width(50);
+ }
+ std::cout.setf(old);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_MPDT_INFO_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Common classes for Multi Pushdown Transducer (MPDT) expansion/traversal.
+
+#ifndef FST_EXTENSIONS_MPDT_MPDT_H_
+#define FST_EXTENSIONS_MPDT_MPDT_H_
+
+#include <array>
+#include <map>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/extensions/pdt/pdt.h>
+
+namespace fst {
+
+enum MPdtType {
+ MPDT_READ_RESTRICT, // Can only read from first empty stack
+ MPDT_WRITE_RESTRICT, // Can only write to first empty stack
+ MPDT_NO_RESTRICT, // No read-write restrictions
+};
+
+namespace internal {
+
+// PLEASE READ THIS CAREFULLY:
+//
+// When USEVECTOR is set, the stack configurations --- the statewise
+// representation of the StackId's for each substack --- is stored in a vector.
+// I would like to do this using an array for efficiency reasons, thus the
+// definition of StackConfig below. However, while this *works* in that tests
+// pass, etc. It causes a memory leak in the compose and expand tests, evidently
+// in the map[] that is being used to store the mapping between these
+// StackConfigs and the external StackId that the caller sees. There are no
+// memory leaks when I use a vector, only with this StackId. Why there should be
+// memory leaks given that I am not mallocing anything is a mystery. In case you
+// were wondering, clearing the map at the end does not help.
+
+template <typename StackId, typename Level, Level nlevels>
+struct StackConfig {
+ StackConfig() : array_() {}
+
+ StackConfig(const StackConfig<StackId, Level, nlevels> &config) {
+ array_ = config.array_;
+ }
+
+ StackId &operator[](const int index) { return array_[index]; }
+
+ const StackId &operator[](const int index) const { return array_[index]; }
+
+ StackConfig &operator=(const StackConfig<StackId, Level, nlevels> &config) {
+ if (this == &config) return *this;
+ array_ = config.array_;
+ return *this;
+ }
+
+ std::array<StackId, nlevels> array_;
+};
+
+template <typename StackId, typename Level, Level nlevels>
+class CompConfig {
+ public:
+ using Config = StackConfig<StackId, Level, nlevels>;
+
+ bool operator()(const Config &x, const Config &y) const {
+ for (Level level = 0; level < nlevels; ++level) {
+ if (x.array_[level] < y.array_[level]) {
+ return true;
+ } else if (x.array_[level] > y.array_[level]) {
+ return false;
+ }
+ }
+ return false;
+ }
+};
+
+// Defines the KeyPair type used as the key to MPdtStack.paren_id_map_. The hash
+// function is provided as a separate struct to match templating syntax.
+template <typename Level>
+struct KeyPair {
+ Level level;
+ size_t underlying_id;
+
+ KeyPair(Level level, size_t id) : level(level), underlying_id(id) {}
+
+ inline bool operator==(const KeyPair<Level> &rhs) const {
+ return level == rhs.level && underlying_id == rhs.underlying_id;
+ }
+};
+
+template <typename Level>
+struct KeyPairHasher {
+ inline size_t operator()(const KeyPair<Level> &keypair) const {
+ return std::hash<Level>()(keypair.level) ^
+ (hash<size_t>()(keypair.underlying_id) << 1);
+ }
+};
+
+template <typename StackId, typename Level, Level nlevels = 2,
+ MPdtType restrict = MPDT_READ_RESTRICT>
+class MPdtStack {
+ public:
+ using Label = Level;
+ using Config = StackConfig<StackId, Level, nlevels>;
+ using ConfigToStackId =
+ std::map<Config, StackId, CompConfig<StackId, Level, nlevels>>;
+
+ MPdtStack(const std::vector<std::pair<Label, Label>> &parens,
+ const std::vector<Level> &assignments);
+
+ MPdtStack(const MPdtStack &mstack);
+
+ ~MPdtStack() {
+ for (Level level = 0; level < nlevels; ++level) delete stacks_[level];
+ }
+
+ StackId Find(StackId stack_id, Label label);
+
+ // For now we do not implement Pop since this is needed only for
+ // ShortestPath().
+
+ // For Top we find the first non-empty config, and find the paren ID of that
+ // (or -1) if there is none, then map that to the external stack_id to return.
+ ssize_t Top(StackId stack_id) const {
+ if (stack_id == -1) return -1;
+ const auto config = InternalStackIds(stack_id);
+ Level level = 0;
+ StackId underlying_id = -1;
+ for (; level < nlevels; ++level) {
+ if (!Empty(config, level)) {
+ underlying_id = stacks_[level]->Top(config[level]);
+ break;
+ }
+ }
+ if (underlying_id == -1) return -1;
+ const auto it = paren_id_map_.find(KeyPair<Level>(level, underlying_id));
+ if (it == paren_id_map_.end()) return -1; // NB: shouldn't happen.
+ return it->second;
+ }
+
+ ssize_t ParenId(Label label) const {
+ const auto it = paren_map_.find(label);
+ return it != paren_map_.end() ? it->second : -1;
+ }
+
+ // TODO(rws): For debugging purposes only: remove later.
+ string PrintConfig(const Config &config) const {
+ string result = "[";
+ for (Level i = 0; i < nlevels; ++i) {
+ char s[128];
+ snprintf(s, sizeof(s), "%d", config[i]);
+ result += string(s);
+ if (i < nlevels - 1) result += ", ";
+ }
+ result += "]";
+ return result;
+ }
+
+ bool Error() { return error_; }
+
+ // Each component stack has an internal stack ID for a given configuration and
+ // label.
+ // This function maps a configuration of those to the stack ID the caller
+ // sees.
+ inline StackId ExternalStackId(const Config &config) {
+ const auto it = config_to_stack_id_map_.find(config);
+ StackId result;
+ if (it == config_to_stack_id_map_.end()) {
+ result = next_stack_id_++;
+ config_to_stack_id_map_.insert(
+ std::pair<Config, StackId>(config, result));
+ stack_id_to_config_map_[result] = config;
+ } else {
+ result = it->second;
+ }
+ return result;
+ }
+
+ // Retrieves the internal stack ID for a corresponding external stack ID.
+ inline const Config InternalStackIds(StackId stack_id) const {
+ auto it = stack_id_to_config_map_.find(stack_id);
+ if (it == stack_id_to_config_map_.end()) {
+ it = stack_id_to_config_map_.find(-1);
+ }
+ return it->second;
+ }
+
+ inline bool Empty(const Config &config, Level level) const {
+ return config[level] <= 0;
+ }
+
+ inline bool AllEmpty(const Config &config) {
+ for (Level level = 0; level < nlevels; ++level) {
+ if (!Empty(config, level)) return false;
+ }
+ return true;
+ }
+
+ bool error_;
+ Label min_paren_;
+ Label max_paren_;
+ // Stores level of each paren.
+ std::unordered_map<Label, Label> paren_levels_;
+ std::vector<std::pair<Label, Label>> parens_; // As in pdt.h.
+ std::unordered_map<Label, size_t> paren_map_; // As in pdt.h.
+ // Maps between internal paren_id and external paren_id.
+ std::unordered_map<KeyPair<Level>, size_t, KeyPairHasher<Level>>
+ paren_id_map_;
+ // Maps between internal stack ids and external stack id.
+ ConfigToStackId config_to_stack_id_map_;
+ std::unordered_map<StackId, Config> stack_id_to_config_map_;
+ StackId next_stack_id_;
+ // Array of stacks.
+ PdtStack<StackId, Label> *stacks_[nlevels];
+};
+
+template <typename StackId, typename Level, Level nlevels, MPdtType restrict>
+MPdtStack<StackId, Level, nlevels, restrict>::MPdtStack(
+ const std::vector<std::pair<Level, Level>> &parens, // NB: Label = Level.
+ const std::vector<Level> &assignments)
+ : error_(false),
+ min_paren_(kNoLabel),
+ max_paren_(kNoLabel),
+ parens_(parens),
+ next_stack_id_(1) {
+ using Label = Level;
+ if (parens.size() != assignments.size()) {
+ FSTERROR() << "MPdtStack: Parens of different size from assignments";
+ error_ = true;
+ return;
+ }
+ std::vector<std::pair<Label, Label>> vectors[nlevels];
+ for (Level i = 0; i < assignments.size(); ++i) {
+ // Assignments here start at 0, so assuming the human-readable version has
+ // them starting at 1, we should subtract 1 here
+ const auto level = assignments[i] - 1;
+ if (level < 0 || level >= nlevels) {
+ FSTERROR() << "MPdtStack: Specified level " << level << " out of bounds";
+ error_ = true;
+ return;
+ }
+ const auto &pair = parens[i];
+ vectors[level].push_back(pair);
+ paren_levels_[pair.first] = level;
+ paren_levels_[pair.second] = level;
+ paren_map_[pair.first] = i;
+ paren_map_[pair.second] = i;
+ const KeyPair<Level> key(level, vectors[level].size() - 1);
+ paren_id_map_[key] = i;
+ if (min_paren_ == kNoLabel || pair.first < min_paren_) {
+ min_paren_ = pair.first;
+ }
+ if (pair.second < min_paren_) min_paren_ = pair.second;
+ if (max_paren_ == kNoLabel || pair.first > max_paren_) {
+ max_paren_ = pair.first;
+ }
+ if (pair.second > max_paren_) max_paren_ = pair.second;
+ }
+ using Config = StackConfig<StackId, Level, nlevels>;
+ Config neg_one;
+ Config zero;
+ for (Level level = 0; level < nlevels; ++level) {
+ stacks_[level] = new PdtStack<StackId, Label>(vectors[level]);
+ neg_one[level] = -1;
+ zero[level] = 0;
+ }
+ config_to_stack_id_map_[neg_one] = -1;
+ config_to_stack_id_map_[zero] = 0;
+ stack_id_to_config_map_[-1] = neg_one;
+ stack_id_to_config_map_[0] = zero;
+}
+
+template <typename StackId, typename Level, Level nlevels, MPdtType restrict>
+MPdtStack<StackId, Level, nlevels, restrict>::MPdtStack(
+ const MPdtStack<StackId, Level, nlevels, restrict> &mstack)
+ : error_(mstack.error_),
+ min_paren_(mstack.min_paren_),
+ max_paren_(mstack.max_paren_),
+ parens_(mstack.parens_),
+ next_stack_id_(mstack.next_stack_id_) {
+ for (const auto &kv : mstack.paren_levels_) {
+ paren_levels_[kv.first] = kv.second;
+ }
+ for (const auto &paren : mstack.parens_) parens_.push_back(paren);
+ for (const auto &kv : mstack.paren_map_) {
+ paren_map_[kv.first] = kv.second;
+ }
+ for (const auto &kv : mstack.paren_id_map_) {
+ paren_id_map_[kv.first] = kv.second;
+ }
+ for (auto it = mstack.config_to_stack_id_map_.begin();
+ it != mstack.config_to_stack_id_map_.end(); ++it) {
+ config_to_stack_id_map_[it->first] = it->second;
+ }
+ for (const auto &kv : mstack.stack_id_to_config_map_) {
+ using Config = StackConfig<StackId, Level, nlevels>;
+ const Config config(kv.second);
+ stack_id_to_config_map_[kv.first] = config;
+ }
+ for (Level level = 0; level < nlevels; ++level)
+ stacks_[level] = mstack.stacks_[level];
+}
+
+template <typename StackId, typename Level, Level nlevels, MPdtType restrict>
+StackId MPdtStack<StackId, Level, nlevels, restrict>::Find(StackId stack_id,
+ Level label) {
+ // Non-paren.
+ if (min_paren_ == kNoLabel || label < min_paren_ || label > max_paren_) {
+ return stack_id;
+ }
+ const auto it = paren_map_.find(label);
+ // Non-paren.
+ if (it == paren_map_.end()) return stack_id;
+ ssize_t paren_id = it->second;
+ // Gets the configuration associated with this stack_id.
+ const auto config = InternalStackIds(stack_id);
+ // Gets the level.
+ const auto level = paren_levels_.find(label)->second;
+ // If the label is an open paren we push:
+ //
+ // 1) if the restrict type is not MPDT_WRITE_RESTRICT, or
+ // 2) the restrict type is MPDT_WRITE_RESTRICT, and all the stacks above the
+ // level are empty.
+ if (label == parens_[paren_id].first) { // Open paren.
+ if (restrict == MPDT_WRITE_RESTRICT) {
+ for (Level upper_level = 0; upper_level < level; ++upper_level) {
+ if (!Empty(config, upper_level)) return -1; // Non-empty stack blocks.
+ }
+ }
+ // If the label is an close paren we pop:
+ //
+ // 1) if the restrict type is not MPDT_READ_RESTRICT, or
+ // 2) the restrict type is MPDT_READ_RESTRICT, and all the stacks above the
+ // level are empty.
+ } else if (restrict == MPDT_READ_RESTRICT) {
+ for (Level lower_level = 0; lower_level < level; ++lower_level) {
+ if (!Empty(config, lower_level)) return -1; // Non-empty stack blocks.
+ }
+ }
+ const auto nid = stacks_[level]->Find(config[level], label);
+ // If the new ID is -1, that means that there is no valid transition at the
+ // level we want.
+ if (nid == -1) {
+ return -1;
+ } else {
+ using Config = StackConfig<StackId, Level, nlevels>;
+ Config nconfig(config);
+ nconfig[level] = nid;
+ return ExternalStackId(nconfig);
+ }
+}
+
+} // namespace internal
+} // namespace fst
+
+#endif // FST_EXTENSIONS_MPDT_MPDT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// This is an experimental multipush-down transducer (MPDT) library. An MPDT is
+// encoded as an FST, where some transitions are labeled with open or close
+// parentheses, each mated pair of which is associated to one stack. To be
+// interpreted as an MPDT, the parentheses within a stack must balance on a
+// path.
+
+#ifndef FST_EXTENSIONS_MPDT_MPDTLIB_H_
+#define FST_EXTENSIONS_MPDT_MPDTLIB_H_
+
+#include <fst/extensions/mpdt/compose.h>
+#include <fst/extensions/mpdt/expand.h>
+#include <fst/extensions/mpdt/mpdt.h>
+#include <fst/extensions/mpdt/reverse.h>
+
+#endif // FST_EXTENSIONS_MPDT_MPDTLIB_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Convenience file for including all MPDT operations at once, and/or
+// registering them for new arc types.
+
+#ifndef FST_EXTENSIONS_MPDT_MPDTSCRIPT_H_
+#define FST_EXTENSIONS_MPDT_MPDTSCRIPT_H_
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include <fst/compose.h> // for ComposeOptions
+#include <fst/util.h>
+
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/shortest-path.h>
+
+#include <fst/extensions/mpdt/compose.h>
+#include <fst/extensions/mpdt/expand.h>
+#include <fst/extensions/mpdt/info.h>
+#include <fst/extensions/mpdt/reverse.h>
+
+#include <fst/extensions/pdt/pdtscript.h> // For LabelClassPair,
+ // FstClassPair, and to detect
+ // any collisions.
+
+namespace fst {
+namespace script {
+
+using MPdtComposeArgs =
+ args::Package<const FstClass &, const FstClass &,
+ const std::vector<LabelPair> &, const std::vector<int64> &,
+ MutableFstClass *, const MPdtComposeOptions &, bool>;
+
+template <class Arc>
+void MPdtCompose(MPdtComposeArgs *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg5->GetMutableFst<Arc>();
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ typed_parens(args->arg3.size());
+ std::copy(args->arg3.begin(), args->arg3.end(), typed_parens.begin());
+ using Level = typename Arc::Label;
+ std::vector<Level> typed_assignments(args->arg4.size());
+ std::copy(args->arg4.begin(), args->arg4.end(), typed_assignments.begin());
+ if (args->arg7) {
+ Compose(ifst1, typed_parens, typed_assignments, ifst2, ofst, args->arg6);
+ } else {
+ Compose(ifst1, ifst2, typed_parens, typed_assignments, ofst, args->arg6);
+ }
+}
+
+void MPdtCompose(const FstClass &ifst1, const FstClass &ifst2,
+ const std::vector<LabelPair> &parens,
+ const std::vector<int64> &assignments, MutableFstClass *ofst,
+ const MPdtComposeOptions &copts, bool left_pdt);
+
+using MPdtExpandArgs =
+ args::Package<const FstClass &, const std::vector<LabelPair> &,
+ const std::vector<int64> &, MutableFstClass *,
+ const MPdtExpandOptions &>;
+
+template <class Arc>
+void MPdtExpand(MPdtExpandArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg4->GetMutableFst<Arc>();
+ // In case Arc::Label is not the same as FstClass::Label, we make copies.
+ // Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ typed_parens(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_parens.begin());
+ using Level = typename Arc::Label;
+ std::vector<Level> typed_assignments(args->arg3.size());
+ std::copy(args->arg3.begin(), args->arg3.end(), typed_assignments.begin());
+ Expand(fst, typed_parens, typed_assignments, ofst,
+ MPdtExpandOptions(args->arg5.connect, args->arg5.keep_parentheses));
+}
+
+void MPdtExpand(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ const std::vector<int64> &assignments, MutableFstClass *ofst,
+ const MPdtExpandOptions &opts);
+
+using MPdtReverseArgs =
+ args::Package<const FstClass &, const std::vector<LabelPair> &,
+ std::vector<int64> *, MutableFstClass *>;
+
+template <class Arc>
+void MPdtReverse(MPdtReverseArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg4->GetMutableFst<Arc>();
+ // In case Arc::Label is not the same as FstClass::Label, we make copies.
+ // Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ typed_parens(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_parens.begin());
+ using Level = typename Arc::Label;
+ std::vector<Level> typed_assignments(args->arg3->size());
+ std::copy(args->arg3->begin(), args->arg3->end(), typed_assignments.begin());
+ Reverse(fst, typed_parens, &typed_assignments, ofst);
+ // Reassign stack assignments to input assignment vector.
+ std::copy(typed_assignments.begin(), typed_assignments.end(),
+ args->arg3->begin());
+}
+
+void MPdtReverse(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ std::vector<int64> *assignments, MutableFstClass *ofst);
+
+using PrintMPdtInfoArgs =
+ args::Package<const FstClass &, const std::vector<LabelPair> &,
+ const std::vector<int64> &>;
+
+template <class Arc>
+void PrintMPdtInfo(PrintMPdtInfoArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ // In case Arc::Label is not the same as FstClass::Label, we make copies.
+ // Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ typed_parens(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_parens.begin());
+ using Level = typename Arc::Label;
+ std::vector<Level> typed_assignments(args->arg3.size());
+ std::copy(args->arg3.begin(), args->arg3.end(), typed_assignments.begin());
+ MPdtInfo<Arc> mpdtinfo(fst, typed_parens, typed_assignments);
+ mpdtinfo.Print();
+}
+
+void PrintMPdtInfo(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ const std::vector<int64> &assignments);
+
+} // namespace script
+} // namespace fst
+
+#define REGISTER_FST_MPDT_OPERATIONS(ArcType) \
+ REGISTER_FST_OPERATION(MPdtCompose, ArcType, MPdtComposeArgs); \
+ REGISTER_FST_OPERATION(MPdtExpand, ArcType, MPdtExpandArgs); \
+ REGISTER_FST_OPERATION(MPdtReverse, ArcType, MPdtReverseArgs); \
+ REGISTER_FST_OPERATION(PrintMPdtInfo, ArcType, PrintMPdtInfoArgs)
+#endif // FST_EXTENSIONS_MPDT_MPDTSCRIPT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Definition of ReadLabelTriples based on ReadLabelPairs, like that in
+// nlp/fst/lib/util.h for pairs, and similarly for WriteLabelTriples.
+
+#ifndef FST_EXTENSIONS_MPDT_READ_WRITE_UTILS_H_
+#define FST_EXTENSIONS_MPDT_READ_WRITE_UTILS_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <fstream>
+#include <fst/test-properties.h>
+
+namespace fst {
+
+// Returns true on success.
+template <typename Label>
+bool ReadLabelTriples(const string &filename,
+ std::vector<std::pair<Label, Label>> *pairs,
+ std::vector<Label> *assignments,
+ bool allow_negative = false) {
+ std::ifstream fstrm(filename);
+ if (!fstrm) {
+ LOG(ERROR) << "ReadIntTriples: Can't open file: " << filename;
+ return false;
+ }
+ static constexpr auto kLineLen = 8096;
+ char line[kLineLen];
+ size_t nline = 0;
+ pairs->clear();
+ while (fstrm.getline(line, kLineLen)) {
+ ++nline;
+ std::vector<char *> col;
+ SplitToVector(line, "\n\t ", &col, true);
+ // Empty line or comment?
+ if (col.empty() || col[0][0] == '\0' || col[0][0] == '#') continue;
+ if (col.size() != 3) {
+ LOG(ERROR) << "ReadLabelTriples: Bad number of columns, "
+ << "file = " << filename << ", line = " << nline;
+ return false;
+ }
+ bool err;
+ const Label i1 = StrToInt64(col[0], filename, nline, allow_negative, &err);
+ if (err) return false;
+ const Label i2 = StrToInt64(col[1], filename, nline, allow_negative, &err);
+ if (err) return false;
+ using Level = Label;
+ const Level i3 = StrToInt64(col[2], filename, nline, allow_negative, &err);
+ if (err) return false;
+ pairs->push_back(std::make_pair(i1, i2));
+ assignments->push_back(i3);
+ }
+ return true;
+}
+
+// Returns true on success.
+template <typename Label>
+bool WriteLabelTriples(const string &filename,
+ const std::vector<std::pair<Label, Label>> &pairs,
+ const std::vector<Label> &assignments) {
+ if (pairs.size() != assignments.size()) {
+ LOG(ERROR) << "WriteLabelTriples: Pairs and assignments of different sizes";
+ return false;
+ }
+ std::ofstream fstrm(filename);
+ if (!fstrm) {
+ LOG(ERROR) << "WriteLabelTriples: Can't open file: " << filename;
+ return false;
+ }
+ for (size_t n = 0; n < pairs.size(); ++n)
+ fstrm << pairs[n].first << "\t" << pairs[n].second << "\t" << assignments[n]
+ << "\n";
+ if (!fstrm) {
+ LOG(ERROR) << "WriteLabelTriples: Write failed: "
+ << (filename.empty() ? "standard output" : filename);
+ return false;
+ }
+ return true;
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_MPDT_READ_WRITE_UTILS_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Reverses an MPDT.
+
+#ifndef FST_EXTENSIONS_MPDT_REVERSE_H_
+#define FST_EXTENSIONS_MPDT_REVERSE_H_
+
+#include <limits>
+#include <vector>
+
+#include <fst/mutable-fst.h>
+#include <fst/relabel.h>
+#include <fst/reverse.h>
+
+namespace fst {
+
+// Reverses a multi-stack pushdown transducer (MPDT) encoded as an FST.
+template <class Arc, class RevArc>
+void Reverse(
+ const Fst<Arc> &ifst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens,
+ std::vector<typename Arc::Label> *assignments, MutableFst<RevArc> *ofst) {
+ using Label = typename Arc::Label;
+ // Reverses FST component.
+ Reverse(ifst, ofst);
+ // Exchanges open and close parenthesis pairs.
+ std::vector<std::pair<Label, Label>> relabel_pairs;
+ relabel_pairs.reserve(2 * parens.size());
+ for (const auto &pair : parens) {
+ relabel_pairs.emplace_back(pair.first, pair.second);
+ relabel_pairs.emplace_back(pair.second, pair.first);
+ }
+ Relabel(ofst, relabel_pairs, relabel_pairs);
+ // Computes new bounds for the stack assignments.
+ Label max_level = -1;
+ Label min_level = std::numeric_limits<Label>::max();
+ for (const auto assignment : *assignments) {
+ if (assignment < min_level) {
+ min_level = assignment;
+ } else if (assignment > max_level) {
+ max_level = assignment;
+ }
+ }
+ // Actually reverses stack assignments.
+ for (auto &assignment : *assignments) {
+ assignment = (max_level - assignment) + min_level;
+ }
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_MPDT_REVERSE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_EXTENSIONS_NGRAM_BITMAP_INDEX_H_
+#define FST_EXTENSIONS_NGRAM_BITMAP_INDEX_H_
+
+#include <utility>
+#include <vector>
+
+#include <fst/compat.h>
+
+// This class is a bitstring storage class with an index that allows
+// seeking to the Nth set or clear bit in time O(Log(N)) where N is
+// the length of the bit vector. In addition, it allows counting set or
+// clear bits over ranges in constant time.
+//
+// This is accomplished by maintaining an "secondary" index of limited
+// size in bits that maintains a running count of the number of bits set
+// in each block of bitmap data. A block is defined as the number of
+// uint64 values that can fit in the secondary index before an overflow
+// occurs.
+//
+// To handle overflows, a "primary" index containing a running count of
+// bits set in each block is created using the type uint64.
+
+namespace fst {
+
+class BitmapIndex {
+ public:
+ static size_t StorageSize(size_t size) {
+ return ((size + kStorageBlockMask) >> kStorageLogBitSize);
+ }
+
+ BitmapIndex() : bits_(nullptr), size_(0) {}
+
+ bool Get(size_t index) const {
+ return (bits_[index >> kStorageLogBitSize] &
+ (kOne << (index & kStorageBlockMask))) != 0;
+ }
+
+ static void Set(uint64* bits, size_t index) {
+ bits[index >> kStorageLogBitSize] |= (kOne << (index & kStorageBlockMask));
+ }
+
+ static void Clear(uint64* bits, size_t index) {
+ bits[index >> kStorageLogBitSize] &= ~(kOne << (index & kStorageBlockMask));
+ }
+
+ size_t Bits() const { return size_; }
+
+ size_t ArraySize() const { return StorageSize(size_); }
+
+ // Returns the number of one bits in the bitmap
+ size_t GetOnesCount() const {
+ return primary_index_[primary_index_size() - 1];
+ }
+
+ // Returns the number of one bits in positions 0 to limit - 1.
+ // REQUIRES: limit <= Bits()
+ size_t Rank1(size_t end) const;
+
+ // Returns the number of one bits in the range start to end - 1.
+ // REQUIRES: limit <= Bits()
+ size_t GetOnesCountInRange(size_t start, size_t end) const {
+ return Rank1(end) - Rank1(start);
+ }
+
+ // Returns the number of zero bits in positions 0 to limit - 1.
+ // REQUIRES: limit <= Bits()
+ size_t Rank0(size_t end) const { return end - Rank1(end); }
+
+ // Returns the number of zero bits in the range start to end - 1.
+ // REQUIRES: limit <= Bits()
+ size_t GetZeroesCountInRange(size_t start, size_t end) const {
+ return end - start - GetOnesCountInRange(start, end);
+ }
+
+ // Return true if any bit between begin inclusive and end exclusive
+ // is set. 0 <= begin <= end <= Bits() is required.
+ //
+ bool TestRange(size_t start, size_t end) const {
+ return Rank1(end) > Rank1(start);
+ }
+
+ // Returns the offset to the nth set bit (zero based)
+ // or Bits() if index >= number of ones
+ size_t Select1(size_t bit_index) const;
+
+ // Returns the offset to the nth clear bit (zero based)
+ // or Bits() if index > number of
+ size_t Select0(size_t bit_index) const;
+
+ // Returns the offset of the nth and nth+1 clear bit (zero based),
+ // equivalent to two calls to Select0, but more efficient.
+ std::pair<size_t, size_t> Select0s(size_t bit_index) const;
+
+ // Rebuilds from index for the associated Bitmap, should be called
+ // whenever changes have been made to the Bitmap or else behavior
+ // of the indexed bitmap methods will be undefined.
+ void BuildIndex(const uint64* bits, size_t size);
+
+ // the secondary index accumulates counts until it can possibly overflow
+ // this constant computes the number of uint64 units that can fit into
+ // units the size of uint16.
+ static const uint64 kOne = 1;
+ static const uint32 kStorageBitSize = 64;
+ static const uint32 kStorageLogBitSize = 6;
+ static const uint32 kSecondaryBlockSize =
+ ((1 << 16) - 1) >> kStorageLogBitSize;
+
+ private:
+ static const uint32 kStorageBlockMask = kStorageBitSize - 1;
+
+ // returns, from the index, the count of ones up to array_index
+ size_t get_index_ones_count(size_t array_index) const;
+
+ // because the indexes, both primary and secondary, contain a running
+ // count of the population of one bits contained in [0,i), there is
+ // no reason to have an element in the zeroth position as this value would
+ // necessarily be zero. (The bits are indexed in a zero based way.) Thus
+ // we don't store the 0th element in either index. Both of the following
+ // functions, if greater than 0, must be decremented by one before retreiving
+ // the value from the corresponding array.
+ // returns the 1 + the block that contains the bitindex in question
+ // the inverted version works the same but looks for zeros using an inverted
+ // view of the index
+ size_t find_primary_block(size_t bit_index) const;
+
+ size_t find_inverted_primary_block(size_t bit_index) const;
+
+ // similarly, the secondary index (which resets its count to zero at
+ // the end of every kSecondaryBlockSize entries) does not store the element
+ // at 0. Note that the rem_bit_index parameter is the number of bits
+ // within the secondary block, after the bits accounted for by the primary
+ // block have been removed (i.e. the remaining bits) And, because we
+ // reset to zero with each new block, there is no need to store those
+ // actual zeros.
+ // returns 1 + the secondary block that contains the bitindex in question
+ size_t find_secondary_block(size_t block, size_t rem_bit_index) const;
+
+ size_t find_inverted_secondary_block(size_t block,
+ size_t rem_bit_index) const;
+
+ // We create a primary index based upon the number of secondary index
+ // blocks. The primary index uses fields wide enough to accomodate any
+ // index of the bitarray so cannot overflow
+ // The primary index is the actual running
+ // count of one bits set for all blocks (and, thus, all uint64s).
+ size_t primary_index_size() const {
+ return (ArraySize() + kSecondaryBlockSize - 1) / kSecondaryBlockSize;
+ }
+
+ const uint64* bits_;
+ size_t size_;
+
+ // The primary index contains the running popcount of all blocks
+ // which means the nth value contains the popcounts of
+ // [0,n*kSecondaryBlockSize], however, the 0th element is omitted.
+ std::vector<uint32> primary_index_;
+ // The secondary index contains the running popcount of the associated
+ // bitmap. It is the same length (in units of uint16) as the
+ // bitmap's map is in units of uint64s.
+ std::vector<uint16> secondary_index_;
+};
+
+} // end namespace fst
+
+#endif // FST_EXTENSIONS_NGRAM_BITMAP_INDEX_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// NgramFst implements a n-gram language model based upon the LOUDS data
+// structure. Please refer to "Unary Data Structures for Language Models"
+// http://research.google.com/pubs/archive/37218.pdf
+
+#ifndef FST_EXTENSIONS_NGRAM_NGRAM_FST_H_
+#define FST_EXTENSIONS_NGRAM_NGRAM_FST_H_
+
+#include <stddef.h>
+#include <string.h>
+#include <algorithm>
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fstream>
+#include <fst/extensions/ngram/bitmap-index.h>
+#include <fst/fstlib.h>
+#include <fst/mapped-file.h>
+
+namespace fst {
+template <class A>
+class NGramFst;
+template <class A>
+class NGramFstMatcher;
+
+// Instance data containing mutable state for bookkeeping repeated access to
+// the same state.
+template <class A>
+struct NGramFstInst {
+ typedef typename A::Label Label;
+ typedef typename A::StateId StateId;
+ typedef typename A::Weight Weight;
+ StateId state_;
+ size_t num_futures_;
+ size_t offset_;
+ size_t node_;
+ StateId node_state_;
+ std::vector<Label> context_;
+ StateId context_state_;
+ NGramFstInst()
+ : state_(kNoStateId),
+ node_state_(kNoStateId),
+ context_state_(kNoStateId) {}
+};
+
+namespace internal {
+
+// Implementation class for LOUDS based NgramFst interface.
+template <class A>
+class NGramFstImpl : public FstImpl<A> {
+ using FstImpl<A>::SetInputSymbols;
+ using FstImpl<A>::SetOutputSymbols;
+ using FstImpl<A>::SetType;
+ using FstImpl<A>::WriteHeader;
+
+ friend class ArcIterator<NGramFst<A>>;
+ friend class NGramFstMatcher<A>;
+
+ public:
+ using FstImpl<A>::InputSymbols;
+ using FstImpl<A>::SetProperties;
+ using FstImpl<A>::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<A> &fst, std::vector<StateId> *order_out);
+
+ explicit NGramFstImpl(const Fst<A> &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<A> *Read(std::istream &strm, // NOLINT
+ const FstReadOptions &opts) {
+ NGramFstImpl<A> *impl = new NGramFstImpl();
+ FstHeader hdr;
+ if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return 0;
+ uint64 num_states, num_futures, num_final;
+ const size_t offset =
+ sizeof(num_states) + sizeof(num_futures) + sizeof(num_final);
+ // Peek at num_states and num_futures to see how much more needs to be read.
+ strm.read(reinterpret_cast<char *>(&num_states), sizeof(num_states));
+ strm.read(reinterpret_cast<char *>(&num_futures), sizeof(num_futures));
+ strm.read(reinterpret_cast<char *>(&num_final), sizeof(num_final));
+ size_t size = Storage(num_states, num_futures, num_final);
+ MappedFile *data_region = MappedFile::Allocate(size);
+ char *data = reinterpret_cast<char *>(data_region->mutable_data());
+ // Copy num_states, num_futures and num_final back into data.
+ memcpy(data, reinterpret_cast<char *>(&num_states), sizeof(num_states));
+ memcpy(data + sizeof(num_states), reinterpret_cast<char *>(&num_futures),
+ sizeof(num_futures));
+ memcpy(data + sizeof(num_states) + sizeof(num_futures),
+ reinterpret_cast<char *>(&num_final), sizeof(num_final));
+ strm.read(data + offset, size - offset);
+ if (strm.fail()) {
+ delete impl;
+ return nullptr;
+ }
+ impl->Init(data, false, data_region);
+ return impl;
+ }
+
+ bool Write(std::ostream &strm, // NOLINT
+ const FstWriteOptions &opts) const {
+ FstHeader hdr;
+ hdr.SetStart(Start());
+ hdr.SetNumStates(num_states_);
+ WriteHeader(strm, opts, kFileVersion, &hdr);
+ strm.write(data_, StorageSize());
+ return !strm.fail();
+ }
+
+ StateId Start() const { return start_; }
+
+ Weight Final(StateId state) const {
+ if (final_index_.Get(state)) {
+ return final_probs_[final_index_.Rank1(state)];
+ } else {
+ return Weight::Zero();
+ }
+ }
+
+ size_t NumArcs(StateId state, NGramFstInst<A> *inst = nullptr) const {
+ if (inst == nullptr) {
+ const std::pair<size_t, size_t> 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<A> *data) const {
+ data->base = 0;
+ data->nstates = num_states_;
+ }
+
+ static size_t Storage(uint64 num_states, uint64 num_futures,
+ uint64 num_final) {
+ uint64 b64;
+ Weight weight;
+ Label label;
+ size_t offset =
+ sizeof(num_states) + sizeof(num_futures) + sizeof(num_final);
+ offset +=
+ sizeof(b64) * (BitmapIndex::StorageSize(num_states * 2 + 1) +
+ BitmapIndex::StorageSize(num_futures + num_states + 1) +
+ BitmapIndex::StorageSize(num_states));
+ offset += (num_states + 1) * sizeof(label) + num_futures * sizeof(label);
+ // Pad for alignemnt, see
+ // http://en.wikipedia.org/wiki/Data_structure_alignment#Computing_padding
+ offset = (offset + sizeof(weight) - 1) & ~(sizeof(weight) - 1);
+ offset += (num_states + 1) * sizeof(weight) + num_final * sizeof(weight) +
+ (num_futures + 1) * sizeof(weight);
+ return offset;
+ }
+
+ void SetInstFuture(StateId state, NGramFstInst<A> *inst) const {
+ if (inst->state_ != state) {
+ inst->state_ = state;
+ const std::pair<size_t, size_t> zeros = future_index_.Select0s(state);
+ inst->num_futures_ = zeros.second - zeros.first - 1;
+ inst->offset_ = future_index_.Rank1(zeros.first + 1);
+ }
+ }
+
+ void SetInstNode(NGramFstInst<A> *inst) const {
+ if (inst->node_state_ != inst->state_) {
+ inst->node_state_ = inst->state_;
+ inst->node_ = context_index_.Select1(inst->state_);
+ }
+ }
+
+ void SetInstContext(NGramFstInst<A> *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<Label> &GetContext(StateId s, NGramFstInst<A> *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<Label> &context,
+ std::vector<StateId> *states) const;
+
+ private:
+ StateId Transition(const std::vector<Label> &context, Label future) const;
+
+ // Properties always true for this Fst class.
+ static const uint64 kStaticProperties =
+ kAcceptor | kIDeterministic | kODeterministic | kEpsilons | kIEpsilons |
+ kOEpsilons | kILabelSorted | kOLabelSorted | kWeighted | kCyclic |
+ kInitialAcyclic | kNotTopSorted | kAccessible | kCoAccessible |
+ kNotString | kExpanded;
+ // Current file format version.
+ static const int kFileVersion = 4;
+ // Minimum file format version supported.
+ static const int kMinFileVersion = 4;
+
+ std::unique_ptr<MappedFile> data_region_;
+ const char *data_ = nullptr;
+ bool owned_ = false; // True if we own data_
+ StateId start_ = fst::kNoStateId;
+ uint64 num_states_ = 0;
+ uint64 num_futures_ = 0;
+ uint64 num_final_ = 0;
+ std::pair<size_t, size_t> select_root_;
+ const Label *root_children_ = nullptr;
+ // borrowed references
+ const uint64 *context_ = nullptr;
+ const uint64 *future_ = nullptr;
+ const uint64 *final_ = nullptr;
+ const Label *context_words_ = nullptr;
+ const Label *future_words_ = nullptr;
+ const Weight *backoff_ = nullptr;
+ const Weight *final_probs_ = nullptr;
+ const Weight *future_probs_ = nullptr;
+ BitmapIndex context_index_;
+ BitmapIndex future_index_;
+ BitmapIndex final_index_;
+};
+
+template <typename A>
+inline void NGramFstImpl<A>::GetStates(
+ const std::vector<Label> &context,
+ std::vector<typename A::StateId> *states) const {
+ states->clear();
+ states->push_back(0);
+ typename std::vector<Label>::const_reverse_iterator cit = context.rbegin();
+ const Label *children = root_children_;
+ size_t num_children = select_root_.second - 2;
+ const Label *loc = std::lower_bound(children, children + num_children, *cit);
+ if (loc == children + num_children || *loc != *cit) return;
+ size_t node = 2 + loc - children;
+ states->push_back(context_index_.Rank1(node));
+ if (context.size() == 1) return;
+ size_t node_rank = context_index_.Rank1(node);
+ std::pair<size_t, size_t> zeros =
+ node_rank == 0 ? select_root_ : context_index_.Select0s(node_rank);
+ size_t first_child = zeros.first + 1;
+ ++cit;
+ if (context_index_.Get(first_child) != false) {
+ size_t last_child = zeros.second - 1;
+ while (cit != context.rend()) {
+ children = context_words_ + context_index_.Rank1(first_child);
+ loc = std::lower_bound(children, children + last_child - first_child + 1,
+ *cit);
+ if (loc == children + last_child - first_child + 1 || *loc != *cit) {
+ break;
+ }
+ ++cit;
+ node = first_child + loc - children;
+ states->push_back(context_index_.Rank1(node));
+ node_rank = context_index_.Rank1(node);
+ zeros =
+ node_rank == 0 ? select_root_ : context_index_.Select0s(node_rank);
+ first_child = zeros.first + 1;
+ if (context_index_.Get(first_child) == false) break;
+ last_child = zeros.second - 1;
+ }
+ }
+}
+
+} // namespace internal
+
+/*****************************************************************************/
+template <class A>
+class NGramFst : public ImplToExpandedFst<internal::NGramFstImpl<A>> {
+ friend class ArcIterator<NGramFst<A>>;
+ friend class NGramFstMatcher<A>;
+
+ public:
+ typedef A Arc;
+ typedef typename A::StateId StateId;
+ typedef typename A::Label Label;
+ typedef typename A::Weight Weight;
+ typedef internal::NGramFstImpl<A> Impl;
+
+ explicit NGramFst(const Fst<A> &dst)
+ : ImplToExpandedFst<Impl>(std::make_shared<Impl>(dst, nullptr)) {}
+
+ NGramFst(const Fst<A> &fst, std::vector<StateId> *order_out)
+ : ImplToExpandedFst<Impl>(std::make_shared<Impl>(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<A> &fst, bool safe = false)
+ : ImplToExpandedFst<Impl>(fst, false) {}
+
+ NGramFst() : ImplToExpandedFst<Impl>(std::make_shared<Impl>()) {}
+
+ // Non-standard constructor to initialize NGramFst directly from data.
+ NGramFst(const char *data, bool owned)
+ : ImplToExpandedFst<Impl>(std::make_shared<Impl>()) {
+ 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<Label> GetContext(StateId s) const {
+ return GetImpl()->GetContext(s, &inst_);
+ }
+
+ // Consumes as much as possible of context from right to left, returns the
+ // the states corresponding to the increasingly conditioned input sequence.
+ void GetStates(const std::vector<Label> &context,
+ std::vector<StateId> *state) const {
+ return GetImpl()->GetStates(context, state);
+ }
+
+ size_t NumArcs(StateId s) const override {
+ return GetImpl()->NumArcs(s, &inst_);
+ }
+
+ NGramFst<A> *Copy(bool safe = false) const override {
+ return new NGramFst(*this, safe);
+ }
+
+ static NGramFst<A> *Read(std::istream &strm, const FstReadOptions &opts) {
+ Impl *impl = Impl::Read(strm, opts);
+ return impl ? new NGramFst<A>(std::shared_ptr<Impl>(impl)) : nullptr;
+ }
+
+ static NGramFst<A> *Read(const string &filename) {
+ if (!filename.empty()) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm.good()) {
+ LOG(ERROR) << "NGramFst::Read: Can't open file: " << filename;
+ return nullptr;
+ }
+ return Read(strm, FstReadOptions(filename));
+ } else {
+ return Read(std::cin, FstReadOptions("standard input"));
+ }
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return GetImpl()->Write(strm, opts);
+ }
+
+ bool Write(const string &filename) const override {
+ return Fst<A>::WriteFile(filename);
+ }
+
+ inline void InitStateIterator(StateIteratorData<A> *data) const override {
+ GetImpl()->InitStateIterator(data);
+ }
+
+ inline void InitArcIterator(StateId s,
+ ArcIteratorData<A> *data) const override;
+
+ MatcherBase<A> *InitMatcher(MatchType match_type) const override {
+ return new NGramFstMatcher<A>(*this, match_type);
+ }
+
+ size_t StorageSize() const { return GetImpl()->StorageSize(); }
+
+ static bool HasRequiredProps(const Fst<A> &fst) {
+ int64 props =
+ kAcceptor | kIDeterministic | kILabelSorted | kIEpsilons | kAccessible;
+ return fst.Properties(props, true) == props;
+ }
+
+ static bool HasRequiredStructure(const Fst<A> &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<Fst<A>> 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<Fst<A>> siter(fst); !siter.Done();
+ siter.Next()) {
+ const typename A::StateId &state = siter.Value();
+ fst::ArcIterator<Fst<A>> 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<Impl, ExpandedFst<A>>::GetImpl;
+ using ImplToExpandedFst<Impl, ExpandedFst<A>>::GetMutableImpl;
+
+ explicit NGramFst(std::shared_ptr<Impl> impl)
+ : ImplToExpandedFst<Impl>(impl) {}
+
+ mutable NGramFstInst<A> inst_;
+};
+
+template <class A>
+inline void NGramFst<A>::InitArcIterator(StateId s,
+ ArcIteratorData<A> *data) const {
+ GetImpl()->SetInstFuture(s, &inst_);
+ GetImpl()->SetInstNode(&inst_);
+ data->base = new ArcIterator<NGramFst<A>>(*this, s);
+}
+
+namespace internal {
+
+template <typename A>
+NGramFstImpl<A>::NGramFstImpl(const Fst<A> &fst,
+ std::vector<StateId> *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<A>::HasRequiredProps(fst)) {
+ FSTERROR() << "NGramFst only accepts OpenGrm language models as input";
+ SetProperties(kError, kError);
+ return;
+ }
+
+ int64 num_states = CountStates(fst);
+ Label *context = new Label[num_states];
+
+ // Find the unigram state by starting from the start state, following
+ // epsilons.
+ StateId unigram = fst.Start();
+ while (1) {
+ if (unigram == kNoStateId) {
+ FSTERROR() << "Could not identify unigram state";
+ SetProperties(kError, kError);
+ return;
+ }
+ ArcIterator<Fst<A>> aiter(fst, unigram);
+ if (aiter.Done()) {
+ LOG(WARNING) << "Unigram state " << unigram << " has no arcs.";
+ break;
+ }
+ if (aiter.Value().ilabel != 0) break;
+ unigram = aiter.Value().nextstate;
+ }
+
+ // Each state's context is determined by the subtree it is under from the
+ // unigram state.
+ std::queue<std::pair<StateId, Label>> label_queue;
+ std::vector<bool> visited(num_states);
+ // Force an epsilon link to the start state.
+ label_queue.push(std::make_pair(fst.Start(), 0));
+ for (ArcIterator<Fst<A>> aiter(fst, unigram); !aiter.Done(); aiter.Next()) {
+ label_queue.push(
+ std::make_pair(aiter.Value().nextstate, aiter.Value().ilabel));
+ }
+ // investigate states in breadth first fashion to assign context words.
+ while (!label_queue.empty()) {
+ std::pair<StateId, Label> &now = label_queue.front();
+ if (!visited[now.first]) {
+ context[now.first] = now.second;
+ visited[now.first] = true;
+ for (ArcIterator<Fst<A>> aiter(fst, now.first); !aiter.Done();
+ aiter.Next()) {
+ const Arc &arc = aiter.Value();
+ if (arc.ilabel != 0) {
+ label_queue.push(std::make_pair(arc.nextstate, now.second));
+ }
+ }
+ }
+ label_queue.pop();
+ }
+ visited.clear();
+
+ // The arc from the start state should be assigned an epsilon to put it
+ // in front of the all other labels (which makes Start state 1 after
+ // unigram which is state 0).
+ context[fst.Start()] = 0;
+
+ // Build the tree of contexts fst by reversing the epsilon arcs from fst.
+ VectorFst<Arc> context_fst;
+ uint64 num_final = 0;
+ for (int i = 0; i < num_states; ++i) {
+ if (fst.Final(i) != Weight::Zero()) {
+ ++num_final;
+ }
+ context_fst.SetFinal(context_fst.AddState(), fst.Final(i));
+ }
+ context_fst.SetStart(unigram);
+ context_fst.SetInputSymbols(fst.InputSymbols());
+ context_fst.SetOutputSymbols(fst.OutputSymbols());
+ int64 num_context_arcs = 0;
+ int64 num_futures = 0;
+ for (StateIterator<Fst<A>> siter(fst); !siter.Done(); siter.Next()) {
+ const StateId &state = siter.Value();
+ num_futures += fst.NumArcs(state) - fst.NumInputEpsilons(state);
+ ArcIterator<Fst<A>> aiter(fst, state);
+ if (!aiter.Done()) {
+ const Arc &arc = aiter.Value();
+ // this arc goes from state to arc.nextstate, so create an arc from
+ // arc.nextstate to state to reverse it.
+ if (arc.ilabel == 0) {
+ context_fst.AddArc(arc.nextstate, Arc(context[state], context[state],
+ arc.weight, state));
+ num_context_arcs++;
+ }
+ }
+ }
+ if (num_context_arcs != context_fst.NumStates() - 1) {
+ FSTERROR() << "Number of contexts arcs != number of states - 1";
+ SetProperties(kError, kError);
+ return;
+ }
+ if (context_fst.NumStates() != num_states) {
+ FSTERROR() << "Number of contexts != number of states";
+ SetProperties(kError, kError);
+ return;
+ }
+ int64 context_props =
+ context_fst.Properties(kIDeterministic | kILabelSorted, true);
+ if (!(context_props & kIDeterministic)) {
+ FSTERROR() << "Input Fst is not structured properly";
+ SetProperties(kError, kError);
+ return;
+ }
+ if (!(context_props & kILabelSorted)) {
+ ArcSort(&context_fst, ILabelCompare<Arc>());
+ }
+
+ delete[] context;
+
+ uint64 b64;
+ Weight weight;
+ Label label = kNoLabel;
+ const size_t storage = Storage(num_states, num_futures, num_final);
+ MappedFile *data_region = MappedFile::Allocate(storage);
+ char *data = reinterpret_cast<char *>(data_region->mutable_data());
+ memset(data, 0, storage);
+ size_t offset = 0;
+ memcpy(data + offset, reinterpret_cast<char *>(&num_states),
+ sizeof(num_states));
+ offset += sizeof(num_states);
+ memcpy(data + offset, reinterpret_cast<char *>(&num_futures),
+ sizeof(num_futures));
+ offset += sizeof(num_futures);
+ memcpy(data + offset, reinterpret_cast<char *>(&num_final),
+ sizeof(num_final));
+ offset += sizeof(num_final);
+ uint64 *context_bits = reinterpret_cast<uint64 *>(data + offset);
+ offset += BitmapIndex::StorageSize(num_states * 2 + 1) * sizeof(b64);
+ uint64 *future_bits = reinterpret_cast<uint64 *>(data + offset);
+ offset +=
+ BitmapIndex::StorageSize(num_futures + num_states + 1) * sizeof(b64);
+ uint64 *final_bits = reinterpret_cast<uint64 *>(data + offset);
+ offset += BitmapIndex::StorageSize(num_states) * sizeof(b64);
+ Label *context_words = reinterpret_cast<Label *>(data + offset);
+ offset += (num_states + 1) * sizeof(label);
+ Label *future_words = reinterpret_cast<Label *>(data + offset);
+ offset += num_futures * sizeof(label);
+ offset = (offset + sizeof(weight) - 1) & ~(sizeof(weight) - 1);
+ Weight *backoff = reinterpret_cast<Weight *>(data + offset);
+ offset += (num_states + 1) * sizeof(weight);
+ Weight *final_probs = reinterpret_cast<Weight *>(data + offset);
+ offset += num_final * sizeof(weight);
+ Weight *future_probs = reinterpret_cast<Weight *>(data + offset);
+ int64 context_arc = 0, future_arc = 0, context_bit = 0, future_bit = 0,
+ final_bit = 0;
+
+ // pseudo-root bits
+ BitmapIndex::Set(context_bits, context_bit++);
+ ++context_bit;
+ context_words[context_arc] = label;
+ backoff[context_arc] = Weight::Zero();
+ context_arc++;
+
+ ++future_bit;
+ if (order_out) {
+ order_out->clear();
+ order_out->resize(num_states);
+ }
+
+ std::queue<StateId> context_q;
+ context_q.push(context_fst.Start());
+ StateId state_number = 0;
+ while (!context_q.empty()) {
+ const StateId &state = context_q.front();
+ if (order_out) {
+ (*order_out)[state] = state_number;
+ }
+
+ const Weight final_weight = context_fst.Final(state);
+ if (final_weight != Weight::Zero()) {
+ BitmapIndex::Set(final_bits, state_number);
+ final_probs[final_bit] = final_weight;
+ ++final_bit;
+ }
+
+ for (ArcIterator<VectorFst<A>> aiter(context_fst, state); !aiter.Done();
+ aiter.Next()) {
+ const Arc &arc = aiter.Value();
+ context_words[context_arc] = arc.ilabel;
+ backoff[context_arc] = arc.weight;
+ ++context_arc;
+ BitmapIndex::Set(context_bits, context_bit++);
+ context_q.push(arc.nextstate);
+ }
+ ++context_bit;
+
+ for (ArcIterator<Fst<A>> aiter(fst, state); !aiter.Done(); aiter.Next()) {
+ const Arc &arc = aiter.Value();
+ if (arc.ilabel != 0) {
+ future_words[future_arc] = arc.ilabel;
+ future_probs[future_arc] = arc.weight;
+ ++future_arc;
+ BitmapIndex::Set(future_bits, future_bit++);
+ }
+ }
+ ++future_bit;
+ ++state_number;
+ context_q.pop();
+ }
+
+ if ((state_number != num_states) || (context_bit != num_states * 2 + 1) ||
+ (context_arc != num_states) || (future_arc != num_futures) ||
+ (future_bit != num_futures + num_states + 1) ||
+ (final_bit != num_final)) {
+ FSTERROR() << "Structure problems detected during construction";
+ SetProperties(kError, kError);
+ return;
+ }
+
+ Init(data, false, data_region);
+}
+
+template <typename A>
+inline void NGramFstImpl<A>::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<const uint64 *>(data_ + offset));
+ offset += sizeof(num_states_);
+ num_futures_ = *(reinterpret_cast<const uint64 *>(data_ + offset));
+ offset += sizeof(num_futures_);
+ num_final_ = *(reinterpret_cast<const uint64 *>(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<const uint64 *>(data_ + offset);
+ offset += BitmapIndex::StorageSize(context_bits) * sizeof(bits);
+ future_ = reinterpret_cast<const uint64 *>(data_ + offset);
+ offset += BitmapIndex::StorageSize(future_bits) * sizeof(bits);
+ final_ = reinterpret_cast<const uint64 *>(data_ + offset);
+ offset += BitmapIndex::StorageSize(num_states_) * sizeof(bits);
+ context_words_ = reinterpret_cast<const Label *>(data_ + offset);
+ offset += (num_states_ + 1) * sizeof(*context_words_);
+ future_words_ = reinterpret_cast<const Label *>(data_ + offset);
+ offset += num_futures_ * sizeof(*future_words_);
+ offset = (offset + sizeof(*backoff_) - 1) & ~(sizeof(*backoff_) - 1);
+ backoff_ = reinterpret_cast<const Weight *>(data_ + offset);
+ offset += (num_states_ + 1) * sizeof(*backoff_);
+ final_probs_ = reinterpret_cast<const Weight *>(data_ + offset);
+ offset += num_final_ * sizeof(*final_probs_);
+ future_probs_ = reinterpret_cast<const Weight *>(data_ + offset);
+
+ context_index_.BuildIndex(context_, context_bits);
+ future_index_.BuildIndex(future_, future_bits);
+ final_index_.BuildIndex(final_, num_states_);
+
+ select_root_ = context_index_.Select0s(0);
+ if (context_index_.Rank1(0) != 0 || select_root_.first != 1 ||
+ context_index_.Get(2) == false) {
+ FSTERROR() << "Malformed file";
+ SetProperties(kError, kError);
+ return;
+ }
+ root_children_ = context_words_ + context_index_.Rank1(2);
+ start_ = 1;
+}
+
+template <typename A>
+inline typename A::StateId NGramFstImpl<A>::Transition(
+ const std::vector<Label> &context, Label future) const {
+ const Label *children = root_children_;
+ size_t num_children = select_root_.second - 2;
+ const Label *loc =
+ std::lower_bound(children, children + num_children, future);
+ if (loc == children + num_children || *loc != future) {
+ return context_index_.Rank1(0);
+ }
+ size_t node = 2 + loc - children;
+ size_t node_rank = context_index_.Rank1(node);
+ std::pair<size_t, size_t> zeros =
+ (node_rank == 0) ? select_root_ : context_index_.Select0s(node_rank);
+ size_t first_child = zeros.first + 1;
+ if (context_index_.Get(first_child) == false) {
+ return context_index_.Rank1(node);
+ }
+ size_t last_child = zeros.second - 1;
+ for (int word = context.size() - 1; word >= 0; --word) {
+ children = context_words_ + context_index_.Rank1(first_child);
+ loc = std::lower_bound(children, children + last_child - first_child + 1,
+ context[word]);
+ if (loc == children + last_child - first_child + 1 ||
+ *loc != context[word]) {
+ break;
+ }
+ node = first_child + loc - children;
+ node_rank = context_index_.Rank1(node);
+ zeros =
+ (node_rank == 0) ? select_root_ : context_index_.Select0s(node_rank);
+ first_child = zeros.first + 1;
+ if (context_index_.Get(first_child) == false) break;
+ last_child = zeros.second - 1;
+ }
+ return context_index_.Rank1(node);
+}
+
+} // namespace internal
+
+/*****************************************************************************/
+template <class A>
+class NGramFstMatcher : public MatcherBase<A> {
+ public:
+ typedef A Arc;
+ typedef typename A::Label Label;
+ typedef typename A::StateId StateId;
+ typedef typename A::Weight Weight;
+
+ NGramFstMatcher(const NGramFst<A> &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);
+ }
+ }
+
+ NGramFstMatcher(const NGramFstMatcher<A> &matcher, bool safe = false)
+ : fst_(matcher.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<A> *Copy(bool safe = false) const override {
+ return new NGramFstMatcher<A>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return match_type_; }
+
+ const Fst<A> &GetFst() const override { return fst_; }
+
+ uint64 Properties(uint64 props) const override { return props; }
+
+ private:
+ void SetState_(StateId s) override {
+ fst_.GetImpl()->SetInstFuture(s, &inst_);
+ current_loop_ = false;
+ }
+
+ bool Find_(Label label) override {
+ 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 override { return !current_loop_ && done_; }
+
+ const Arc &Value_() const override { return (current_loop_) ? loop_ : arc_; }
+
+ void Next_() override {
+ if (current_loop_) {
+ current_loop_ = false;
+ } else {
+ done_ = true;
+ }
+ }
+
+ ssize_t Priority_(StateId s) override { return fst_.NumArcs(s); }
+
+ const NGramFst<A> &fst_;
+ NGramFstInst<A> 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 A>
+class StateIterator<NGramFst<A>> final : public StateIteratorBase<A> {
+ public:
+ typedef typename A::StateId StateId;
+
+ explicit StateIterator(const NGramFst<A> &fst)
+ : s_(0), num_states_(fst.NumStates()) {}
+
+ bool Done() const override { return s_ >= num_states_; }
+
+ StateId Value() const override { return s_; }
+
+ void Next() override { ++s_; }
+
+ void Reset() override { s_ = 0; }
+
+ private:
+ StateId s_;
+ StateId num_states_;
+};
+
+/*****************************************************************************/
+template <class A>
+class ArcIterator<NGramFst<A>> final : public ArcIteratorBase<A> {
+ public:
+ typedef A Arc;
+ typedef typename A::Label Label;
+ typedef typename A::StateId StateId;
+ typedef typename A::Weight Weight;
+
+ ArcIterator(const NGramFst<A> &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 override {
+ return i_ >=
+ ((inst_.node_ == 0) ? inst_.num_futures_ : inst_.num_futures_ + 1);
+ }
+
+ const Arc &Value() const override {
+ 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() override {
+ ++i_;
+ lazy_ = ~0;
+ }
+
+ size_t Position() const override { return i_; }
+
+ void Reset() override {
+ i_ = 0;
+ lazy_ = ~0;
+ }
+
+ void Seek(size_t a) override {
+ if (i_ != a) {
+ i_ = a;
+ lazy_ = ~0;
+ }
+ }
+
+ uint32 Flags() const override { return flags_; }
+
+ void SetFlags(uint32 flags, uint32 mask) override {
+ flags_ &= ~mask;
+ flags_ |= (flags & kArcValueFlags);
+ }
+
+ private:
+ mutable Arc arc_;
+ mutable uint32 lazy_;
+ const internal::NGramFstImpl<A> *impl_; // Borrowed reference.
+ mutable NGramFstInst<A> inst_;
+
+ size_t i_;
+ uint32 flags_;
+};
+
+} // namespace fst
+#endif // FST_EXTENSIONS_NGRAM_NGRAM_FST_H_
--- /dev/null
+// 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 <fst/types.h>
+
+extern uint32 nth_bit_bit_offset[];
+
+inline uint32 nth_bit(uint64 v, uint32 r) {
+ uint32 shift = 0;
+ uint32 c = __builtin_popcount(v & 0xffffffff);
+ uint32 mask = -(r > c);
+ r -= c & mask;
+ shift += (32 & mask);
+
+ c = __builtin_popcount((v >> shift) & 0xffff);
+ mask = -(r > c);
+ r -= c & mask;
+ shift += (16 & mask);
+
+ c = __builtin_popcount((v >> shift) & 0xff);
+ mask = -(r > c);
+ r -= c & mask;
+ shift += (8 & mask);
+
+ return shift +
+ ((nth_bit_bit_offset[(v >> shift) & 0xff] >> ((r - 1) << 2)) & 0xf);
+}
+
+#endif // FST_EXTENSIONS_NGRAM_NTHBIT_H_
--- /dev/null
+// 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 <functional>
+#include <vector>
+
+#include <fst/bi-table.h>
+
+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 I, class T>
+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<I, Node, NodeHash>;
+
+ 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<T> &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<T> hash_;
+
+ NodeTable node_table_;
+};
+
+template <class I, class T>
+constexpr I Collection<I, T>::kNoNodeId;
+
+template <class I, class T>
+const std::hash<T> Collection<I, T>::hash_ = {};
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_COLLECTION_H_
--- /dev/null
+// 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 <list>
+
+#include <fst/extensions/pdt/pdt.h>
+#include <fst/compose.h>
+
+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 F>
+class ParenMatcher {
+ public:
+ using FST = F;
+ using M = SortedMatcher<FST>;
+ using Arc = typename FST::Arc;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ 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;
+ }
+
+ ParenMatcher(const ParenMatcher<FST> &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<FST> *Copy(bool safe = false) const {
+ return new ParenMatcher<FST>(*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<Label, kNoLabel> open_parens_;
+ // Close paren label set.
+ CompactSet<Label, kNoLabel> 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 <class FST>
+inline bool ParenMatcher<FST>::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 <class FST>
+inline void ParenMatcher<FST>::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 <class FST>
+inline bool ParenMatcher<FST>::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 <class FST>
+inline bool ParenMatcher<FST>::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 Filter>
+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<StackId, Label>;
+ using FilterState1 = typename Filter::FilterState;
+ using FilterState2 = IntegerFilterState<StackId>;
+ using FilterState = PairFilterState<FilterState1, FilterState2>;
+
+ ParenFilter(const FST1 &fst1, const FST2 &fst2, Matcher1 *matcher1 = nullptr,
+ Matcher2 *matcher2 = nullptr,
+ const std::vector<std::pair<Label, Label>> *parens = nullptr,
+ bool expand = false, bool keep_parens = true)
+ : filter_(fst1, fst2, matcher1, matcher2),
+ parens_(parens ? *parens : std::vector<std::pair<Label, Label>>()),
+ 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<std::pair<Label, Label>> 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 Arc, bool left_pdt = true>
+class PdtComposeFstOptions
+ : public ComposeFstOptions<
+ Arc, ParenMatcher<Fst<Arc>>,
+ ParenFilter<AltSequenceComposeFilter<ParenMatcher<Fst<Arc>>>>> {
+ public:
+ using Label = typename Arc::Label;
+ using PdtMatcher = ParenMatcher<Fst<Arc>>;
+ using PdtFilter = ParenFilter<AltSequenceComposeFilter<PdtMatcher>>;
+
+ using ComposeFstOptions<Arc, PdtMatcher, PdtFilter>::matcher1;
+ using ComposeFstOptions<Arc, PdtMatcher, PdtFilter>::matcher2;
+ using ComposeFstOptions<Arc, PdtMatcher, PdtFilter>::filter;
+
+ PdtComposeFstOptions(const Fst<Arc> &ifst1,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const Fst<Arc> &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 Arc>
+class PdtComposeFstOptions<Arc, false>
+ : public ComposeFstOptions<
+ Arc, ParenMatcher<Fst<Arc>>,
+ ParenFilter<SequenceComposeFilter<ParenMatcher<Fst<Arc>>>>> {
+ public:
+ using Label = typename Arc::Label;
+ using PdtMatcher = ParenMatcher<Fst<Arc>>;
+ using PdtFilter = ParenFilter<SequenceComposeFilter<PdtMatcher>>;
+
+ using ComposeFstOptions<Arc, PdtMatcher, PdtFilter>::matcher1;
+ using ComposeFstOptions<Arc, PdtMatcher, PdtFilter>::matcher2;
+ using ComposeFstOptions<Arc, PdtMatcher, PdtFilter>::filter;
+
+ PdtComposeFstOptions(const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ const std::vector<std::pair<Label, Label>> &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 <class Arc>
+void Compose(const Fst<Arc> &ifst1,
+ const std::vector<
+ std::pair<typename Arc::Label, typename Arc::Label>> &parens,
+ const Fst<Arc> &ifst2, MutableFst<Arc> *ofst,
+ const PdtComposeOptions &opts = PdtComposeOptions()) {
+ bool expand = opts.filter_type != PAREN_FILTER;
+ bool keep_parens = opts.filter_type != EXPAND_FILTER;
+ PdtComposeFstOptions<Arc, true> copts(ifst1, parens, ifst2, expand,
+ keep_parens);
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(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 <class Arc>
+void Compose(const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ const std::vector<
+ std::pair<typename Arc::Label, typename Arc::Label>> &parens,
+ MutableFst<Arc> *ofst,
+ const PdtComposeOptions &opts = PdtComposeOptions()) {
+ bool expand = opts.filter_type != PAREN_FILTER;
+ bool keep_parens = opts.filter_type != EXPAND_FILTER;
+ PdtComposeFstOptions<Arc, false> copts(ifst1, ifst2, parens, expand,
+ keep_parens);
+ copts.gc_limit = 0;
+ *ofst = ComposeFst<Arc>(ifst1, ifst2, copts);
+ if (opts.connect) Connect(ofst);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_COMPOSE_H_
--- /dev/null
+// 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 <forward_list>
+#include <vector>
+
+#include <fst/extensions/pdt/paren.h>
+#include <fst/extensions/pdt/pdt.h>
+#include <fst/extensions/pdt/reverse.h>
+#include <fst/extensions/pdt/shortest-path.h>
+#include <fst/cache.h>
+#include <fst/mutable-fst.h>
+#include <fst/queue.h>
+#include <fst/state-table.h>
+#include <fst/test-properties.h>
+
+namespace fst {
+
+template <class Arc>
+struct PdtExpandFstOptions : public CacheOptions {
+ bool keep_parentheses;
+ PdtStack<typename Arc::StateId, typename Arc::Label> *stack;
+ PdtStateTable<typename Arc::StateId, typename Arc::StateId> *state_table;
+
+ explicit PdtExpandFstOptions(
+ const CacheOptions &opts = CacheOptions(), bool keep_parentheses = false,
+ PdtStack<typename Arc::StateId, typename Arc::Label> *stack = nullptr,
+ PdtStateTable<typename Arc::StateId, typename Arc::StateId> *state_table =
+ nullptr)
+ : CacheOptions(opts),
+ keep_parentheses(keep_parentheses),
+ stack(stack),
+ state_table(state_table) {}
+};
+
+namespace internal {
+
+// Implementation class for PdtExpandFst.
+template <class Arc>
+class PdtExpandFstImpl : public CacheImpl<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using StackId = StateId;
+ using StateTuple = PdtStateTuple<StateId, StackId>;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::Properties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheBaseImpl<CacheState<Arc>>::PushArc;
+ using CacheBaseImpl<CacheState<Arc>>::HasArcs;
+ using CacheBaseImpl<CacheState<Arc>>::HasFinal;
+ using CacheBaseImpl<CacheState<Arc>>::HasStart;
+ using CacheBaseImpl<CacheState<Arc>>::SetArcs;
+ using CacheBaseImpl<CacheState<Arc>>::SetFinal;
+ using CacheBaseImpl<CacheState<Arc>>::SetStart;
+
+ PdtExpandFstImpl(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const PdtExpandFstOptions<Arc> &opts)
+ : CacheImpl<Arc>(opts),
+ fst_(fst.Copy()),
+ stack_(opts.stack ? opts.stack : new PdtStack<StateId, Label>(parens)),
+ state_table_(opts.state_table ? opts.state_table
+ : new PdtStateTable<StateId, StackId>()),
+ own_stack_(opts.stack == 0),
+ own_state_table_(opts.state_table == 0),
+ keep_parentheses_(opts.keep_parentheses) {
+ SetType("expand");
+ const auto props = fst.Properties(kFstProperties, false);
+ SetProperties(PdtExpandProperties(props), kCopyProperties);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ }
+
+ PdtExpandFstImpl(const PdtExpandFstImpl &impl)
+ : CacheImpl<Arc>(impl),
+ fst_(impl.fst_->Copy(true)),
+ stack_(new PdtStack<StateId, Label>(*impl.stack_)),
+ state_table_(new PdtStateTable<StateId, StackId>()),
+ 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<Arc>::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<Arc>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) ExpandState(s);
+ return CacheImpl<Arc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) ExpandState(s);
+ return CacheImpl<Arc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) ExpandState(s);
+ return CacheImpl<Arc>::NumOutputEpsilons(s);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) ExpandState(s);
+ CacheImpl<Arc>::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<Fst<Arc>> 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<StackId, Label> &GetStack() const { return *stack_; }
+
+ const PdtStateTable<StateId, StackId> &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<const Fst<Arc>> fst_;
+ PdtStack<StackId, Label> *stack_;
+ PdtStateTable<StateId, StackId> *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 A>
+class PdtExpandFst : public ImplToFst<internal::PdtExpandFstImpl<A>> {
+ 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<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::PdtExpandFstImpl<Arc>;
+
+ friend class ArcIterator<PdtExpandFst<Arc>>;
+ friend class StateIterator<PdtExpandFst<Arc>>;
+
+ PdtExpandFst(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens)
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, parens, PdtExpandFstOptions<A>())) {}
+
+ PdtExpandFst(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const PdtExpandFstOptions<Arc> &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, parens, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ PdtExpandFst(const PdtExpandFst<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Gets a copy of this ExpandFst. See Fst<>::Copy() for further doc.
+ PdtExpandFst<Arc> *Copy(bool safe = false) const override {
+ return new PdtExpandFst<Arc>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ const PdtStack<StackId, Label> &GetStack() const {
+ return GetImpl()->GetStack();
+ }
+
+ const PdtStateTable<StateId, StackId> &GetStateTable() const {
+ return GetImpl()->GetStateTable();
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ void operator=(const PdtExpandFst &) = delete;
+};
+
+// Specialization for PdtExpandFst.
+template <class Arc>
+class StateIterator<PdtExpandFst<Arc>>
+ : public CacheStateIterator<PdtExpandFst<Arc>> {
+ public:
+ explicit StateIterator(const PdtExpandFst<Arc> &fst)
+ : CacheStateIterator<PdtExpandFst<Arc>>(fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for PdtExpandFst.
+template <class Arc>
+class ArcIterator<PdtExpandFst<Arc>>
+ : public CacheArcIterator<PdtExpandFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const PdtExpandFst<Arc> &fst, StateId s)
+ : CacheArcIterator<PdtExpandFst<Arc>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->ExpandState(s);
+ }
+};
+
+template <class Arc>
+inline void PdtExpandFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<PdtExpandFst<Arc>>(*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 Arc>
+class PdtPrunedExpand {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using StackId = StateId;
+ using Stack = PdtStack<StackId, Label>;
+ using StateTable = PdtStateTable<StateId, StackId>;
+ using SetIterator = typename internal::PdtBalanceData<Arc>::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<Arc> &ifst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ bool keep_parentheses = false,
+ const CacheOptions &opts = CacheOptions())
+ : ifst_(ifst.Copy()),
+ keep_parentheses_(keep_parentheses),
+ stack_(parens),
+ efst_(ifst, parens,
+ PdtExpandFstOptions<Arc>(opts, true, &stack_, &state_table_)),
+ queue_(state_table_, stack_, stack_length_, distance_, fdistance_),
+ error_(false) {
+ Reverse(*ifst_, parens, &rfst_);
+ VectorFst<Arc> path;
+ reverse_shortest_path_.reset(new PdtShortestPath<Arc, FifoQueue<StateId>>(
+ rfst_, parens,
+ PdtShortestPathOptions<Arc, FifoQueue<StateId>>(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<Arc> *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<StackId> &stack_length,
+ const std::vector<Weight> &distance,
+ const std::vector<Weight> &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<StackId> &stack_length_;
+ const std::vector<Weight> &distance_;
+ const std::vector<Weight> &fdistance_;
+ const NaturalLess<Weight> less_;
+ };
+
+ class ShortestStackFirstQueue
+ : public ShortestFirstQueue<StateId, StackCompare> {
+ public:
+ ShortestStackFirstQueue(const PdtStateTable<StateId, StackId> &state_table,
+ const Stack &stack,
+ const std::vector<StackId> &stack_length,
+ const std::vector<Weight> &distance,
+ const std::vector<Weight> &fdistance)
+ : ShortestFirstQueue<StateId, StackCompare>(StackCompare(
+ state_table, stack, stack_length, distance, fdistance)) {}
+ };
+
+ void InitCloseParenMultimap(
+ const std::vector<std::pair<Label, Label>> &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<Fst<Arc>> ifst_;
+ // Reversed PDT.
+ VectorFst<Arc> rfst_;
+ // Keep parentheses in ofst?
+ const bool keep_parentheses_;
+ // State table for efst_.
+ StateTable state_table_;
+ // Stack trie.
+ Stack stack_;
+ // Expanded PDT.
+ PdtExpandFst<Arc> efst_;
+ // Length of stack for given stack ID.
+ std::vector<StackId> stack_length_;
+ // Distance from initial state in efst_/ofst.
+ std::vector<Weight> distance_;
+ // Distance to final states in efst_/ofst.
+ std::vector<Weight> fdistance_;
+ // Queue used to visit efst_.
+ ShortestStackFirstQueue queue_;
+ // Construction time failure?
+ bool error_;
+ // Status flags for states in efst_/ofst.
+ std::vector<uint8> flags_;
+ // PDT source state for each expanded state.
+ std::vector<StateId> sources_;
+ // Shortest path for rfst_.
+ std::unique_ptr<PdtShortestPath<Arc, FifoQueue<StateId>>>
+ reverse_shortest_path_;
+ std::unique_ptr<internal::PdtBalanceData<Arc>> balance_data_;
+ // Maps open paren arcs to balancing close paren arcs.
+ typename PdtShortestPath<Arc, FifoQueue<StateId>>::CloseParenMultimap
+ close_paren_multimap_;
+ MutableFst<Arc> *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<StateId, Weight> 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<std::pair<StateId, Weight>> cached_dest_list_;
+ NaturalLess<Weight> 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 <class Arc>
+void PdtPrunedExpand<Arc>::InitCloseParenMultimap(
+ const std::vector<std::pair<Label, Label>> &parens) {
+ std::unordered_map<Label, Label> 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<Fst<Arc>> siter(*ifst_); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ for (ArcIterator<Fst<Arc>> 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<Arc> 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 <class Arc>
+typename Arc::Weight PdtPrunedExpand<Arc>::DistanceToDest(StateId source,
+ StateId dest) const {
+ using SearchState =
+ typename PdtShortestPath<Arc, FifoQueue<StateId>>::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 <class Arc>
+uint8 PdtPrunedExpand<Arc>::Flags(StateId s) const {
+ return s < flags_.size() ? flags_[s] : 0;
+}
+
+// Modifies the flags for state s in ofst_.
+template <class Arc>
+void PdtPrunedExpand<Arc>::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 <class Arc>
+typename Arc::Weight PdtPrunedExpand<Arc>::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 <class Arc>
+void PdtPrunedExpand<Arc>::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 <class Arc>
+typename Arc::Weight PdtPrunedExpand<Arc>::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 <class Arc>
+void PdtPrunedExpand<Arc>::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 <class Arc>
+typename Arc::StateId PdtPrunedExpand<Arc>::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 <class Arc>
+void PdtPrunedExpand<Arc>::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 <class Arc>
+void PdtPrunedExpand<Arc>::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 <class Arc>
+void PdtPrunedExpand<Arc>::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 <class Arc>
+bool PdtPrunedExpand<Arc>::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 <class Arc>
+void PdtPrunedExpand<Arc>::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<StateId, StackId> 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 <class Arc>
+void PdtPrunedExpand<Arc>::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 <class Arc>
+bool PdtPrunedExpand<Arc>::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 <class Arc>
+bool PdtPrunedExpand<Arc>::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<StateId> 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<Arc> 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<StateId, StackId> 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 <class Arc>
+bool PdtPrunedExpand<Arc>::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 <class Arc>
+void PdtPrunedExpand<Arc>::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<Arc> 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<StateId, StackId> 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 <class Arc>
+void PdtPrunedExpand<Arc>::Expand(MutableFst<Arc> *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<PdtExpandFst<Arc>> 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 <class Arc>
+struct PdtExpandOptions {
+ using Weight = typename Arc::Weight;
+
+ bool connect;
+ bool keep_parentheses;
+ Weight weight_threshold;
+
+ PdtExpandOptions(bool connect = true, bool keep_parentheses = false,
+ Weight weight_threshold = Weight::Zero())
+ : connect(connect),
+ keep_parentheses(keep_parentheses),
+ weight_threshold(std::move(weight_threshold)) {}
+};
+
+// Expands a pushdown transducer (PDT) encoded as an FST into an FST. This
+// version writes the expanded PDT to a mutable FST. In the PDT, some
+// transitions are labeled with open or close parentheses. To be interpreted as
+// a PDT, the parens must balance on a path. The open-close parenthesis label
+// pairs are passed using the parens argument. Expansion enforces the
+// parenthesis constraints. The PDT must be expandable as an FST.
+template <class Arc>
+void Expand(
+ const Fst<Arc> &ifst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens,
+ MutableFst<Arc> *ofst, const PdtExpandOptions<Arc> &opts) {
+ PdtExpandFstOptions<Arc> eopts;
+ eopts.gc_limit = 0;
+ if (opts.weight_threshold == Arc::Weight::Zero()) {
+ eopts.keep_parentheses = opts.keep_parentheses;
+ *ofst = PdtExpandFst<Arc>(ifst, parens, eopts);
+ } else {
+ PdtPrunedExpand<Arc> 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 <class Arc>
+void Expand(const Fst<Arc> &ifst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens, MutableFst<Arc> *ofst, bool connect = true,
+ bool keep_parentheses = false) {
+ const PdtExpandOptions<Arc> opts(connect, keep_parentheses);
+ Expand(ifst, parens, ofst, opts);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_EXPAND_H_
--- /dev/null
+// 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 <string>
+
+#include <fst/extensions/pdt/compose.h>
+#include <fst/extensions/pdt/replace.h>
+
+namespace fst {
+namespace script {
+
+bool GetPdtComposeFilter(const string &str, PdtComposeFilter *cf);
+
+bool GetPdtParserType(const string &str, PdtParserType *pt);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_GETTERS_H_
--- /dev/null
+// 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 <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <fst/extensions/pdt/pdt.h>
+#include <fst/fst.h>
+
+namespace fst {
+
+// Compute various information about PDTs.
+template <class Arc>
+class PdtInfo {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ PdtInfo(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parents);
+
+ const string &FstType() const { return fst_type_; }
+
+ const string &ArcType() const { return Arc::Type(); }
+
+ int64 NumStates() const { return nstates_; }
+
+ int64 NumArcs() const { return narcs_; }
+
+ int64 NumOpenParens() const { return nopen_parens_; }
+
+ int64 NumCloseParens() const { return nclose_parens_; }
+
+ int64 NumUniqueOpenParens() const { return nuniq_open_parens_; }
+
+ int64 NumUniqueCloseParens() const { return nuniq_close_parens_; }
+
+ int64 NumOpenParenStates() const { return nopen_paren_states_; }
+
+ int64 NumCloseParenStates() const { return nclose_paren_states_; }
+
+ private:
+ string fst_type_;
+ int64 nstates_;
+ int64 narcs_;
+ int64 nopen_parens_;
+ int64 nclose_parens_;
+ int64 nuniq_open_parens_;
+ int64 nuniq_close_parens_;
+ int64 nopen_paren_states_;
+ int64 nclose_paren_states_;
+};
+
+template <class Arc>
+PdtInfo<Arc>::PdtInfo(
+ const Fst<Arc> &fst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &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<Label, size_t> paren_map;
+ std::unordered_set<Label> paren_set;
+ std::unordered_set<StateId> open_paren_state_set;
+ std::unordered_set<StateId> close_paren_state_set;
+ 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<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ ++nstates_;
+ const auto s = siter.Value();
+ for (ArcIterator<Fst<Arc>> aiter(fst, s); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ ++narcs_;
+ const auto it = paren_map.find(arc.ilabel);
+ if (it != paren_map.end()) {
+ const auto open_paren = parens[it->second].first;
+ const auto close_paren = parens[it->second].second;
+ if (arc.ilabel == open_paren) {
+ ++nopen_parens_;
+ if (!paren_set.count(open_paren)) {
+ ++nuniq_open_parens_;
+ paren_set.insert(open_paren);
+ }
+ if (!open_paren_state_set.count(arc.nextstate)) {
+ ++nopen_paren_states_;
+ open_paren_state_set.insert(arc.nextstate);
+ }
+ } else {
+ ++nclose_parens_;
+ if (!paren_set.count(close_paren)) {
+ ++nuniq_close_parens_;
+ paren_set.insert(close_paren);
+ }
+ if (!close_paren_state_set.count(s)) {
+ ++nclose_paren_states_;
+ close_paren_state_set.insert(s);
+ }
+ }
+ }
+ }
+ }
+}
+
+template <class Arc>
+void PrintPdtInfo(const PdtInfo<Arc> &info) {
+ const auto old = std::cout.setf(std::ios::left);
+ std::cout.width(50);
+ std::cout << "fst type" << info.FstType().c_str() << std::endl;
+ std::cout.width(50);
+ std::cout << "arc type" << info.ArcType().c_str() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of states" << info.NumStates() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of arcs" << info.NumArcs() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of open parentheses" << info.NumOpenParens() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of close parentheses" << info.NumCloseParens() << std::endl;
+ std::cout.width(50);
+ std::cout << "# of unique open parentheses" << info.NumUniqueOpenParens()
+ << std::endl;
+ std::cout.width(50);
+ std::cout << "# of unique close parentheses" << info.NumUniqueCloseParens()
+ << std::endl;
+ std::cout.width(50);
+ std::cout << "# of open parenthesis dest. states" << info.NumOpenParenStates()
+ << std::endl;
+ std::cout.width(50);
+ std::cout << "# of close parenthesis source states"
+ << info.NumCloseParenStates() << std::endl;
+ std::cout.setf(old);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_INFO_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Common classes for PDT parentheses.
+
+#ifndef FST_EXTENSIONS_PDT_PAREN_H_
+#define FST_EXTENSIONS_PDT_PAREN_H_
+
+#include <algorithm>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+
+#include <fst/extensions/pdt/collection.h>
+#include <fst/extensions/pdt/pdt.h>
+#include <fst/dfs-visit.h>
+#include <fst/fst.h>
+
+
+namespace fst {
+namespace internal {
+
+// ParenState: Pair of an open (close) parenthesis and its destination (source)
+// state.
+
+template <class Arc>
+struct ParenState {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+
+ Label paren_id; // ID of open (close) paren.
+ StateId state_id; // Destination (source) state of open (close) paren.
+
+ explicit ParenState(Label paren_id = kNoLabel, StateId state_id = kNoStateId)
+ : paren_id(paren_id), state_id(state_id) {}
+
+ bool operator==(const ParenState<Arc> &other) const {
+ if (&other == this) return true;
+ return other.paren_id == paren_id && other.state_id == state_id;
+ }
+
+ bool operator!=(const ParenState<Arc> &other) const {
+ return !(other == *this);
+ }
+
+ struct Hash {
+ size_t operator()(const ParenState<Arc> &pstate) const {
+ static constexpr auto prime = 7853;
+ return pstate.paren_id + pstate.state_id * prime;
+ }
+ };
+};
+
+// Creates an FST-style const iterator from an STL-style map.
+template <class Map>
+class MapIterator {
+ public:
+ using StlIterator = typename Map::const_iterator;
+ using ValueType = typename Map::mapped_type;
+
+ MapIterator(const Map &map, StlIterator it)
+ : begin_(it), end_(map.end()), it_(it) {}
+
+ bool Done() const { return it_ == end_ || it_->first != begin_->first; }
+
+ ValueType Value() const { return it_->second; }
+
+ void Next() { ++it_; }
+
+ void Reset() { it_ = begin_; }
+
+ private:
+ const StlIterator begin_;
+ const StlIterator end_;
+ StlIterator it_;
+};
+
+// PdtParenReachable: Provides various parenthesis reachability information.
+
+template <class Arc>
+class PdtParenReachable {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+
+ using State = ParenState<Arc>;
+ using StateHash = typename State::Hash;
+
+ // Maps from state ID to reachable paren IDs from (to) that state.
+ using ParenMultimap = std::unordered_multimap<StateId, Label>;
+
+ // Maps from paren ID and state ID to reachable state set ID.
+ using StateSetMap = std::unordered_map<State, ssize_t, StateHash>;
+
+ // Maps from paren ID and state ID to arcs exiting that state with that
+ // Label.
+ using ParenArcMultimap = std::unordered_map<State, Arc, StateHash>;
+
+ using ParenIterator = MapIterator<ParenMultimap>;
+
+ using ParenArcIterator = MapIterator<ParenArcMultimap>;
+
+ using SetIterator = typename Collection<ssize_t, StateId>::SetIterator;
+
+ // Computes close (open) parenthesis reachability information for a PDT with
+ // bounded stack.
+ PdtParenReachable(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ bool close)
+ : fst_(fst), parens_(parens), close_(close), error_(false) {
+ paren_map_.reserve(2 * parens.size());
+ for (size_t i = 0; i < parens.size(); ++i) {
+ const auto &pair = parens[i];
+ paren_map_[pair.first] = i;
+ paren_map_[pair.second] = i;
+ }
+ if (close_) {
+ const auto start = fst.Start();
+ if (start == kNoStateId) return;
+ if (!DFSearch(start)) {
+ FSTERROR() << "PdtReachable: Underlying cyclicity not supported";
+ error_ = true;
+ }
+ } else {
+ FSTERROR() << "PdtParenReachable: Open paren info not implemented";
+ error_ = true;
+ }
+ }
+
+ bool Error() const { return error_; }
+
+ // Given a state ID, returns an iterator over paren IDs for close (open)
+ // parens reachable from that state along balanced paths.
+ ParenIterator FindParens(StateId s) const {
+ return ParenIterator(paren_multimap_, paren_multimap_.find(s));
+ }
+
+ // Given a paren ID and a state ID s, returns an iterator over states that can
+ // be reached along balanced paths from (to) s that have have close (open)
+ // parentheses matching the paren ID exiting (entering) those states.
+ SetIterator FindStates(Label paren_id, StateId s) const {
+ const State paren_state(paren_id, s);
+ const auto it = set_map_.find(paren_state);
+ if (it == set_map_.end()) {
+ return state_sets_.FindSet(-1);
+ } else {
+ return state_sets_.FindSet(it->second);
+ }
+ }
+
+ // Given a paren ID and a state ID s, return an iterator over arcs that exit
+ // (enter) s and are labeled with a close (open) parenthesis matching the
+ // paren ID.
+ ParenArcIterator FindParenArcs(Label paren_id, StateId s) const {
+ const State paren_state(paren_id, s);
+ return ParenArcIterator(paren_arc_multimap_,
+ paren_arc_multimap_.find(paren_state));
+ }
+
+ private:
+ // Returns false when cycle detected during DFS gathering paren and state set
+ // information.
+ bool DFSearch(StateId s);
+
+ // Unions state sets together gathered by the DFS.
+ void ComputeStateSet(StateId s);
+
+ // Gathers state set(s) from state.
+ void UpdateStateSet(StateId nextstate, std::set<Label> *paren_set,
+ std::vector<std::set<StateId>> *state_sets) const;
+
+ const Fst<Arc> &fst_;
+ // Paren IDs to labels.
+ const std::vector<std::pair<Label, Label>> &parens_;
+ // Close/open paren info?
+ const bool close_;
+ // Labels to paren IDs.
+ std::unordered_map<Label, Label> paren_map_;
+ // Paren reachability.
+ ParenMultimap paren_multimap_;
+ // Paren arcs.
+ ParenArcMultimap paren_arc_multimap_;
+ // DFS states.
+ std::vector<uint8> state_color_;
+ // Reachable states to IDs.
+ mutable Collection<ssize_t, StateId> state_sets_;
+ // IDs to reachable states.
+ StateSetMap set_map_;
+ bool error_;
+
+ PdtParenReachable(const PdtParenReachable &) = delete;
+ PdtParenReachable &operator=(const PdtParenReachable &) = delete;
+};
+
+// Gathers paren and state set information.
+template <class Arc>
+bool PdtParenReachable<Arc>::DFSearch(StateId s) {
+ static constexpr uint8 kWhiteState = 0x01; // Undiscovered.
+ static constexpr uint8 kGreyState = 0x02; // Discovered & unfinished.
+ static constexpr uint8 kBlackState = 0x04; // Finished.
+ if (s >= state_color_.size()) state_color_.resize(s + 1, kWhiteState);
+ if (state_color_[s] == kBlackState) return true;
+ if (state_color_[s] == kGreyState) return false;
+ state_color_[s] = kGreyState;
+ for (ArcIterator<Fst<Arc>> aiter(fst_, s); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto it = paren_map_.find(arc.ilabel);
+ if (it != paren_map_.end()) { // Paren?
+ const auto paren_id = it->second;
+ if (arc.ilabel == parens_[paren_id].first) { // Open paren?
+ if (!DFSearch(arc.nextstate)) return false;
+ for (auto set_iter = FindStates(paren_id, arc.nextstate);
+ !set_iter.Done(); set_iter.Next()) {
+ for (auto paren_arc_iter =
+ FindParenArcs(paren_id, set_iter.Element());
+ !paren_arc_iter.Done(); paren_arc_iter.Next()) {
+ const auto &cparc = paren_arc_iter.Value();
+ if (!DFSearch(cparc.nextstate)) return false;
+ }
+ }
+ }
+ } else if (!DFSearch(arc.nextstate)) { // Non-paren.
+ return false;
+ }
+ }
+ ComputeStateSet(s);
+ state_color_[s] = kBlackState;
+ return true;
+}
+
+// Unions state sets.
+template <class Arc>
+void PdtParenReachable<Arc>::ComputeStateSet(StateId s) {
+ std::set<Label> paren_set;
+ std::vector<std::set<StateId>> state_sets(parens_.size());
+ for (ArcIterator<Fst<Arc>> aiter(fst_, s); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto it = paren_map_.find(arc.ilabel);
+ if (it != paren_map_.end()) { // Paren?
+ const auto paren_id = it->second;
+ if (arc.ilabel == parens_[paren_id].first) { // Open paren?
+ for (auto set_iter = FindStates(paren_id, arc.nextstate);
+ !set_iter.Done(); set_iter.Next()) {
+ for (auto paren_arc_iter =
+ FindParenArcs(paren_id, set_iter.Element());
+ !paren_arc_iter.Done(); paren_arc_iter.Next()) {
+ const auto &cparc = paren_arc_iter.Value();
+ UpdateStateSet(cparc.nextstate, &paren_set, &state_sets);
+ }
+ }
+ } else { // Close paren.
+ paren_set.insert(paren_id);
+ state_sets[paren_id].insert(s);
+ const State paren_state(paren_id, s);
+ paren_arc_multimap_.insert(std::make_pair(paren_state, arc));
+ }
+ } else { // Non-paren.
+ UpdateStateSet(arc.nextstate, &paren_set, &state_sets);
+ }
+ }
+ std::vector<StateId> state_set;
+ for (auto paren_iter = paren_set.begin(); paren_iter != paren_set.end();
+ ++paren_iter) {
+ state_set.clear();
+ const auto paren_id = *paren_iter;
+ paren_multimap_.insert(std::make_pair(s, paren_id));
+ for (auto state_iter = state_sets[paren_id].begin();
+ state_iter != state_sets[paren_id].end(); ++state_iter) {
+ state_set.push_back(*state_iter);
+ }
+ const State paren_state(paren_id, s);
+ set_map_[paren_state] = state_sets_.FindId(state_set);
+ }
+}
+
+// Gathers state sets.
+template <class Arc>
+void PdtParenReachable<Arc>::UpdateStateSet(
+ StateId nextstate, std::set<Label> *paren_set,
+ std::vector<std::set<StateId>> *state_sets) const {
+ for (auto paren_iter = FindParens(nextstate); !paren_iter.Done();
+ paren_iter.Next()) {
+ const auto paren_id = paren_iter.Value();
+ paren_set->insert(paren_id);
+ for (auto set_iter = FindStates(paren_id, nextstate); !set_iter.Done();
+ set_iter.Next()) {
+ (*state_sets)[paren_id].insert(set_iter.Element());
+ }
+ }
+}
+
+// Stores balancing parenthesis data for a PDT. Unlike PdtParenReachable above
+// this allows on-the-fly construction (e.g., in PdtShortestPath).
+template <class Arc>
+class PdtBalanceData {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+
+ using State = ParenState<Arc>;
+ using StateHash = typename State::Hash;
+
+ // Set for open parens.
+ using OpenParenSet = std::unordered_set<State, StateHash>;
+
+ // Maps from open paren destination state to parenthesis ID.
+ using OpenParenMap = std::unordered_multimap<StateId, Label>;
+
+ // Maps from open paren state to source states of matching close parens
+ using CloseParenMap = std::unordered_multimap<State, StateId, StateHash>;
+
+ // Maps from open paren state to close source set ID.
+ using CloseSourceMap = std::unordered_map<State, ssize_t, StateHash>;
+
+ using SetIterator = typename Collection<ssize_t, StateId>::SetIterator;
+
+ PdtBalanceData() {}
+
+ void Clear() {
+ open_paren_map_.clear();
+ close_paren_map_.clear();
+ }
+
+ // Adds an open parenthesis with destination state open_dest.
+ void OpenInsert(Label paren_id, StateId open_dest) {
+ const State key(paren_id, open_dest);
+ if (!open_paren_set_.count(key)) {
+ open_paren_set_.insert(key);
+ open_paren_map_.emplace(open_dest, paren_id);
+ }
+ }
+
+ // Adds a matching closing parenthesis with source state close_source
+ // balancing an open_parenthesis with destination state open_dest if
+ // OpenInsert() previously called.
+ void CloseInsert(Label paren_id, StateId open_dest, StateId close_source) {
+ const State key(paren_id, open_dest);
+ if (open_paren_set_.count(key)) {
+ close_paren_map_.emplace(key, close_source);
+ }
+ }
+
+ // Finds close paren source states matching an open parenthesis. The following
+ // methods are then used to iterate through those matching states. Should be
+ // called only after FinishInsert(open_dest).
+ SetIterator Find(Label paren_id, StateId open_dest) {
+ const State key(paren_id, open_dest);
+ const auto it = close_source_map_.find(key);
+ if (it == close_source_map_.end()) {
+ return close_source_sets_.FindSet(-1);
+ } else {
+ return close_source_sets_.FindSet(it->second);
+ }
+ }
+
+ // Called when all open and close parenthesis insertions (w.r.t. open
+ // parentheses entering state open_dest) are finished. Must be called before
+ // Find(open_dest).
+ void FinishInsert(StateId open_dest) {
+ std::vector<StateId> close_sources;
+ for (auto oit = open_paren_map_.find(open_dest);
+ oit != open_paren_map_.end() && oit->first == open_dest;) {
+ const auto paren_id = oit->second;
+ close_sources.clear();
+ const State key(paren_id, open_dest);
+ open_paren_set_.erase(open_paren_set_.find(key));
+ for (auto cit = close_paren_map_.find(key);
+ cit != close_paren_map_.end() && cit->first == key;) {
+ close_sources.push_back(cit->second);
+ close_paren_map_.erase(cit++);
+ }
+ std::sort(close_sources.begin(), close_sources.end());
+ auto unique_end = std::unique(close_sources.begin(), close_sources.end());
+ close_sources.resize(unique_end - close_sources.begin());
+ if (!close_sources.empty()) {
+ close_source_map_[key] = close_source_sets_.FindId(close_sources);
+ }
+ open_paren_map_.erase(oit++);
+ }
+ }
+
+ // Returns a new balance data object representing the reversed balance
+ // information.
+ PdtBalanceData<Arc> *Reverse(StateId num_states, StateId num_split,
+ StateId state_id_shift) const;
+
+ private:
+ // Open paren at destintation state?
+ OpenParenSet open_paren_set_;
+ // Open parens per state.
+ OpenParenMap open_paren_map_;
+ // Current open destination state.
+ State open_dest_;
+ // Current open paren/state.
+ typename OpenParenMap::const_iterator open_iter_;
+ // Close states to (open paren, state).
+ CloseParenMap close_paren_map_;
+ // (Paren, state) to set ID.
+ CloseSourceMap close_source_map_;
+ mutable Collection<ssize_t, StateId> close_source_sets_;
+};
+
+// Return a new balance data object representing the reversed balance
+// information.
+template <class Arc>
+PdtBalanceData<Arc> *PdtBalanceData<Arc>::Reverse(
+ StateId num_states, StateId num_split, StateId state_id_shift) const {
+ auto *bd = new PdtBalanceData<Arc>;
+ std::unordered_set<StateId> close_sources;
+ const auto split_size = num_states / num_split;
+ for (StateId i = 0; i < num_states; i += split_size) {
+ close_sources.clear();
+ for (auto it = close_source_map_.begin(); it != close_source_map_.end();
+ ++it) {
+ const auto &okey = it->first;
+ const auto open_dest = okey.state_id;
+ const auto paren_id = okey.paren_id;
+ for (auto set_iter = close_source_sets_.FindSet(it->second);
+ !set_iter.Done(); set_iter.Next()) {
+ const auto close_source = set_iter.Element();
+ if ((close_source < i) || (close_source >= i + split_size)) continue;
+ close_sources.insert(close_source + state_id_shift);
+ bd->OpenInsert(paren_id, close_source + state_id_shift);
+ bd->CloseInsert(paren_id, close_source + state_id_shift,
+ open_dest + state_id_shift);
+ }
+ }
+ for (auto it = close_sources.begin(); it != close_sources.end(); ++it) {
+ bd->FinishInsert(*it);
+ }
+ }
+ return bd;
+}
+
+} // namespace internal
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_PAREN_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Common classes for PDT expansion/traversal.
+
+#ifndef FST_EXTENSIONS_PDT_PDT_H_
+#define FST_EXTENSIONS_PDT_PDT_H_
+
+#include <map>
+#include <set>
+#include <unordered_map>
+
+#include <fst/compat.h>
+#include <fst/fst.h>
+#include <fst/state-table.h>
+
+namespace fst {
+
+// Provides bijection between parenthesis stacks and signed integral stack IDs.
+// Each stack ID is unique to each distinct stack. The open-close parenthesis
+// label pairs are passed using the parens argument.
+template <typename StackId, typename Label>
+class PdtStack {
+ public:
+ // The stacks are stored in a tree. The nodes are stored in a vector. Each
+ // node represents the top of some stack and is identified by its position in
+ // the vector. Its' parent node represents the stack with the top popped and
+ // its children are stored in child_map_ and accessed by stack_id and label.
+ // The paren_id is
+ // the position in parens of the parenthesis for that node.
+ struct StackNode {
+ StackId parent_id;
+ size_t paren_id;
+
+ StackNode(StackId p, size_t i) : parent_id(p), paren_id(i) {}
+ };
+
+ explicit PdtStack(const std::vector<std::pair<Label, Label>> &parens)
+ : parens_(parens), min_paren_(kNoLabel), max_paren_(kNoLabel) {
+ for (size_t i = 0; i < parens.size(); ++i) {
+ const auto &pair = parens[i];
+ paren_map_[pair.first] = i;
+ paren_map_[pair.second] = i;
+ if (min_paren_ == kNoLabel || pair.first < min_paren_) {
+ min_paren_ = pair.first;
+ }
+ if (pair.second < min_paren_) min_paren_ = pair.second;
+ if (max_paren_ == kNoLabel || pair.first > max_paren_) {
+ max_paren_ = pair.first;
+ }
+ if (pair.second > max_paren_) max_paren_ = pair.second;
+ }
+ nodes_.push_back(StackNode(-1, -1)); // Tree root.
+ }
+
+ // Returns stack ID given the current stack ID (0 if empty) and label read.
+ // Pushes onto the stack if the label is an open parenthesis, returning the
+ // new stack ID. Pops the stack if the label is a close parenthesis that
+ // matches the top of the stack, returning the parent stack ID. Returns -1 if
+ // label is an unmatched close parenthesis. Otherwise, returns the current
+ // stack ID.
+ StackId Find(StackId stack_id, Label label) {
+ if (min_paren_ == kNoLabel || label < min_paren_ || label > max_paren_) {
+ return stack_id; // Non-paren.
+ }
+ const auto it = paren_map_.find(label);
+ // Non-paren.
+ if (it == paren_map_.end()) return stack_id;
+ const auto paren_id = it->second;
+ // Open paren.
+ if (label == parens_[paren_id].first) {
+ auto &child_id = child_map_[std::make_pair(stack_id, label)];
+ if (child_id == 0) { // Child not found; pushes label.
+ child_id = nodes_.size();
+ nodes_.push_back(StackNode(stack_id, paren_id));
+ }
+ return child_id;
+ }
+ const auto &node = nodes_[stack_id];
+ // Matching close paren.
+ if (paren_id == node.paren_id) return node.parent_id;
+ // Non-matching close paren.
+ return -1;
+ }
+
+ // Returns the stack ID obtained by popping the label at the top of the
+ // current stack ID.
+ StackId Pop(StackId stack_id) const { return nodes_[stack_id].parent_id; }
+
+ // Returns the paren ID at the top of the stack.
+ ssize_t Top(StackId stack_id) const { return nodes_[stack_id].paren_id; }
+
+ ssize_t ParenId(Label label) const {
+ const auto it = paren_map_.find(label);
+ if (it == paren_map_.end()) return -1; // Non-paren.
+ return it->second;
+ }
+
+ private:
+ struct ChildHash {
+ size_t operator()(const std::pair<StackId, Label> &pair) const {
+ static constexpr auto prime = 7853;
+ return pair.first + pair.second * prime;
+ }
+ };
+
+ std::vector<std::pair<Label, Label>> parens_;
+ std::vector<StackNode> nodes_;
+ std::unordered_map<Label, size_t> paren_map_;
+ // Child of stack node w.r.t label
+ std::unordered_map<std::pair<StackId, Label>, StackId, ChildHash> child_map_;
+ Label min_paren_;
+ Label max_paren_;
+};
+
+// State tuple for PDT expansion.
+template <typename S, typename K>
+struct PdtStateTuple {
+ using StateId = S;
+ using StackId = K;
+
+ StateId state_id;
+ StackId stack_id;
+
+ PdtStateTuple(StateId state_id = kNoStateId, StackId stack_id = -1)
+ : state_id(state_id), stack_id(stack_id) {}
+};
+
+// Equality of PDT state tuples.
+template <typename S, typename K>
+inline bool operator==(const PdtStateTuple<S, K> &x,
+ const PdtStateTuple<S, K> &y) {
+ if (&x == &y) return true;
+ return x.state_id == y.state_id && x.stack_id == y.stack_id;
+}
+
+// Hash function object for PDT state tuples
+template <class T>
+class PdtStateHash {
+ public:
+ size_t operator()(const T &tuple) const {
+ static constexpr auto prime = 7853;
+ return tuple.state_id + tuple.stack_id * prime;
+ }
+};
+
+// Tuple to PDT state bijection.
+template <class StateId, class StackId>
+class PdtStateTable : public CompactHashStateTable<
+ PdtStateTuple<StateId, StackId>,
+ PdtStateHash<PdtStateTuple<StateId, StackId>>> {
+ public:
+ PdtStateTable() {}
+
+ PdtStateTable(const PdtStateTable &other) {}
+
+ private:
+ PdtStateTable &operator=(const PdtStateTable &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_PDT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// This is an experimental push-down transducer (PDT) library. A PDT is
+// encoded as an FST, where some transitions are labeled with open or close
+// parentheses. To be interpreted as a PDT, the parentheses must balance on a
+// path.
+
+#ifndef FST_EXTENSIONS_PDT_PDTLIB_H_
+#define FST_EXTENSIONS_PDT_PDTLIB_H_
+
+#include <fst/extensions/pdt/compose.h>
+#include <fst/extensions/pdt/expand.h>
+#include <fst/extensions/pdt/pdt.h>
+#include <fst/extensions/pdt/replace.h>
+#include <fst/extensions/pdt/reverse.h>
+#include <fst/extensions/pdt/shortest-path.h>
+
+#endif // FST_EXTENSIONS_PDT_PDTLIB_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Convenience file for including all PDT operations at once, and/or
+// registering them for new arc types.
+
+#ifndef FST_EXTENSIONS_PDT_PDTSCRIPT_H_
+#define FST_EXTENSIONS_PDT_PDTSCRIPT_H_
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include <fst/compose.h> // for ComposeOptions
+#include <fst/util.h>
+
+#include <fst/script/arg-packs.h>
+#include <fst/script/fstscript.h>
+#include <fst/script/shortest-path.h>
+
+#include <fst/extensions/pdt/compose.h>
+#include <fst/extensions/pdt/expand.h>
+#include <fst/extensions/pdt/info.h>
+#include <fst/extensions/pdt/replace.h>
+#include <fst/extensions/pdt/reverse.h>
+#include <fst/extensions/pdt/shortest-path.h>
+
+namespace fst {
+namespace script {
+
+using PdtComposeArgs =
+ args::Package<const FstClass &, const FstClass &,
+ const std::vector<LabelPair> &, MutableFstClass *,
+ const PdtComposeOptions &, bool>;
+
+template <class Arc>
+void PdtCompose(PdtComposeArgs *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg4->GetMutableFst<Arc>();
+ // In case Arc::Label is not the same as FstClass::Label, we make a
+ // copy. Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ typed_parens(args->arg3.size());
+ std::copy(args->arg3.begin(), args->arg3.end(), typed_parens.begin());
+ if (args->arg6) {
+ Compose(ifst1, typed_parens, ifst2, ofst, args->arg5);
+ } else {
+ Compose(ifst1, ifst2, typed_parens, ofst, args->arg5);
+ }
+}
+
+void PdtCompose(const FstClass &ifst1, const FstClass &ifst2,
+ const std::vector<LabelPair> &parens,
+ MutableFstClass *ofst, const PdtComposeOptions &opts,
+ bool left_pdt);
+
+struct PdtExpandOptions {
+ bool connect;
+ bool keep_parentheses;
+ const WeightClass &weight_threshold;
+
+ PdtExpandOptions(bool c, bool k, const WeightClass &w)
+ : connect(c), keep_parentheses(k), weight_threshold(w) {}
+};
+
+using PdtExpandArgs =
+ args::Package<const FstClass &, const std::vector<LabelPair> &,
+ MutableFstClass *, const PdtExpandOptions &>;
+
+template <class Arc>
+void PdtExpand(PdtExpandArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ // In case Arc::Label is not the same as FstClass::Label, we make a
+ // copy. Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label,
+ typename Arc::Label>> typed_parens(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_parens.begin());
+ Expand(fst, typed_parens, ofst,
+ fst::PdtExpandOptions<Arc>(args->arg4.connect,
+ args->arg4.keep_parentheses,
+ *(args->arg4.weight_threshold.GetWeight<typename Arc::Weight>())));
+}
+
+void PdtExpand(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ MutableFstClass *ofst, const PdtExpandOptions &opts);
+
+void PdtExpand(const FstClass &ifst, const std::vector<LabelPair> &parens,
+ MutableFstClass *ofst, bool connect, bool keep_parentheses,
+ const WeightClass &weight_threshold);
+
+using PdtReplaceArgs =
+ args::Package<const std::vector<LabelFstClassPair> &, MutableFstClass *,
+ std::vector<LabelPair> *, int64, PdtParserType, int64,
+ const string &, const string &>;
+
+template <class Arc>
+void PdtReplace(PdtReplaceArgs *args) {
+ const auto &untyped_pairs = args->arg1;
+ auto size = untyped_pairs.size();
+ std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>> typed_pairs(
+ size);
+ for (size_t i = 0; i < size; ++i) {
+ typed_pairs[i].first = untyped_pairs[i].first;
+ typed_pairs[i].second = untyped_pairs[i].second->GetFst<Arc>();
+ }
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>> typed_parens;
+ const PdtReplaceOptions<Arc> opts(args->arg4, args->arg5, args->arg6,
+ args->arg7, args->arg8);
+ Replace(typed_pairs, ofst, &typed_parens, opts);
+ // Copies typed parens into arg3.
+ args->arg3->resize(typed_parens.size());
+ std::copy(typed_parens.begin(), typed_parens.end(), args->arg3->begin());
+}
+
+void PdtReplace(const std::vector<LabelFstClassPair> &pairs,
+ MutableFstClass *ofst, std::vector<LabelPair> *parens,
+ int64 root, PdtParserType parser_type = PDT_LEFT_PARSER,
+ int64 start_paren_labels = kNoLabel,
+ const string &left_paren_prefix = "(_",
+ const string &right_paren_prefix = "_)");
+
+using PdtReverseArgs =
+ args::Package<const FstClass &, const std::vector<LabelPair> &,
+ MutableFstClass *>;
+
+template <class Arc>
+void PdtReverse(PdtReverseArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ // In case Arc::Label is not the same as FstClass::Label, we make a
+ // copy. Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label,
+ typename Arc::Label>> typed_parens(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_parens.begin());
+ Reverse(fst, typed_parens, ofst);
+}
+
+void PdtReverse(const FstClass &ifst, const std::vector<LabelPair> &,
+ MutableFstClass *ofst);
+
+// PDT SHORTESTPATH
+
+struct PdtShortestPathOptions {
+ QueueType queue_type;
+ bool keep_parentheses;
+ bool path_gc;
+
+ PdtShortestPathOptions(QueueType qt = FIFO_QUEUE, bool kp = false,
+ bool gc = true)
+ : queue_type(qt), keep_parentheses(kp), path_gc(gc) {}
+};
+
+using PdtShortestPathArgs =
+ args::Package<const FstClass &, const std::vector<LabelPair> &,
+ MutableFstClass *, const PdtShortestPathOptions &>;
+
+template <class Arc>
+void PdtShortestPath(PdtShortestPathArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ const PdtShortestPathOptions &opts = args->arg4;
+ // In case Arc::Label is not the same as FstClass::Label, we make a
+ // copy. Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label,
+ typename Arc::Label>> typed_parens(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_parens.begin());
+ switch (opts.queue_type) {
+ default:
+ FSTERROR() << "Unknown queue type: " << opts.queue_type;
+ case FIFO_QUEUE: {
+ using Queue = FifoQueue<typename Arc::StateId>;
+ fst::PdtShortestPathOptions<Arc, Queue> spopts(opts.keep_parentheses,
+ opts.path_gc);
+ ShortestPath(fst, typed_parens, ofst, spopts);
+ return;
+ }
+ case LIFO_QUEUE: {
+ using Queue = LifoQueue<typename Arc::StateId>;
+ fst::PdtShortestPathOptions<Arc, Queue> spopts(opts.keep_parentheses,
+ opts.path_gc);
+ ShortestPath(fst, typed_parens, ofst, spopts);
+ return;
+ }
+ case STATE_ORDER_QUEUE: {
+ using Queue = StateOrderQueue<typename Arc::StateId>;
+ fst::PdtShortestPathOptions<Arc, Queue> spopts(opts.keep_parentheses,
+ opts.path_gc);
+ ShortestPath(fst, typed_parens, ofst, spopts);
+ return;
+ }
+ }
+}
+
+void PdtShortestPath(const FstClass &ifst,
+ const std::vector<LabelPair> &parens, MutableFstClass *ofst,
+ const PdtShortestPathOptions &opts = PdtShortestPathOptions());
+
+// PRINT INFO
+
+using PrintPdtInfoArgs =
+ args::Package<const FstClass &, const std::vector<LabelPair> &>;
+
+template <class Arc>
+void PrintPdtInfo(PrintPdtInfoArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ // In case Arc::Label is not the same as FstClass::Label, we make a
+ // copy. Truncation may occur if FstClass::Label has more precision than
+ // Arc::Label.
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ typed_parens(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_parens.begin());
+ PdtInfo<Arc> pdtinfo(fst, typed_parens);
+ PrintPdtInfo(pdtinfo);
+}
+
+void PrintPdtInfo(const FstClass &ifst, const std::vector<LabelPair> &parens);
+
+} // namespace script
+} // namespace fst
+
+#define REGISTER_FST_PDT_OPERATIONS(ArcType) \
+ REGISTER_FST_OPERATION(PdtCompose, ArcType, PdtComposeArgs); \
+ REGISTER_FST_OPERATION(PdtExpand, ArcType, PdtExpandArgs); \
+ REGISTER_FST_OPERATION(PdtReplace, ArcType, PdtReplaceArgs); \
+ REGISTER_FST_OPERATION(PdtReverse, ArcType, PdtReverseArgs); \
+ REGISTER_FST_OPERATION(PdtShortestPath, ArcType, PdtShortestPathArgs); \
+ REGISTER_FST_OPERATION(PrintPdtInfo, ArcType, PrintPdtInfoArgs)
+#endif // FST_EXTENSIONS_PDT_PDTSCRIPT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Recursively replaces FST arcs with other FSTs, returning a PDT.
+
+#ifndef FST_EXTENSIONS_PDT_REPLACE_H_
+#define FST_EXTENSIONS_PDT_REPLACE_H_
+
+#include <map>
+#include <memory>
+#include <set>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/replace.h>
+#include <fst/replace-util.h>
+#include <fst/symbol-table-ops.h>
+
+namespace fst {
+namespace internal {
+
+// Hash to paren IDs
+template <typename S>
+struct ReplaceParenHash {
+ size_t operator()(const std::pair<size_t, S> &paren) const {
+ static constexpr auto prime = 7853;
+ return paren.first + paren.second * prime;
+ }
+};
+
+} // namespace internal
+
+// Parser types characterize the PDT construction method. When applied to a CFG,
+// each non-terminal is encoded as a DFA that accepts precisely the RHS's of
+// productions of that non-terminal. For parsing (rather than just recognition),
+// production numbers can used as outputs (placed as early as possible) in the
+// DFAs promoted to DFTs. For more information on the strongly regular
+// construction, see:
+//
+// Mohri, M., and Pereira, F. 1998. Dynamic compilation of weighted context-free
+// grammars. In Proc. ACL, pages 891-897.
+enum PdtParserType {
+ // Top-down construction. Applied to a simple LL(1) grammar (among others),
+ // gives a DPDA. If promoted to a DPDT, with outputs being production
+ // numbers, gives a leftmost derivation. Left recursive grammars are
+ // problematic in use.
+ PDT_LEFT_PARSER,
+
+ // Top-down construction. Similar to PDT_LEFT_PARSE except bounded-stack
+ // (expandable as an FST) result with regular or, more generally, strongly
+ // regular grammars. Epsilons may replace some parentheses, which may
+ // introduce some non-determinism.
+ PDT_LEFT_SR_PARSER,
+
+ /* TODO(riley):
+ // Bottom-up construction. Applied to a LR(0) grammar, gives a DPDA.
+ // If promoted to a DPDT, with outputs being the production nubmers,
+ // gives the reverse of a rightmost derivation.
+ PDT_RIGHT_PARSER,
+ */
+};
+
+template <class Arc>
+struct PdtReplaceOptions {
+ using Label = typename Arc::Label;
+
+ explicit PdtReplaceOptions(Label root,
+ PdtParserType type = PDT_LEFT_PARSER,
+ Label start_paren_labels = kNoLabel,
+ string left_paren_prefix = "(_",
+ string right_paren_prefix = ")_") :
+ root(root), type(type), start_paren_labels(start_paren_labels),
+ left_paren_prefix(std::move(left_paren_prefix)),
+ right_paren_prefix(std::move(right_paren_prefix)) {}
+
+ Label root;
+ PdtParserType type;
+ Label start_paren_labels;
+ const string left_paren_prefix;
+ const string right_paren_prefix;
+};
+
+// PdtParser: Base PDT parser class common to specific parsers.
+
+template <class Arc>
+class PdtParser {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using LabelFstPair = std::pair<Label, const Fst<Arc> *>;
+ using LabelPair = std::pair<Label, Label>;
+ using LabelStatePair = std::pair<Label, StateId>;
+ using StateWeightPair = std::pair<StateId, Weight>;
+ using ParenKey = std::pair<size_t, StateId>;
+ using ParenMap =
+ std::unordered_map<ParenKey, size_t, internal::ReplaceParenHash<StateId>>;
+
+ PdtParser(const std::vector<LabelFstPair> &fst_array,
+ const PdtReplaceOptions<Arc> &opts) :
+ root_(opts.root), start_paren_labels_(opts.start_paren_labels),
+ left_paren_prefix_(std::move(opts.left_paren_prefix)),
+ right_paren_prefix_(std::move(opts.right_paren_prefix)),
+ error_(false) {
+ for (size_t i = 0; i < fst_array.size(); ++i) {
+ if (!CompatSymbols(fst_array[0].second->InputSymbols(),
+ fst_array[i].second->InputSymbols())) {
+ FSTERROR() << "PdtParser: Input symbol table of input FST " << i
+ << " does not match input symbol table of 0th input FST";
+ error_ = true;
+ }
+ if (!CompatSymbols(fst_array[0].second->OutputSymbols(),
+ fst_array[i].second->OutputSymbols())) {
+ FSTERROR() << "PdtParser: Output symbol table of input FST " << i
+ << " does not match input symbol table of 0th input FST";
+ error_ = true;
+ }
+ fst_array_.emplace_back(fst_array[i].first, fst_array[i].second->Copy());
+ // Builds map from non-terminal label to FST ID.
+ label2id_[fst_array[i].first] = i;
+ }
+ }
+
+ virtual ~PdtParser() {
+ for (auto &pair : fst_array_) delete pair.second;
+ }
+
+ // Constructs the output PDT, dependent on the derived parser type.
+ virtual void GetParser(MutableFst<Arc> *ofst,
+ std::vector<LabelPair> *parens) = 0;
+
+ protected:
+ const std::vector<LabelFstPair> &FstArray() const { return fst_array_; }
+
+ Label Root() const { return root_; }
+
+ // Maps from non-terminal label to corresponding FST ID, or returns
+ // kNoStateId to signal lookup failure.
+ StateId Label2Id(Label l) const {
+ auto it = label2id_.find(l);
+ return it == label2id_.end() ? kNoStateId : it->second;
+ }
+
+ // Maps from output state to input FST label, state pair, or returns a
+ // (kNoLabel, kNoStateId) pair to signal lookup failure.
+ LabelStatePair GetLabelStatePair(StateId os) const {
+ if (os >= label_state_pairs_.size()) {
+ static const LabelStatePair no_pair(kNoLabel, kNoLabel);
+ return no_pair;
+ } else {
+ return label_state_pairs_[os];
+ }
+ }
+
+ // Maps to output state from input FST (label, state) pair, or returns
+ // kNoStateId to signal lookup failure.
+ StateId GetState(const LabelStatePair &lsp) const {
+ auto it = state_map_.find(lsp);
+ if (it == state_map_.end()) {
+ return kNoStateId;
+ } else {
+ return it->second;
+ }
+ }
+
+ // Builds single FST combining all referenced input FSTs, leaving in the
+ // non-termnals for now; also tabulates the PDT states that correspond to the
+ // start and final states of the input FSTs.
+ void CreateFst(MutableFst<Arc> *ofst, std::vector<StateId> *open_dest,
+ std::vector<std::vector<StateWeightPair>> *close_src);
+
+ // Assigns parenthesis labels from total allocated paren IDs.
+ void AssignParenLabels(size_t total_nparens, std::vector<LabelPair> *parens) {
+ parens->clear();
+ for (size_t paren_id = 0; paren_id < total_nparens; ++paren_id) {
+ const auto open_paren = start_paren_labels_ + paren_id;
+ const auto close_paren = open_paren + total_nparens;
+ parens->emplace_back(open_paren, close_paren);
+ }
+ }
+
+ // Determines how non-terminal instances are assigned parentheses IDs.
+ virtual size_t AssignParenIds(const Fst<Arc> &ofst,
+ ParenMap *paren_map) const = 0;
+
+ // Changes a non-terminal transition to an open parenthesis transition
+ // redirected to the PDT state specified in the open_dest argument, when
+ // indexed by the input FST ID for the non-terminal. Adds close parenthesis
+ // transitions (with specified weights) from the PDT states specified in the
+ // close_src argument, when indexed by the input FST ID for the non-terminal,
+ // to the former destination state of the non-terminal transition. The
+ // paren_map argument gives the parenthesis ID for a given non-terminal FST ID
+ // and destination state pair. The close_non_term_weight vector specifies
+ // non-terminals for which the non-terminal arc weight should be applied on
+ // the close parenthesis (multiplying the close_src weight above) rather than
+ // on the open parenthesis. If no paren ID is found, then an epsilon replaces
+ // the parenthesis that would carry the non-terminal arc weight and the other
+ // parenthesis is omitted (appropriate for the strongly-regular case).
+ void AddParensToFst(
+ const std::vector<LabelPair> &parens,
+ const ParenMap &paren_map,
+ const std::vector<StateId> &open_dest,
+ const std::vector<std::vector<StateWeightPair>> &close_src,
+ const std::vector<bool> &close_non_term_weight,
+ MutableFst<Arc> *ofst);
+
+ // Ensures that parentheses arcs are added to the symbol table.
+ void AddParensToSymbolTables(const std::vector<LabelPair> &parens,
+ MutableFst<Arc> *ofst);
+
+ private:
+ std::vector<LabelFstPair> fst_array_;
+ Label root_;
+ // Index to use for the first parenthesis.
+ Label start_paren_labels_;
+ const string left_paren_prefix_;
+ const string right_paren_prefix_;
+ // Maps from non-terminal label to FST ID.
+ std::unordered_map<Label, StateId> label2id_;
+ // Given an output state, specifies the input FST (label, state) pair.
+ std::vector<LabelStatePair> label_state_pairs_;
+ // Given an FST (label, state) pair, specifies the output FST state ID.
+ std::map<LabelStatePair, StateId> state_map_;
+ bool error_;
+};
+
+template <class Arc>
+void PdtParser<Arc>::CreateFst(
+ MutableFst<Arc> *ofst, std::vector<StateId> *open_dest,
+ std::vector<std::vector<StateWeightPair>> *close_src) {
+ ofst->DeleteStates();
+ if (error_) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ open_dest->resize(fst_array_.size(), kNoStateId);
+ close_src->resize(fst_array_.size());
+ // Queue of non-terminals to replace.
+ std::deque<Label> non_term_queue;
+ non_term_queue.push_back(root_);
+ // Has a non-terminal been enqueued?
+ std::vector<bool> enqueued(fst_array_.size(), false);
+ enqueued[label2id_[root_]] = true;
+ Label max_label = kNoLabel;
+ for (StateId soff = 0; !non_term_queue.empty(); soff = ofst->NumStates()) {
+ const auto label = non_term_queue.front();
+ non_term_queue.pop_front();
+ StateId fst_id = Label2Id(label);
+ const auto *ifst = fst_array_[fst_id].second;
+ for (StateIterator<Fst<Arc>> siter(*ifst); !siter.Done(); siter.Next()) {
+ const auto is = siter.Value();
+ const auto os = ofst->AddState();
+ const LabelStatePair lsp(label, is);
+ label_state_pairs_.push_back(lsp);
+ state_map_[lsp] = os;
+ if (is == ifst->Start()) {
+ (*open_dest)[fst_id] = os;
+ if (label == root_) ofst->SetStart(os);
+ }
+ if (ifst->Final(is) != Weight::Zero()) {
+ if (label == root_) ofst->SetFinal(os, ifst->Final(is));
+ (*close_src)[fst_id].emplace_back(os, ifst->Final(is));
+ }
+ for (ArcIterator<Fst<Arc>> aiter(*ifst, is); !aiter.Done();
+ aiter.Next()) {
+ auto arc = aiter.Value();
+ arc.nextstate += soff;
+ if (max_label == kNoLabel || arc.olabel > max_label)
+ max_label = arc.olabel;
+ const auto nfst_id = Label2Id(arc.olabel);
+ if (nfst_id != kNoStateId) {
+ if (fst_array_[nfst_id].second->Start() == kNoStateId) continue;
+ if (!enqueued[nfst_id]) {
+ non_term_queue.push_back(arc.olabel);
+ enqueued[nfst_id] = true;
+ }
+ }
+ ofst->AddArc(os, arc);
+ }
+ }
+ }
+ if (start_paren_labels_ == kNoLabel)
+ start_paren_labels_ = max_label + 1;
+}
+
+template <class Arc>
+void PdtParser<Arc>::AddParensToFst(
+ const std::vector<LabelPair> &parens,
+ const ParenMap &paren_map,
+ const std::vector<StateId> &open_dest,
+ const std::vector<std::vector<StateWeightPair>> &close_src,
+ const std::vector<bool> &close_non_term_weight,
+ MutableFst<Arc> *ofst) {
+ StateId dead_state = kNoStateId;
+ using MIter = MutableArcIterator<MutableFst<Arc>>;
+ for (StateIterator<Fst<Arc>> siter(*ofst); !siter.Done(); siter.Next()) {
+ StateId os = siter.Value();
+ std::unique_ptr<MIter> aiter(new MIter(ofst, os));
+ for (auto n = 0; !aiter->Done(); aiter->Next(), ++n) {
+ const auto arc = aiter->Value(); // A reference here may go stale.
+ StateId nfst_id = Label2Id(arc.olabel);
+ if (nfst_id != kNoStateId) {
+ // Gets parentheses.
+ const ParenKey paren_key(nfst_id, arc.nextstate);
+ auto it = paren_map.find(paren_key);
+ Label open_paren = 0;
+ Label close_paren = 0;
+ if (it != paren_map.end()) {
+ const auto paren_id = it->second;
+ open_paren = parens[paren_id].first;
+ close_paren = parens[paren_id].second;
+ }
+ // Sets open parenthesis.
+ if (open_paren != 0 || !close_non_term_weight[nfst_id]) {
+ const auto open_weight =
+ close_non_term_weight[nfst_id] ? Weight::One() : arc.weight;
+ const Arc sarc(open_paren, open_paren, open_weight,
+ open_dest[nfst_id]);
+ aiter->SetValue(sarc);
+ } else {
+ if (dead_state == kNoStateId) {
+ dead_state = ofst->AddState();
+ }
+ const Arc sarc(0, 0, Weight::One(), dead_state);
+ aiter->SetValue(sarc);
+ }
+ // Adds close parentheses.
+ if (close_paren != 0 || close_non_term_weight[nfst_id]) {
+ for (size_t i = 0; i < close_src[nfst_id].size(); ++i) {
+ const auto &pair = close_src[nfst_id][i];
+ const auto close_weight = close_non_term_weight[nfst_id]
+ ? Times(arc.weight, pair.second)
+ : pair.second;
+ const Arc farc(close_paren, close_paren, close_weight,
+ arc.nextstate);
+
+ ofst->AddArc(pair.first, farc);
+ if (os == pair.first) { // Invalidated iterator.
+ aiter.reset(new MIter(ofst, os));
+ aiter->Seek(n);
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+template <class Arc>
+void PdtParser<Arc>::AddParensToSymbolTables(
+ const std::vector<LabelPair> &parens, MutableFst<Arc> *ofst) {
+ auto size = parens.size();
+ if (ofst->InputSymbols()) {
+ if (!AddAuxiliarySymbols(left_paren_prefix_, start_paren_labels_, size,
+ ofst->MutableInputSymbols())) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ if (!AddAuxiliarySymbols(right_paren_prefix_, start_paren_labels_ + size,
+ size, ofst->MutableInputSymbols())) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ }
+ if (ofst->OutputSymbols()) {
+ if (!AddAuxiliarySymbols(left_paren_prefix_, start_paren_labels_, size,
+ ofst->MutableOutputSymbols())) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ if (!AddAuxiliarySymbols(right_paren_prefix_, start_paren_labels_ + size,
+ size, ofst->MutableOutputSymbols())) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ }
+}
+
+// Builds a PDT by recursive replacement top-down, where the call and return are
+// encoded in the parentheses.
+template <class Arc>
+class PdtLeftParser final : public PdtParser<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using LabelFstPair = typename PdtParser<Arc>::LabelFstPair;
+ using LabelPair = typename PdtParser<Arc>::LabelPair;
+ using LabelStatePair = typename PdtParser<Arc>::LabelStatePair;
+ using StateWeightPair = typename PdtParser<Arc>::StateWeightPair;
+ using ParenKey = typename PdtParser<Arc>::ParenKey;
+ using ParenMap = typename PdtParser<Arc>::ParenMap;
+
+ using PdtParser<Arc>::AddParensToFst;
+ using PdtParser<Arc>::AddParensToSymbolTables;
+ using PdtParser<Arc>::AssignParenLabels;
+ using PdtParser<Arc>::CreateFst;
+ using PdtParser<Arc>::FstArray;
+ using PdtParser<Arc>::GetLabelStatePair;
+ using PdtParser<Arc>::GetState;
+ using PdtParser<Arc>::Label2Id;
+ using PdtParser<Arc>::Root;
+
+ PdtLeftParser(const std::vector<LabelFstPair> &fst_array,
+ const PdtReplaceOptions<Arc> &opts) :
+ PdtParser<Arc>(fst_array, opts) { }
+
+ void GetParser(MutableFst<Arc> *ofst,
+ std::vector<LabelPair> *parens) override;
+
+ protected:
+ // Assigns a unique parenthesis ID for each non-terminal, destination
+ // state pair.
+ size_t AssignParenIds(const Fst<Arc> &ofst,
+ ParenMap *paren_map) const override;
+};
+
+template <class Arc>
+void PdtLeftParser<Arc>::GetParser(
+ MutableFst<Arc> *ofst,
+ std::vector<LabelPair> *parens) {
+ ofst->DeleteStates();
+ parens->clear();
+ const auto &fst_array = FstArray();
+ // Map that gives the paren ID for a (non-terminal, dest. state) pair
+ // (which can be unique).
+ ParenMap paren_map;
+ // Specifies the open parenthesis destination state for a given non-terminal.
+ // The source is the non-terminal instance source state.
+ std::vector<StateId> open_dest(fst_array.size(), kNoStateId);
+ // Specifies close parenthesis source states and weights for a given
+ // non-terminal. The destination is the non-terminal instance destination
+ // state.
+ std::vector<std::vector<StateWeightPair>> close_src(fst_array.size());
+ // Specifies non-terminals for which the non-terminal arc weight
+ // should be applied on the close parenthesis (multiplying the
+ // 'close_src' weight above) rather than on the open parenthesis.
+ std::vector<bool> close_non_term_weight(fst_array.size(), false);
+ CreateFst(ofst, &open_dest, &close_src);
+ auto total_nparens = AssignParenIds(*ofst, &paren_map);
+ AssignParenLabels(total_nparens, parens);
+ AddParensToFst(*parens, paren_map, open_dest, close_src,
+ close_non_term_weight, ofst);
+ if (!fst_array.empty()) {
+ ofst->SetInputSymbols(fst_array[0].second->InputSymbols());
+ ofst->SetOutputSymbols(fst_array[0].second->OutputSymbols());
+ }
+ AddParensToSymbolTables(*parens, ofst);
+}
+
+template <class Arc>
+size_t PdtLeftParser<Arc>::AssignParenIds(
+ const Fst<Arc> &ofst,
+ ParenMap *paren_map) const {
+ // Number of distinct parenthesis pairs per FST.
+ std::vector<size_t> nparens(FstArray().size(), 0);
+ // Number of distinct parenthesis pairs overall.
+ size_t total_nparens = 0;
+ for (StateIterator<Fst<Arc>> siter(ofst); !siter.Done(); siter.Next()) {
+ const auto os = siter.Value();
+ for (ArcIterator<Fst<Arc>> aiter(ofst, os); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto nfst_id = Label2Id(arc.olabel);
+ if (nfst_id != kNoStateId) {
+ const ParenKey paren_key(nfst_id, arc.nextstate);
+ auto it = paren_map->find(paren_key);
+ if (it == paren_map->end()) {
+ // Assigns new paren ID for this (FST, dest state) pair.
+ (*paren_map)[paren_key] = nparens[nfst_id]++;
+ if (nparens[nfst_id] > total_nparens)
+ total_nparens = nparens[nfst_id];
+ }
+ }
+ }
+ }
+ return total_nparens;
+}
+
+// Similar to PdtLeftParser but:
+//
+// 1. Uses epsilons rather than parentheses labels for any non-terminal
+// instances within a left- (right-) linear dependency SCC,
+// 2. Allocates a paren ID uniquely for each such dependency SCC (rather than
+// non-terminal = dependency state) and destination state.
+template <class Arc>
+class PdtLeftSRParser final : public PdtParser<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using LabelFstPair = typename PdtParser<Arc>::LabelFstPair;
+ using LabelPair = typename PdtParser<Arc>::LabelPair;
+ using LabelStatePair = typename PdtParser<Arc>::LabelStatePair;
+ using StateWeightPair = typename PdtParser<Arc>::StateWeightPair;
+ using ParenKey = typename PdtParser<Arc>::ParenKey;
+ using ParenMap = typename PdtParser<Arc>::ParenMap;
+
+ using PdtParser<Arc>::AddParensToFst;
+ using PdtParser<Arc>::AddParensToSymbolTables;
+ using PdtParser<Arc>::AssignParenLabels;
+ using PdtParser<Arc>::CreateFst;
+ using PdtParser<Arc>::FstArray;
+ using PdtParser<Arc>::GetLabelStatePair;
+ using PdtParser<Arc>::GetState;
+ using PdtParser<Arc>::Label2Id;
+ using PdtParser<Arc>::Root;
+
+ PdtLeftSRParser(const std::vector<LabelFstPair> &fst_array,
+ const PdtReplaceOptions<Arc> &opts) :
+ PdtParser<Arc>(fst_array, opts),
+ replace_util_(fst_array, ReplaceUtilOptions(opts.root)) { }
+
+ void GetParser(MutableFst<Arc> *ofst,
+ std::vector<LabelPair> *parens) override;
+
+ protected:
+ // Assigns a unique parenthesis ID for each non-terminal, destination state
+ // pair when the non-terminal refers to a non-linear FST. Otherwise, assigns
+ // a unique parenthesis ID for each dependency SCC, destination state pair if
+ // the non-terminal instance is between
+ // SCCs. Otherwise does nothing.
+ size_t AssignParenIds(const Fst<Arc> &ofst,
+ ParenMap *paren_map) const override;
+
+ // Returns dependency SCC for given label.
+ size_t SCC(Label label) const { return replace_util_.SCC(label); }
+
+ // Is a given dependency SCC left-linear?
+ bool SCCLeftLinear(size_t scc_id) const {
+ const auto ll_props = kReplaceSCCLeftLinear | kReplaceSCCNonTrivial;
+ const auto scc_props = replace_util_.SCCProperties(scc_id);
+ return (scc_props & ll_props) == ll_props;
+ }
+
+ // Is a given dependency SCC right-linear?
+ bool SCCRightLinear(size_t scc_id) const {
+ const auto lr_props = kReplaceSCCRightLinear | kReplaceSCCNonTrivial;
+ const auto scc_props = replace_util_.SCCProperties(scc_id);
+ return (scc_props & lr_props) == lr_props;
+ }
+
+ // Components of left- (right-) linear dependency SCC; empty o.w.
+ const std::vector<size_t> &SCCComps(size_t scc_id) const {
+ if (scc_comps_.empty()) GetSCCComps();
+ return scc_comps_[scc_id];
+ }
+
+ // Returns the representative state of an SCC. For left-linear grammars, it
+ // is one of the initial states. For right-linear grammars, it is one of the
+ // non-terminal destination states; otherwise, it is kNoStateId.
+ StateId RepState(size_t scc_id) const {
+ if (SCCComps(scc_id).empty()) return kNoStateId;
+ const auto fst_id = SCCComps(scc_id).front();
+ const auto &fst_array = FstArray();
+ const auto label = fst_array[fst_id].first;
+ const auto *ifst = fst_array[fst_id].second;
+ if (SCCLeftLinear(scc_id)) {
+ const LabelStatePair lsp(label, ifst->Start());
+ return GetState(lsp);
+ } else { // Right-linear.
+ const LabelStatePair lsp(label, *NonTermDests(fst_id).begin());
+ return GetState(lsp);
+ }
+ return kNoStateId;
+ }
+
+ private:
+ // Merges initial (final) states of in a left- (right-) linear dependency SCC
+ // after dealing with the non-terminal arc and final weights.
+ void ProcSCCs(MutableFst<Arc> *ofst,
+ std::vector<StateId> *open_dest,
+ std::vector<std::vector<StateWeightPair>> *close_src,
+ std::vector<bool> *close_non_term_weight) const;
+
+ // Computes components of left- (right-) linear dependency SCC.
+ void GetSCCComps() const {
+ const std::vector<LabelFstPair> &fst_array = FstArray();
+ for (size_t i = 0; i < fst_array.size(); ++i) {
+ const auto label = fst_array[i].first;
+ const auto scc_id = SCC(label);
+ if (scc_comps_.size() <= scc_id) scc_comps_.resize(scc_id + 1);
+ if (SCCLeftLinear(scc_id) || SCCRightLinear(scc_id)) {
+ scc_comps_[scc_id].push_back(i);
+ }
+ }
+ }
+
+ const std::set<StateId> &NonTermDests(StateId fst_id) const {
+ if (non_term_dests_.empty()) GetNonTermDests();
+ return non_term_dests_[fst_id];
+ }
+
+ // Finds non-terminal destination states for right-linear FSTS, or does
+ // nothing if not found.
+ void GetNonTermDests() const;
+
+ // Dependency SCC info.
+ mutable ReplaceUtil<Arc> replace_util_;
+ // Components of left- (right-) linear dependency SCCs, or empty otherwise.
+ mutable std::vector<std::vector<size_t>> scc_comps_;
+ // States that have non-terminals entering them for each (right-linear) FST.
+ mutable std::vector<std::set<StateId>> non_term_dests_;
+};
+
+template <class Arc>
+void PdtLeftSRParser<Arc>::GetParser(
+ MutableFst<Arc> *ofst,
+ std::vector<LabelPair> *parens) {
+ ofst->DeleteStates();
+ parens->clear();
+ const auto &fst_array = FstArray();
+ // Map that gives the paren ID for a (non-terminal, dest. state) pair.
+ ParenMap paren_map;
+ // Specifies the open parenthesis destination state for a given non-terminal.
+ // The source is the non-terminal instance source state.
+ std::vector<StateId> open_dest(fst_array.size(), kNoStateId);
+ // Specifies close parenthesis source states and weights for a given
+ // non-terminal. The destination is the non-terminal instance destination
+ // state.
+ std::vector<std::vector<StateWeightPair>> close_src(fst_array.size());
+ // Specifies non-terminals for which the non-terminal arc weight should be
+ // applied on the close parenthesis (multiplying the close_src weight above)
+ // rather than on the open parenthesis.
+ std::vector<bool> close_non_term_weight(fst_array.size(), false);
+ CreateFst(ofst, &open_dest, &close_src);
+ ProcSCCs(ofst, &open_dest, &close_src, &close_non_term_weight);
+ const auto total_nparens = AssignParenIds(*ofst, &paren_map);
+ AssignParenLabels(total_nparens, parens);
+ AddParensToFst(*parens, paren_map, open_dest, close_src,
+ close_non_term_weight, ofst);
+ if (!fst_array.empty()) {
+ ofst->SetInputSymbols(fst_array[0].second->InputSymbols());
+ ofst->SetOutputSymbols(fst_array[0].second->OutputSymbols());
+ }
+ AddParensToSymbolTables(*parens, ofst);
+ Connect(ofst);
+}
+
+template <class Arc>
+void PdtLeftSRParser<Arc>::ProcSCCs(
+ MutableFst<Arc> *ofst,
+ std::vector<StateId> *open_dest,
+ std::vector<std::vector<StateWeightPair>> *close_src,
+ std::vector<bool> *close_non_term_weight) const {
+ const auto &fst_array = FstArray();
+ for (StateIterator<Fst<Arc>> siter(*ofst); !siter.Done(); siter.Next()) {
+ const auto os = siter.Value();
+ const auto label = GetLabelStatePair(os).first;
+ const auto is = GetLabelStatePair(os).second;
+ const auto fst_id = Label2Id(label);
+ const auto scc_id = SCC(label);
+ const auto rs = RepState(scc_id);
+ const auto *ifst = fst_array[fst_id].second;
+ // SCC LEFT-LINEAR: puts non-terminal weights on close parentheses. Merges
+ // initial states into SCC representative state and updates open_dest.
+ if (SCCLeftLinear(scc_id)) {
+ (*close_non_term_weight)[fst_id] = true;
+ if (is == ifst->Start() && os != rs) {
+ for (ArcIterator<Fst<Arc>> aiter(*ofst, os); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ ofst->AddArc(rs, arc);
+ }
+ ofst->DeleteArcs(os);
+ if (os == ofst->Start())
+ ofst->SetStart(rs);
+ (*open_dest)[fst_id] = rs;
+ }
+ }
+ // SCC RIGHT-LINEAR: pushes back final weights onto non-terminals, if
+ // possible, or adds weighted epsilons to the SCC representative state.
+ // Merges final states into SCC representative state and updates close_src.
+ if (SCCRightLinear(scc_id)) {
+ for (MutableArcIterator<MutableFst<Arc>> aiter(ofst, os); !aiter.Done();
+ aiter.Next()) {
+ auto arc = aiter.Value();
+ const auto idest = GetLabelStatePair(arc.nextstate).second;
+ if (NonTermDests(fst_id).count(idest) > 0) {
+ if (ofst->Final(arc.nextstate) != Weight::Zero()) {
+ ofst->SetFinal(arc.nextstate, Weight::Zero());
+ ofst->SetFinal(rs, Weight::One());
+ }
+ arc.weight = Times(arc.weight, ifst->Final(idest));
+ arc.nextstate = rs;
+ aiter.SetValue(arc);
+ }
+ }
+ const auto final_weight = ifst->Final(is);
+ if (final_weight != Weight::Zero() &&
+ NonTermDests(fst_id).count(is) == 0) {
+ ofst->AddArc(os, Arc(0, 0, final_weight, rs));
+ if (ofst->Final(os) != Weight::Zero()) {
+ ofst->SetFinal(os, Weight::Zero());
+ ofst->SetFinal(rs, Weight::One());
+ }
+ }
+ if (is == ifst->Start()) {
+ (*close_src)[fst_id].clear();
+ (*close_src)[fst_id].emplace_back(rs, Weight::One());
+ }
+ }
+ }
+}
+
+template <class Arc>
+void PdtLeftSRParser<Arc>::GetNonTermDests() const {
+ const auto &fst_array = FstArray();
+ non_term_dests_.resize(fst_array.size());
+ for (size_t fst_id = 0; fst_id < fst_array.size(); ++fst_id) {
+ const auto label = fst_array[fst_id].first;
+ const auto scc_id = SCC(label);
+ if (SCCRightLinear(scc_id)) {
+ const auto *ifst = fst_array[fst_id].second;
+ for (StateIterator<Fst<Arc>> siter(*ifst); !siter.Done(); siter.Next()) {
+ const auto is = siter.Value();
+ for (ArcIterator<Fst<Arc>> aiter(*ifst, is); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ if (Label2Id(arc.olabel) != kNoStateId) {
+ non_term_dests_[fst_id].insert(arc.nextstate);
+ }
+ }
+ }
+ }
+ }
+}
+
+template <class Arc>
+size_t PdtLeftSRParser<Arc>::AssignParenIds(
+ const Fst<Arc> &ofst,
+ ParenMap *paren_map) const {
+ const auto &fst_array = FstArray();
+ // Number of distinct parenthesis pairs per FST.
+ std::vector<size_t> nparens(fst_array.size(), 0);
+ // Number of distinct parenthesis pairs overall.
+ size_t total_nparens = 0;
+ for (StateIterator<Fst<Arc>> siter(ofst); !siter.Done(); siter.Next()) {
+ const auto os = siter.Value();
+ const auto label = GetLabelStatePair(os).first;
+ const auto scc_id = SCC(label);
+ for (ArcIterator<Fst<Arc>> aiter(ofst, os); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto nfst_id = Label2Id(arc.olabel);
+ if (nfst_id != kNoStateId) {
+ size_t nscc_id = SCC(arc.olabel);
+ bool nscc_linear = !SCCComps(nscc_id).empty();
+ // Assigns a parenthesis ID for the non-terminal transition
+ // if the non-terminal belongs to a (left-/right-) linear dependency
+ // SCC or if the transition is in an FST from a different SCC
+ if (!nscc_linear || scc_id != nscc_id) {
+ // For (left-/right-) linear SCCs instead of using nfst_id, we
+ // will use its SCC prototype pfst_id for assigning distinct
+ // parenthesis IDs.
+ const auto pfst_id =
+ nscc_linear ? SCCComps(nscc_id).front() : nfst_id;
+ ParenKey paren_key(pfst_id, arc.nextstate);
+ const auto it = paren_map->find(paren_key);
+ if (it == paren_map->end()) {
+ // Assigns new paren ID for this (FST/SCC, dest. state) pair.
+ if (nscc_linear) {
+ // This is mapping we'll need, but we also store (harmlessly)
+ // for the prototype below so we can easily keep count per SCC.
+ const ParenKey nparen_key(nfst_id, arc.nextstate);
+ (*paren_map)[nparen_key] = nparens[pfst_id];
+ }
+ (*paren_map)[paren_key] = nparens[pfst_id]++;
+ if (nparens[pfst_id] > total_nparens) {
+ total_nparens = nparens[pfst_id];
+ }
+ }
+ }
+ }
+ }
+ }
+ return total_nparens;
+}
+
+// Builds a pushdown transducer (PDT) from an RTN specification. The result is
+// a PDT written to a mutable FST where 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 returned in the parens argument.
+template <class Arc>
+void Replace(
+ const std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>
+ &ifst_array,
+ MutableFst<Arc> *ofst,
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>> *parens,
+ const PdtReplaceOptions<Arc> &opts) {
+ switch (opts.type) {
+ case PDT_LEFT_PARSER:
+ {
+ PdtLeftParser<Arc> pr(ifst_array, opts);
+ pr.GetParser(ofst, parens);
+ return;
+ }
+ case PDT_LEFT_SR_PARSER:
+ {
+ PdtLeftSRParser<Arc> pr(ifst_array, opts);
+ pr.GetParser(ofst, parens);
+ return;
+ }
+ default:
+ FSTERROR() << "Replace: Unknown PDT parser type: " << opts.type;
+ ofst->DeleteStates();
+ ofst->SetProperties(kError, kError);
+ parens->clear();
+ return;
+ }
+}
+
+// Variant where the only user-controlled arguments is the root ID.
+template <class Arc>
+void Replace(
+ const std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>
+ &ifst_array,
+ MutableFst<Arc> *ofst,
+ std::vector<std::pair<typename Arc::Label, typename Arc::Label>> *parens,
+ typename Arc::Label root) {
+ PdtReplaceOptions<Arc> opts(root);
+ Replace(ifst_array, ofst, parens, opts);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_REPLACE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Expands a PDT to an FST.
+
+#ifndef FST_EXTENSIONS_PDT_REVERSE_H_
+#define FST_EXTENSIONS_PDT_REVERSE_H_
+
+#include <vector>
+
+#include <fst/mutable-fst.h>
+#include <fst/relabel.h>
+#include <fst/reverse.h>
+
+namespace fst {
+
+// Reverses a pushdown transducer (PDT) encoded as an FST.
+template <class Arc, class RevArc>
+void Reverse(const Fst<Arc> &ifst,
+ const std::vector<
+ std::pair<typename Arc::Label, typename Arc::Label>> &parens,
+ MutableFst<RevArc> *ofst) {
+ using Label = typename Arc::Label;
+ // Reverses FST component.
+ Reverse(ifst, ofst);
+ // Exchanges open and close parenthesis pairs.
+ std::vector<std::pair<Label, Label>> relabel_pairs;
+ relabel_pairs.reserve(2 * parens.size());
+ for (const auto &pair : parens) {
+ relabel_pairs.emplace_back(pair.first, pair.second);
+ relabel_pairs.emplace_back(pair.second, pair.first);
+ }
+ Relabel(ofst, relabel_pairs, relabel_pairs);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_REVERSE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions to find shortest paths in a PDT.
+
+#ifndef FST_EXTENSIONS_PDT_SHORTEST_PATH_H_
+#define FST_EXTENSIONS_PDT_SHORTEST_PATH_H_
+
+#include <stack>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/extensions/pdt/paren.h>
+#include <fst/extensions/pdt/pdt.h>
+#include <fst/shortest-path.h>
+
+namespace fst {
+
+template <class Arc, class Queue>
+struct PdtShortestPathOptions {
+ bool keep_parentheses;
+ bool path_gc;
+
+ PdtShortestPathOptions(bool keep_parentheses = false, bool path_gc = true)
+ : keep_parentheses(keep_parentheses), path_gc(path_gc) {}
+};
+
+namespace internal {
+
+// Flags for shortest path data.
+
+constexpr uint8 kPdtInited = 0x01;
+constexpr uint8 kPdtFinal = 0x02;
+constexpr uint8 kPdtMarked = 0x04;
+
+// Stores shortest path tree info Distance(), Parent(), and ArcParent()
+// information keyed on two types:
+//
+// 1. SearchState: This is a usual node in a shortest path tree but:
+// a. is w.r.t a PDT search state (a pair of a PDT state and a "start" state,
+// either the PDT start state or the destination state of an open
+// parenthesis).
+// b. the Distance() is from this "start" state to the search state.
+// c. Parent().state is kNoLabel for the "start" state.
+//
+// 2. ParenSpec: This connects shortest path trees depending on the the
+// parenthesis taken. Given the parenthesis spec:
+// a. the Distance() is from the Parent() "start" state to the parenthesis
+// destination state.
+// b. The ArcParent() is the parenthesis arc.
+template <class Arc>
+class PdtShortestPathData {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ struct SearchState {
+ StateId state; // PDT state.
+ StateId start; // PDT paren "start" state.
+
+ SearchState(StateId s = kNoStateId, StateId t = kNoStateId)
+ : state(s), start(t) {}
+
+ bool operator==(const SearchState &other) const {
+ if (&other == this) return true;
+ return other.state == state && other.start == start;
+ }
+ };
+
+ // Specifies paren ID, source and dest "start" states of a paren. These are
+ // the "start" states of the respective sub-graphs.
+ struct ParenSpec {
+ ParenSpec(Label paren_id = kNoLabel, StateId src_start = kNoStateId,
+ StateId dest_start = kNoStateId)
+ : paren_id(paren_id), src_start(src_start), dest_start(dest_start) {}
+
+ Label paren_id;
+ StateId src_start; // Sub-graph "start" state for paren source.
+ StateId dest_start; // Sub-graph "start" state for paren dest.
+
+ bool operator==(const ParenSpec &other) const {
+ if (&other == this) return true;
+ return (other.paren_id == paren_id &&
+ other.src_start == other.src_start &&
+ other.dest_start == dest_start);
+ }
+ };
+
+ struct SearchData {
+ SearchData()
+ : distance(Weight::Zero()),
+ parent(kNoStateId, kNoStateId),
+ paren_id(kNoLabel),
+ flags(0) {}
+
+ Weight distance; // Distance to this state from PDT "start" state.
+ SearchState parent; // Parent state in shortest path tree.
+ int16 paren_id; // If parent arc has paren, paren ID (or kNoLabel).
+ uint8 flags; // First byte reserved for PdtShortestPathData use.
+ };
+
+ PdtShortestPathData(bool gc)
+ : gc_(gc), nstates_(0), ngc_(0), finished_(false) {}
+
+ ~PdtShortestPathData() {
+ VLOG(1) << "opm size: " << paren_map_.size();
+ VLOG(1) << "# of search states: " << nstates_;
+ if (gc_) VLOG(1) << "# of GC'd search states: " << ngc_;
+ }
+
+ void Clear() {
+ search_map_.clear();
+ search_multimap_.clear();
+ paren_map_.clear();
+ state_ = SearchState(kNoStateId, kNoStateId);
+ nstates_ = 0;
+ ngc_ = 0;
+ }
+
+ // TODO(kbg): Currently copying SearchState and passing a const reference to
+ // ParenSpec. Benchmark to confirm this is the right thing to do.
+
+ Weight Distance(SearchState s) const { return GetSearchData(s)->distance; }
+
+ Weight Distance(const ParenSpec &paren) const {
+ return GetSearchData(paren)->distance;
+ }
+
+ SearchState Parent(SearchState s) const { return GetSearchData(s)->parent; }
+
+ SearchState Parent(const ParenSpec &paren) const {
+ return GetSearchData(paren)->parent;
+ }
+
+ Label ParenId(SearchState s) const { return GetSearchData(s)->paren_id; }
+
+ uint8 Flags(SearchState s) const { return GetSearchData(s)->flags; }
+
+ void SetDistance(SearchState s, Weight weight) {
+ GetSearchData(s)->distance = std::move(weight);
+ }
+
+ void SetDistance(const ParenSpec &paren, Weight weight) {
+ GetSearchData(paren)->distance = std::move(weight);
+ }
+
+ void SetParent(SearchState s, SearchState p) { GetSearchData(s)->parent = p; }
+
+ void SetParent(const ParenSpec &paren, SearchState p) {
+ GetSearchData(paren)->parent = p;
+ }
+
+ void SetParenId(SearchState s, Label p) {
+ if (p >= 32768) {
+ FSTERROR() << "PdtShortestPathData: Paren ID does not fit in an int16";
+ }
+ GetSearchData(s)->paren_id = p;
+ }
+
+ void SetFlags(SearchState s, uint8 f, uint8 mask) {
+ auto *data = GetSearchData(s);
+ data->flags &= ~mask;
+ data->flags |= f & mask;
+ }
+
+ void GC(StateId s);
+
+ void Finish() { finished_ = true; }
+
+ private:
+ // Hash for search state.
+ struct SearchStateHash {
+ size_t operator()(const SearchState &s) const {
+ static constexpr auto prime = 7853;
+ return s.state + s.start * prime;
+ }
+ };
+
+ // Hash for paren map.
+ struct ParenHash {
+ size_t operator()(const ParenSpec &paren) const {
+ static constexpr auto prime0 = 7853;
+ static constexpr auto prime1 = 7867;
+ return paren.paren_id + paren.src_start * prime0 +
+ paren.dest_start * prime1;
+ }
+ };
+
+ using SearchMap =
+ std::unordered_map<SearchState, SearchData, SearchStateHash>;
+
+ using SearchMultimap = std::unordered_multimap<StateId, StateId>;
+
+ // Hash map from paren spec to open paren data.
+ using ParenMap = std::unordered_map<ParenSpec, SearchData, ParenHash>;
+
+ SearchData *GetSearchData(SearchState s) const {
+ if (s == state_) return state_data_;
+ if (finished_) {
+ auto it = search_map_.find(s);
+ if (it == search_map_.end()) return &null_search_data_;
+ state_ = s;
+ return state_data_ = &(it->second);
+ } else {
+ state_ = s;
+ state_data_ = &search_map_[s];
+ if (!(state_data_->flags & kPdtInited)) {
+ ++nstates_;
+ if (gc_) search_multimap_.insert(std::make_pair(s.start, s.state));
+ state_data_->flags = kPdtInited;
+ }
+ return state_data_;
+ }
+ }
+
+ SearchData *GetSearchData(ParenSpec paren) const {
+ if (paren == paren_) return paren_data_;
+ if (finished_) {
+ auto it = paren_map_.find(paren);
+ if (it == paren_map_.end()) return &null_search_data_;
+ paren_ = paren;
+ return state_data_ = &(it->second);
+ } else {
+ paren_ = paren;
+ return paren_data_ = &paren_map_[paren];
+ }
+ }
+
+ mutable SearchMap search_map_; // Maps from search state to data.
+ mutable SearchMultimap search_multimap_; // Maps from "start" to subgraph.
+ mutable ParenMap paren_map_; // Maps paren spec to search data.
+ mutable SearchState state_; // Last state accessed.
+ mutable SearchData *state_data_; // Last state data accessed.
+ mutable ParenSpec paren_; // Last paren spec accessed.
+ mutable SearchData *paren_data_; // Last paren data accessed.
+ bool gc_; // Allow GC?
+ mutable size_t nstates_; // Total number of search states.
+ size_t ngc_; // Number of GC'd search states.
+ mutable SearchData null_search_data_; // Null search data.
+ bool finished_; // Read-only access when true.
+
+ PdtShortestPathData(const PdtShortestPathData &) = delete;
+ PdtShortestPathData &operator=(const PdtShortestPathData &) = delete;
+};
+
+// Deletes inaccessible search data from a given "start" (open paren dest)
+// state. Assumes "final" (close paren source or PDT final) states have
+// been flagged kPdtFinal.
+template <class Arc>
+void PdtShortestPathData<Arc>::GC(StateId start) {
+ if (!gc_) return;
+ std::vector<StateId> finals;
+ for (auto it = search_multimap_.find(start);
+ it != search_multimap_.end() && it->first == start; ++it) {
+ const SearchState s(it->second, start);
+ if (search_map_[s].flags & kPdtFinal) finals.push_back(s.state);
+ }
+ // Mark phase.
+ for (const auto state : finals) {
+ SearchState ss(state, start);
+ while (ss.state != kNoLabel) {
+ auto &sdata = search_map_[ss];
+ if (sdata.flags & kPdtMarked) break;
+ sdata.flags |= kPdtMarked;
+ const auto p = sdata.parent;
+ if (p.start != start && p.start != kNoLabel) { // Entering sub-subgraph.
+ const ParenSpec paren(sdata.paren_id, ss.start, p.start);
+ ss = paren_map_[paren].parent;
+ } else {
+ ss = p;
+ }
+ }
+ }
+ // Sweep phase.
+ auto it = search_multimap_.find(start);
+ while (it != search_multimap_.end() && it->first == start) {
+ const SearchState s(it->second, start);
+ auto mit = search_map_.find(s);
+ const SearchData &data = mit->second;
+ if (!(data.flags & kPdtMarked)) {
+ search_map_.erase(mit);
+ ++ngc_;
+ }
+ search_multimap_.erase(it++);
+ }
+}
+
+} // namespace internal
+
+// This computes the single source shortest (balanced) path (SSSP) through a
+// weighted PDT that has a bounded stack (i.e., is expandable as an FST). It is
+// a generalization of the classic SSSP graph algorithm that removes a state s
+// from a queue (defined by a user-provided queue type) and relaxes the
+// destination states of transitions leaving s. In this PDT version, states that
+// have entering open parentheses are treated as source states for a sub-graph
+// SSSP problem with the shortest path up to the open parenthesis being first
+// saved. When a close parenthesis is then encountered any balancing open
+// parenthesis is examined for this saved information and multiplied back. In
+// this way, each sub-graph is entered only once rather than repeatedly. If
+// every state in the input PDT has the property that there is a unique "start"
+// state for it with entering open parentheses, then this algorithm is quite
+// straightforward. In general, this will not be the case, so the algorithm
+// (implicitly) creates a new graph where each state is a pair of an original
+// state and a possible parenthesis "start" state for that state.
+template <class Arc, class Queue>
+class PdtShortestPath {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using SpData = internal::PdtShortestPathData<Arc>;
+ using SearchState = typename SpData::SearchState;
+ using ParenSpec = typename SpData::ParenSpec;
+ using CloseSourceIterator =
+ typename internal::PdtBalanceData<Arc>::SetIterator;
+
+ PdtShortestPath(const Fst<Arc> &ifst,
+ const std::vector<std::pair<Label, Label>> &parens,
+ const PdtShortestPathOptions<Arc, Queue> &opts)
+ : ifst_(ifst.Copy()),
+ parens_(parens),
+ keep_parens_(opts.keep_parentheses),
+ start_(ifst.Start()),
+ sp_data_(opts.path_gc),
+ error_(false) {
+ // TODO(kbg): Make this a compile-time static_assert once:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this oepration for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ if ((Weight::Properties() & (kPath | kRightSemiring)) !=
+ (kPath | kRightSemiring)) {
+ FSTERROR() << "PdtShortestPath: Weight needs to have the path"
+ << " property and be right distributive: " << Weight::Type();
+ error_ = true;
+ }
+ for (Label i = 0; i < parens.size(); ++i) {
+ const auto &pair = parens[i];
+ paren_map_[pair.first] = i;
+ paren_map_[pair.second] = i;
+ }
+ }
+
+ ~PdtShortestPath() {
+ VLOG(1) << "# of input states: " << CountStates(*ifst_);
+ VLOG(1) << "# of enqueued: " << nenqueued_;
+ VLOG(1) << "cpmm size: " << close_paren_multimap_.size();
+ }
+
+ void ShortestPath(MutableFst<Arc> *ofst) {
+ Init(ofst);
+ GetDistance(start_);
+ GetPath();
+ sp_data_.Finish();
+ if (error_) ofst->SetProperties(kError, kError);
+ }
+
+ const internal::PdtShortestPathData<Arc> &GetShortestPathData() const {
+ return sp_data_;
+ }
+
+ internal::PdtBalanceData<Arc> *GetBalanceData() { return &balance_data_; }
+
+ public:
+ // Hash multimap from close paren label to an paren arc.
+ using CloseParenMultimap =
+ std::unordered_multimap<internal::ParenState<Arc>, Arc,
+ typename internal::ParenState<Arc>::Hash>;
+
+ const CloseParenMultimap &GetCloseParenMultimap() const {
+ return close_paren_multimap_;
+ }
+
+ private:
+ void Init(MutableFst<Arc> *ofst);
+
+ void GetDistance(StateId start);
+
+ void ProcFinal(SearchState s);
+
+ void ProcArcs(SearchState s);
+
+ void ProcOpenParen(Label paren_id, SearchState s, StateId nexstate,
+ const Weight &weight);
+
+ void ProcCloseParen(Label paren_id, SearchState s, const Weight &weight);
+
+ void ProcNonParen(SearchState s, StateId nextstate, const Weight &weight);
+
+ void Relax(SearchState s, SearchState t, StateId nextstate,
+ const Weight &weight, Label paren_id);
+
+ void Enqueue(SearchState d);
+
+ void GetPath();
+
+ Arc GetPathArc(SearchState s, SearchState p, Label paren_id, bool open);
+
+ std::unique_ptr<Fst<Arc>> ifst_;
+ MutableFst<Arc> *ofst_;
+ const std::vector<std::pair<Label, Label>> &parens_;
+ bool keep_parens_;
+ Queue *state_queue_;
+ StateId start_;
+ Weight fdistance_;
+ SearchState f_parent_;
+ SpData sp_data_;
+ std::unordered_map<Label, Label> paren_map_;
+ CloseParenMultimap close_paren_multimap_;
+ internal::PdtBalanceData<Arc> balance_data_;
+ ssize_t nenqueued_;
+ bool error_;
+
+ static constexpr uint8 kEnqueued = 0x10;
+ static constexpr uint8 kExpanded = 0x20;
+ static constexpr uint8 kFinished = 0x40;
+
+ static const Arc kNoArc;
+};
+
+template <class Arc, class Queue>
+void PdtShortestPath<Arc, Queue>::Init(MutableFst<Arc> *ofst) {
+ ofst_ = ofst;
+ ofst->DeleteStates();
+ ofst->SetInputSymbols(ifst_->InputSymbols());
+ ofst->SetOutputSymbols(ifst_->OutputSymbols());
+ if (ifst_->Start() == kNoStateId) return;
+ fdistance_ = Weight::Zero();
+ f_parent_ = SearchState(kNoStateId, kNoStateId);
+ sp_data_.Clear();
+ close_paren_multimap_.clear();
+ balance_data_.Clear();
+ nenqueued_ = 0;
+ // Finds open parens per destination state and close parens per source state.
+ for (StateIterator<Fst<Arc>> siter(*ifst_); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ for (ArcIterator<Fst<Arc>> 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()) { // Is a paren?
+ const auto paren_id = it->second;
+ if (arc.ilabel == parens_[paren_id].first) { // Open paren.
+ balance_data_.OpenInsert(paren_id, arc.nextstate);
+ } else { // Close paren.
+ const internal::ParenState<Arc> paren_state(paren_id, s);
+ close_paren_multimap_.emplace(paren_state, arc);
+ }
+ }
+ }
+ }
+}
+
+// Computes the shortest distance stored in a recursive way. Each sub-graph
+// (i.e., different paren "start" state) begins with weight One().
+template <class Arc, class Queue>
+void PdtShortestPath<Arc, Queue>::GetDistance(StateId start) {
+ if (start == kNoStateId) return;
+ Queue state_queue;
+ state_queue_ = &state_queue;
+ const SearchState q(start, start);
+ Enqueue(q);
+ sp_data_.SetDistance(q, Weight::One());
+ while (!state_queue_->Empty()) {
+ const auto state = state_queue_->Head();
+ state_queue_->Dequeue();
+ const SearchState s(state, start);
+ sp_data_.SetFlags(s, 0, kEnqueued);
+ ProcFinal(s);
+ ProcArcs(s);
+ sp_data_.SetFlags(s, kExpanded, kExpanded);
+ }
+ sp_data_.SetFlags(q, kFinished, kFinished);
+ balance_data_.FinishInsert(start);
+ sp_data_.GC(start);
+}
+
+// Updates best complete path.
+template <class Arc, class Queue>
+void PdtShortestPath<Arc, Queue>::ProcFinal(SearchState s) {
+ if (ifst_->Final(s.state) != Weight::Zero() && s.start == start_) {
+ const auto weight = Times(sp_data_.Distance(s), ifst_->Final(s.state));
+ if (fdistance_ != Plus(fdistance_, weight)) {
+ if (f_parent_.state != kNoStateId) {
+ sp_data_.SetFlags(f_parent_, 0, internal::kPdtFinal);
+ }
+ sp_data_.SetFlags(s, internal::kPdtFinal, internal::kPdtFinal);
+ fdistance_ = Plus(fdistance_, weight);
+ f_parent_ = s;
+ }
+ }
+}
+
+// Processes all arcs leaving the state s.
+template <class Arc, class Queue>
+void PdtShortestPath<Arc, Queue>::ProcArcs(SearchState s) {
+ for (ArcIterator<Fst<Arc>> aiter(*ifst_, s.state); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto weight = Times(sp_data_.Distance(s), arc.weight);
+ const auto it = paren_map_.find(arc.ilabel);
+ if (it != paren_map_.end()) { // Is a paren?
+ const auto paren_id = it->second;
+ if (arc.ilabel == parens_[paren_id].first) {
+ ProcOpenParen(paren_id, s, arc.nextstate, weight);
+ } else {
+ ProcCloseParen(paren_id, s, weight);
+ }
+ } else {
+ ProcNonParen(s, arc.nextstate, weight);
+ }
+ }
+}
+
+// Saves the shortest path info for reaching this parenthesis and starts a new
+// SSSP in the sub-graph pointed to by the parenthesis if previously unvisited.
+// Otherwise it finds any previously encountered closing parentheses and relaxes
+// them using the recursively stored shortest distance to them.
+template <class Arc, class Queue>
+inline void PdtShortestPath<Arc, Queue>::ProcOpenParen(Label paren_id,
+ SearchState s,
+ StateId nextstate,
+ const Weight &weight) {
+ const SearchState d(nextstate, nextstate);
+ const ParenSpec paren(paren_id, s.start, d.start);
+ const auto pdist = sp_data_.Distance(paren);
+ if (pdist != Plus(pdist, weight)) {
+ sp_data_.SetDistance(paren, weight);
+ sp_data_.SetParent(paren, s);
+ const auto dist = sp_data_.Distance(d);
+ if (dist == Weight::Zero()) {
+ auto *state_queue = state_queue_;
+ GetDistance(d.start);
+ state_queue_ = state_queue;
+ } else if (!(sp_data_.Flags(d) & kFinished)) {
+ FSTERROR()
+ << "PdtShortestPath: open parenthesis recursion: not bounded stack";
+ error_ = true;
+ }
+ for (auto set_iter = balance_data_.Find(paren_id, nextstate);
+ !set_iter.Done(); set_iter.Next()) {
+ const SearchState cpstate(set_iter.Element(), d.start);
+ const internal::ParenState<Arc> paren_state(paren_id, cpstate.state);
+ for (auto cpit = close_paren_multimap_.find(paren_state);
+ cpit != close_paren_multimap_.end() && paren_state == cpit->first;
+ ++cpit) {
+ const auto &cparc = cpit->second;
+ const auto cpw =
+ Times(weight, Times(sp_data_.Distance(cpstate), cparc.weight));
+ Relax(cpstate, s, cparc.nextstate, cpw, paren_id);
+ }
+ }
+ }
+}
+
+// Saves the correspondence between each closing parenthesis and its balancing
+// open parenthesis info. Relaxes any close parenthesis destination state that
+// has a balancing previously encountered open parenthesis.
+template <class Arc, class Queue>
+inline void PdtShortestPath<Arc, Queue>::ProcCloseParen(Label paren_id,
+ SearchState s,
+ const Weight &weight) {
+ const internal::ParenState<Arc> paren_state(paren_id, s.start);
+ if (!(sp_data_.Flags(s) & kExpanded)) {
+ balance_data_.CloseInsert(paren_id, s.start, s.state);
+ sp_data_.SetFlags(s, internal::kPdtFinal, internal::kPdtFinal);
+ }
+}
+
+// Classical relaxation for non-parentheses.
+template <class Arc, class Queue>
+inline void PdtShortestPath<Arc, Queue>::ProcNonParen(SearchState s,
+ StateId nextstate,
+ const Weight &weight) {
+ Relax(s, s, nextstate, weight, kNoLabel);
+}
+
+// Classical relaxation on the search graph for an arc with destination state
+// nexstate from state s. State t is in the same sub-graph as nextstate (i.e.,
+// has the same paren "start").
+template <class Arc, class Queue>
+inline void PdtShortestPath<Arc, Queue>::Relax(SearchState s, SearchState t,
+ StateId nextstate,
+ const Weight &weight,
+ Label paren_id) {
+ const SearchState d(nextstate, t.start);
+ Weight dist = sp_data_.Distance(d);
+ if (dist != Plus(dist, weight)) {
+ sp_data_.SetParent(d, s);
+ sp_data_.SetParenId(d, paren_id);
+ sp_data_.SetDistance(d, Plus(dist, weight));
+ Enqueue(d);
+ }
+}
+
+template <class Arc, class Queue>
+inline void PdtShortestPath<Arc, Queue>::Enqueue(SearchState s) {
+ if (!(sp_data_.Flags(s) & kEnqueued)) {
+ state_queue_->Enqueue(s.state);
+ sp_data_.SetFlags(s, kEnqueued, kEnqueued);
+ ++nenqueued_;
+ } else {
+ state_queue_->Update(s.state);
+ }
+}
+
+// Follows parent pointers to find the shortest path. A stack is used since the
+// shortest distance is stored recursively.
+template <class Arc, class Queue>
+void PdtShortestPath<Arc, Queue>::GetPath() {
+ SearchState s = f_parent_;
+ SearchState d = SearchState(kNoStateId, kNoStateId);
+ StateId s_p = kNoStateId;
+ StateId d_p = kNoStateId;
+ auto arc = kNoArc;
+ Label paren_id = kNoLabel;
+ std::stack<ParenSpec> paren_stack;
+ while (s.state != kNoStateId) {
+ d_p = s_p;
+ s_p = ofst_->AddState();
+ if (d.state == kNoStateId) {
+ ofst_->SetFinal(s_p, ifst_->Final(f_parent_.state));
+ } else {
+ if (paren_id != kNoLabel) { // Paren?
+ if (arc.ilabel == parens_[paren_id].first) { // Open paren?
+ paren_stack.pop();
+ } else { // Close paren?
+ const ParenSpec paren(paren_id, d.start, s.start);
+ paren_stack.push(paren);
+ }
+ if (!keep_parens_) arc.ilabel = arc.olabel = 0;
+ }
+ arc.nextstate = d_p;
+ ofst_->AddArc(s_p, arc);
+ }
+ d = s;
+ s = sp_data_.Parent(d);
+ paren_id = sp_data_.ParenId(d);
+ if (s.state != kNoStateId) {
+ arc = GetPathArc(s, d, paren_id, false);
+ } else if (!paren_stack.empty()) {
+ const ParenSpec paren = paren_stack.top();
+ s = sp_data_.Parent(paren);
+ paren_id = paren.paren_id;
+ arc = GetPathArc(s, d, paren_id, true);
+ }
+ }
+ ofst_->SetStart(s_p);
+ ofst_->SetProperties(
+ ShortestPathProperties(ofst_->Properties(kFstProperties, false)),
+ kFstProperties);
+}
+
+// Finds transition with least weight between two states with label matching
+// paren_id and open/close paren type or a non-paren if kNoLabel.
+template <class Arc, class Queue>
+Arc PdtShortestPath<Arc, Queue>::GetPathArc(SearchState s, SearchState d,
+ Label paren_id, bool open_paren) {
+ auto path_arc = kNoArc;
+ for (ArcIterator<Fst<Arc>> aiter(*ifst_, s.state); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ if (arc.nextstate != d.state) continue;
+ Label arc_paren_id = kNoLabel;
+ const auto it = paren_map_.find(arc.ilabel);
+ if (it != paren_map_.end()) {
+ arc_paren_id = it->second;
+ bool arc_open_paren = (arc.ilabel == parens_[arc_paren_id].first);
+ if (arc_open_paren != open_paren) continue;
+ }
+ if (arc_paren_id != paren_id) continue;
+ if (arc.weight == Plus(arc.weight, path_arc.weight)) path_arc = arc;
+ }
+ if (path_arc.nextstate == kNoStateId) {
+ FSTERROR() << "PdtShortestPath::GetPathArc: Failed to find arc";
+ error_ = true;
+ }
+ return path_arc;
+}
+
+template <class Arc, class Queue>
+const Arc PdtShortestPath<Arc, Queue>::kNoArc = Arc(kNoLabel, kNoLabel,
+ Weight::Zero(), kNoStateId);
+
+// Functional variants.
+
+template <class Arc, class Queue>
+void ShortestPath(
+ const Fst<Arc> &ifst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens,
+ MutableFst<Arc> *ofst, const PdtShortestPathOptions<Arc, Queue> &opts) {
+ PdtShortestPath<Arc, Queue> psp(ifst, parens, opts);
+ psp.ShortestPath(ofst);
+}
+
+template <class Arc>
+void ShortestPath(
+ const Fst<Arc> &ifst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &parens,
+ MutableFst<Arc> *ofst) {
+ using Q = FifoQueue<typename Arc::StateId>;
+ const PdtShortestPathOptions<Arc, Q> opts;
+ PdtShortestPath<Arc, Q> psp(ifst, parens, opts);
+ psp.ShortestPath(ofst);
+}
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_PDT_SHORTEST_PATH_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_EXTENSIONS_SPECIAL_PHI_FST_H_
+#define FST_EXTENSIONS_SPECIAL_PHI_FST_H_
+
+#include <memory>
+#include <string>
+
+#include <fst/const-fst.h>
+#include <fst/matcher-fst.h>
+#include <fst/matcher.h>
+
+DECLARE_int64(phi_fst_phi_label);
+DECLARE_bool(phi_fst_phi_loop);
+DECLARE_string(phi_fst_rewrite_mode);
+
+namespace fst {
+namespace internal {
+
+template <class Label>
+class PhiFstMatcherData {
+ public:
+ PhiFstMatcherData(
+ Label phi_label = FLAGS_phi_fst_phi_label,
+ bool phi_loop = FLAGS_phi_fst_phi_loop,
+ MatcherRewriteMode rewrite_mode = RewriteMode(FLAGS_phi_fst_rewrite_mode))
+ : phi_label_(phi_label),
+ phi_loop_(phi_loop),
+ rewrite_mode_(rewrite_mode) {}
+
+ PhiFstMatcherData(const PhiFstMatcherData &data)
+ : phi_label_(data.phi_label_),
+ phi_loop_(data.phi_loop_),
+ rewrite_mode_(data.rewrite_mode_) {}
+
+ static PhiFstMatcherData<Label> *Read(std::istream &istrm,
+ const FstReadOptions &read) {
+ auto *data = new PhiFstMatcherData<Label>();
+ ReadType(istrm, &data->phi_label_);
+ ReadType(istrm, &data->phi_loop_);
+ int32 rewrite_mode;
+ ReadType(istrm, &rewrite_mode);
+ data->rewrite_mode_ = static_cast<MatcherRewriteMode>(rewrite_mode);
+ return data;
+ }
+
+ bool Write(std::ostream &ostrm, const FstWriteOptions &opts) const {
+ WriteType(ostrm, phi_label_);
+ WriteType(ostrm, phi_loop_);
+ WriteType(ostrm, static_cast<int32>(rewrite_mode_));
+ return !ostrm ? false : true;
+ }
+
+ Label PhiLabel() const { return phi_label_; }
+
+ bool PhiLoop() const { return phi_loop_; }
+
+ MatcherRewriteMode RewriteMode() const { return rewrite_mode_; }
+
+ private:
+ static MatcherRewriteMode RewriteMode(const string &mode) {
+ if (mode == "auto") return MATCHER_REWRITE_AUTO;
+ if (mode == "always") return MATCHER_REWRITE_ALWAYS;
+ if (mode == "never") return MATCHER_REWRITE_NEVER;
+ LOG(WARNING) << "PhiFst: Unknown rewrite mode: " << mode << ". "
+ << "Defaulting to auto.";
+ return MATCHER_REWRITE_AUTO;
+ }
+
+ Label phi_label_;
+ bool phi_loop_;
+ MatcherRewriteMode rewrite_mode_;
+};
+
+} // namespace internal
+
+constexpr uint8 kPhiFstMatchInput = 0x01; // Input matcher is PhiMatcher.
+constexpr uint8 kPhiFstMatchOutput = 0x02; // Output matcher is PhiMatcher.
+
+template <class M, uint8 F = kPhiFstMatchInput | kPhiFstMatchOutput>
+class PhiFstMatcher : public PhiMatcher<M> {
+ public:
+ using FST = typename M::FST;
+ using Arc = typename M::Arc;
+ using StateId = typename Arc::StateId;
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+ using MatcherData = internal::PhiFstMatcherData<Label>;
+
+ PhiFstMatcher(const FST &fst, MatchType match_type,
+ std::shared_ptr<MatcherData> data = std::make_shared<MatcherData>())
+ : PhiMatcher<M>(fst, match_type,
+ PhiLabel(match_type, data ? data->PhiLabel()
+ : MatcherData().PhiLabel()),
+ data ? data->PhiLoop() : MatcherData().PhiLoop(),
+ data ? data->RewriteMode() : MatcherData().RewriteMode()),
+ data_(data) {}
+
+ PhiFstMatcher(const PhiFstMatcher<M, F> &matcher, bool safe = false)
+ : PhiMatcher<M>(matcher, false), data_(matcher.data_) {}
+
+ PhiFstMatcher<M, F> *Copy(bool safe = false) const override {
+ return new PhiFstMatcher<M, F>(*this, safe);
+ }
+
+ const MatcherData *GetData() const { return data_.get(); }
+
+ std::shared_ptr<MatcherData> GetSharedData() const { return data_; }
+
+ private:
+ static Label PhiLabel(MatchType match_type, Label label) {
+ if (match_type == MATCH_INPUT && F & kPhiFstMatchInput) return label;
+ if (match_type == MATCH_OUTPUT && F & kPhiFstMatchOutput) return label;
+ return kNoLabel;
+ }
+
+ std::shared_ptr<MatcherData> data_;
+};
+
+extern const char phi_fst_type[];
+extern const char input_phi_fst_type[];
+extern const char output_phi_fst_type[];
+
+using StdPhiFst =
+ MatcherFst<ConstFst<StdArc>, PhiFstMatcher<SortedMatcher<ConstFst<StdArc>>>,
+ phi_fst_type>;
+
+using LogPhiFst =
+ MatcherFst<ConstFst<LogArc>, PhiFstMatcher<SortedMatcher<ConstFst<LogArc>>>,
+ phi_fst_type>;
+
+using Log64PhiFst = MatcherFst<ConstFst<Log64Arc>,
+ PhiFstMatcher<SortedMatcher<ConstFst<Log64Arc>>>,
+ input_phi_fst_type>;
+
+using StdInputPhiFst =
+ MatcherFst<ConstFst<StdArc>, PhiFstMatcher<SortedMatcher<ConstFst<StdArc>>,
+ kPhiFstMatchInput>,
+ input_phi_fst_type>;
+
+using LogInputPhiFst =
+ MatcherFst<ConstFst<LogArc>, PhiFstMatcher<SortedMatcher<ConstFst<LogArc>>,
+ kPhiFstMatchInput>,
+ input_phi_fst_type>;
+
+using Log64InputPhiFst = MatcherFst<
+ ConstFst<Log64Arc>,
+ PhiFstMatcher<SortedMatcher<ConstFst<Log64Arc>>, kPhiFstMatchInput>,
+ input_phi_fst_type>;
+
+using StdOutputPhiFst =
+ MatcherFst<ConstFst<StdArc>, PhiFstMatcher<SortedMatcher<ConstFst<StdArc>>,
+ kPhiFstMatchOutput>,
+ output_phi_fst_type>;
+
+using LogOutputPhiFst =
+ MatcherFst<ConstFst<LogArc>, PhiFstMatcher<SortedMatcher<ConstFst<LogArc>>,
+ kPhiFstMatchOutput>,
+ output_phi_fst_type>;
+
+using Log64OutputPhiFst = MatcherFst<
+ ConstFst<Log64Arc>,
+ PhiFstMatcher<SortedMatcher<ConstFst<Log64Arc>>, kPhiFstMatchOutput>,
+ output_phi_fst_type>;
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_SPECIAL_PHI_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_EXTENSIONS_SPECIAL_RHO_FST_H_
+#define FST_EXTENSIONS_SPECIAL_RHO_FST_H_
+
+#include <memory>
+#include <string>
+
+#include <fst/const-fst.h>
+#include <fst/matcher-fst.h>
+#include <fst/matcher.h>
+
+DECLARE_int64(rho_fst_rho_label);
+DECLARE_string(rho_fst_rewrite_mode);
+
+namespace fst {
+namespace internal {
+
+template <class Label>
+class RhoFstMatcherData {
+ public:
+ explicit RhoFstMatcherData(
+ Label rho_label = FLAGS_rho_fst_rho_label,
+ MatcherRewriteMode rewrite_mode = RewriteMode(FLAGS_rho_fst_rewrite_mode))
+ : rho_label_(rho_label), rewrite_mode_(rewrite_mode) {}
+
+ RhoFstMatcherData(const RhoFstMatcherData &data)
+ : rho_label_(data.rho_label_), rewrite_mode_(data.rewrite_mode_) {}
+
+ static RhoFstMatcherData<Label> *Read(std::istream &istrm,
+ const FstReadOptions &read) {
+ auto *data = new RhoFstMatcherData<Label>();
+ ReadType(istrm, &data->rho_label_);
+ int32 rewrite_mode;
+ ReadType(istrm, &rewrite_mode);
+ data->rewrite_mode_ = static_cast<MatcherRewriteMode>(rewrite_mode);
+ return data;
+ }
+
+ bool Write(std::ostream &ostrm, const FstWriteOptions &opts) const {
+ WriteType(ostrm, rho_label_);
+ WriteType(ostrm, static_cast<int32>(rewrite_mode_));
+ return !ostrm ? false : true;
+ }
+
+ Label RhoLabel() const { return rho_label_; }
+
+ MatcherRewriteMode RewriteMode() const { return rewrite_mode_; }
+
+ private:
+ static MatcherRewriteMode RewriteMode(const string &mode) {
+ if (mode == "auto") return MATCHER_REWRITE_AUTO;
+ if (mode == "always") return MATCHER_REWRITE_ALWAYS;
+ if (mode == "never") return MATCHER_REWRITE_NEVER;
+ LOG(WARNING) << "RhoFst: Unknown rewrite mode: " << mode << ". "
+ << "Defaulting to auto.";
+ return MATCHER_REWRITE_AUTO;
+ }
+
+ Label rho_label_;
+ MatcherRewriteMode rewrite_mode_;
+};
+
+} // namespace internal
+
+constexpr uint8 kRhoFstMatchInput = 0x01; // Input matcher is RhoMatcher.
+constexpr uint8 kRhoFstMatchOutput = 0x02; // Output matcher is RhoMatcher.
+
+template <class M, uint8 F = kRhoFstMatchInput | kRhoFstMatchOutput>
+class RhoFstMatcher : public RhoMatcher<M> {
+ public:
+ using FST = typename M::FST;
+ using Arc = typename M::Arc;
+ using StateId = typename Arc::StateId;
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+ using MatcherData = internal::RhoFstMatcherData<Label>;
+
+ RhoFstMatcher(
+ const FST &fst, MatchType match_type,
+ std::shared_ptr<MatcherData> data = std::make_shared<MatcherData>())
+ : RhoMatcher<M>(fst, match_type,
+ RhoLabel(match_type, data ? data->RhoLabel()
+ : MatcherData().RhoLabel()),
+ data ? data->RewriteMode() : MatcherData().RewriteMode()),
+ data_(data) {}
+
+ RhoFstMatcher(const RhoFstMatcher<M, F> &matcher, bool safe = false)
+ : RhoMatcher<M>(matcher, false), data_(matcher.data_) {}
+
+ RhoFstMatcher<M, F> *Copy(bool safe = false) const override {
+ return new RhoFstMatcher<M, F>(*this, safe);
+ }
+
+ const MatcherData *GetData() const { return data_.get(); }
+
+ std::shared_ptr<MatcherData> GetSharedData() const { return data_; }
+
+ private:
+ static Label RhoLabel(MatchType match_type, Label label) {
+ if (match_type == MATCH_INPUT && F & kRhoFstMatchInput) return label;
+ if (match_type == MATCH_OUTPUT && F & kRhoFstMatchOutput) return label;
+ return kNoLabel;
+ }
+
+ std::shared_ptr<MatcherData> data_;
+};
+
+extern const char rho_fst_type[];
+extern const char input_rho_fst_type[];
+extern const char output_rho_fst_type[];
+
+using StdRhoFst =
+ MatcherFst<ConstFst<StdArc>, RhoFstMatcher<SortedMatcher<ConstFst<StdArc>>>,
+ rho_fst_type>;
+
+using LogRhoFst =
+ MatcherFst<ConstFst<LogArc>, RhoFstMatcher<SortedMatcher<ConstFst<LogArc>>>,
+ rho_fst_type>;
+
+using Log64RhoFst = MatcherFst<ConstFst<Log64Arc>,
+ RhoFstMatcher<SortedMatcher<ConstFst<Log64Arc>>>,
+ input_rho_fst_type>;
+
+using StdInputRhoFst =
+ MatcherFst<ConstFst<StdArc>, RhoFstMatcher<SortedMatcher<ConstFst<StdArc>>,
+ kRhoFstMatchInput>,
+ input_rho_fst_type>;
+
+using LogInputRhoFst =
+ MatcherFst<ConstFst<LogArc>, RhoFstMatcher<SortedMatcher<ConstFst<LogArc>>,
+ kRhoFstMatchInput>,
+ input_rho_fst_type>;
+
+using Log64InputRhoFst = MatcherFst<
+ ConstFst<Log64Arc>,
+ RhoFstMatcher<SortedMatcher<ConstFst<Log64Arc>>, kRhoFstMatchInput>,
+ input_rho_fst_type>;
+
+using StdOutputRhoFst =
+ MatcherFst<ConstFst<StdArc>, RhoFstMatcher<SortedMatcher<ConstFst<StdArc>>,
+ kRhoFstMatchOutput>,
+ output_rho_fst_type>;
+
+using LogOutputRhoFst =
+ MatcherFst<ConstFst<LogArc>, RhoFstMatcher<SortedMatcher<ConstFst<LogArc>>,
+ kRhoFstMatchOutput>,
+ output_rho_fst_type>;
+
+using Log64OutputRhoFst = MatcherFst<
+ ConstFst<Log64Arc>,
+ RhoFstMatcher<SortedMatcher<ConstFst<Log64Arc>>, kRhoFstMatchOutput>,
+ output_rho_fst_type>;
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_SPECIAL_RHO_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_EXTENSIONS_SPECIAL_SIGMA_FST_H_
+#define FST_EXTENSIONS_SPECIAL_SIGMA_FST_H_
+
+#include <memory>
+#include <string>
+
+#include <fst/const-fst.h>
+#include <fst/matcher-fst.h>
+#include <fst/matcher.h>
+
+DECLARE_int64(sigma_fst_sigma_label);
+DECLARE_string(sigma_fst_rewrite_mode);
+
+namespace fst {
+namespace internal {
+
+template <class Label>
+class SigmaFstMatcherData {
+ public:
+ explicit SigmaFstMatcherData(Label sigma_label = FLAGS_sigma_fst_sigma_label,
+ MatcherRewriteMode rewrite_mode =
+ RewriteMode(FLAGS_sigma_fst_rewrite_mode))
+ : sigma_label_(sigma_label), rewrite_mode_(rewrite_mode) {}
+
+ SigmaFstMatcherData(const SigmaFstMatcherData &data)
+ : sigma_label_(data.sigma_label_), rewrite_mode_(data.rewrite_mode_) {}
+
+ static SigmaFstMatcherData<Label> *Read(std::istream &istrm,
+ const FstReadOptions &read) {
+ auto *data = new SigmaFstMatcherData<Label>();
+ ReadType(istrm, &data->sigma_label_);
+ int32 rewrite_mode;
+ ReadType(istrm, &rewrite_mode);
+ data->rewrite_mode_ = static_cast<MatcherRewriteMode>(rewrite_mode);
+ return data;
+ }
+
+ bool Write(std::ostream &ostrm, const FstWriteOptions &opts) const {
+ WriteType(ostrm, sigma_label_);
+ WriteType(ostrm, static_cast<int32>(rewrite_mode_));
+ return !ostrm ? false : true;
+ }
+
+ Label SigmaLabel() const { return sigma_label_; }
+
+ MatcherRewriteMode RewriteMode() const { return rewrite_mode_; }
+
+ private:
+ static MatcherRewriteMode RewriteMode(const string &mode) {
+ if (mode == "auto") return MATCHER_REWRITE_AUTO;
+ if (mode == "always") return MATCHER_REWRITE_ALWAYS;
+ if (mode == "never") return MATCHER_REWRITE_NEVER;
+ LOG(WARNING) << "SigmaFst: Unknown rewrite mode: " << mode << ". "
+ << "Defaulting to auto.";
+ return MATCHER_REWRITE_AUTO;
+ }
+
+ Label sigma_label_;
+ MatcherRewriteMode rewrite_mode_;
+};
+
+} // namespace internal
+
+constexpr uint8 kSigmaFstMatchInput = 0x01; // Input matcher is SigmaMatcher.
+constexpr uint8 kSigmaFstMatchOutput = 0x02; // Output matcher is SigmaMatcher.
+
+template <class M, uint8 F = kSigmaFstMatchInput | kSigmaFstMatchOutput>
+class SigmaFstMatcher : public SigmaMatcher<M> {
+ public:
+ using FST = typename M::FST;
+ using Arc = typename M::Arc;
+ using StateId = typename Arc::StateId;
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+ using MatcherData = internal::SigmaFstMatcherData<Label>;
+
+ SigmaFstMatcher(
+ const FST &fst, MatchType match_type,
+ std::shared_ptr<MatcherData> data = std::make_shared<MatcherData>())
+ : SigmaMatcher<M>(
+ fst, match_type,
+ SigmaLabel(match_type,
+ data ? data->SigmaLabel() : MatcherData().SigmaLabel()),
+ data ? data->RewriteMode() : MatcherData().RewriteMode()),
+ data_(data) {}
+
+ SigmaFstMatcher(const SigmaFstMatcher<M, F> &matcher, bool safe = false)
+ : SigmaMatcher<M>(matcher, false), data_(matcher.data_) {}
+
+ SigmaFstMatcher<M, F> *Copy(bool safe = false) const override {
+ return new SigmaFstMatcher<M, F>(*this, safe);
+ }
+
+ const MatcherData *GetData() const { return data_.get(); }
+
+ std::shared_ptr<MatcherData> GetSharedData() const { return data_; }
+
+ private:
+ static Label SigmaLabel(MatchType match_type, Label label) {
+ if (match_type == MATCH_INPUT && F & kSigmaFstMatchInput) return label;
+ if (match_type == MATCH_OUTPUT && F & kSigmaFstMatchOutput) return label;
+ return kNoLabel;
+ }
+
+ std::shared_ptr<MatcherData> data_;
+};
+
+extern const char sigma_fst_type[];
+extern const char input_sigma_fst_type[];
+extern const char output_sigma_fst_type[];
+
+using StdSigmaFst = MatcherFst<ConstFst<StdArc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<StdArc>>>,
+ sigma_fst_type>;
+
+using LogSigmaFst = MatcherFst<ConstFst<LogArc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<LogArc>>>,
+ sigma_fst_type>;
+
+using Log64SigmaFst =
+ MatcherFst<ConstFst<Log64Arc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<Log64Arc>>>,
+ input_sigma_fst_type>;
+
+using StdInputSigmaFst = MatcherFst<
+ ConstFst<StdArc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<StdArc>>, kSigmaFstMatchInput>,
+ input_sigma_fst_type>;
+
+using LogInputSigmaFst = MatcherFst<
+ ConstFst<LogArc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<LogArc>>, kSigmaFstMatchInput>,
+ input_sigma_fst_type>;
+
+using Log64InputSigmaFst = MatcherFst<
+ ConstFst<Log64Arc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<Log64Arc>>, kSigmaFstMatchInput>,
+ input_sigma_fst_type>;
+
+using StdOutputSigmaFst = MatcherFst<
+ ConstFst<StdArc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<StdArc>>, kSigmaFstMatchOutput>,
+ output_sigma_fst_type>;
+
+using LogOutputSigmaFst = MatcherFst<
+ ConstFst<LogArc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<LogArc>>, kSigmaFstMatchOutput>,
+ output_sigma_fst_type>;
+
+using Log64OutputSigmaFst = MatcherFst<
+ ConstFst<Log64Arc>,
+ SigmaFstMatcher<SortedMatcher<ConstFst<Log64Arc>>, kSigmaFstMatchOutput>,
+ output_sigma_fst_type>;
+
+} // namespace fst
+
+#endif // FST_EXTENSIONS_SPECIAL_SIGMA_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Classes to factor weights in an FST.
+
+#ifndef FST_LIB_FACTOR_WEIGHT_H_
+#define FST_LIB_FACTOR_WEIGHT_H_
+
+#include <algorithm>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+constexpr uint32 kFactorFinalWeights = 0x00000001;
+constexpr uint32 kFactorArcWeights = 0x00000002;
+
+template <class Arc>
+struct FactorWeightOptions : CacheOptions {
+ using Label = typename Arc::Label;
+
+ float delta;
+ uint32 mode; // Factor arc weights and/or final weights.
+ Label final_ilabel; // Input label of arc when factoring final weights.
+ Label final_olabel; // Output label of arc when factoring final weights.
+ bool increment_final_ilabel; // When factoring final w' results in > 1 arcs
+ bool increment_final_olabel; // at state, increment labels to make distinct?
+
+ explicit FactorWeightOptions(const CacheOptions &opts, float delta = kDelta,
+ uint32 mode = kFactorArcWeights |
+ kFactorFinalWeights,
+ Label final_ilabel = 0, Label final_olabel = 0,
+ bool increment_final_ilabel = false,
+ bool increment_final_olabel = false)
+ : CacheOptions(opts),
+ delta(delta),
+ mode(mode),
+ final_ilabel(final_ilabel),
+ final_olabel(final_olabel),
+ increment_final_ilabel(increment_final_ilabel),
+ increment_final_olabel(increment_final_olabel) {}
+
+ explicit FactorWeightOptions(float delta = kDelta,
+ uint32 mode = kFactorArcWeights |
+ kFactorFinalWeights,
+ Label final_ilabel = 0, Label final_olabel = 0,
+ bool increment_final_ilabel = false,
+ bool increment_final_olabel = false)
+ : delta(delta),
+ mode(mode),
+ final_ilabel(final_ilabel),
+ final_olabel(final_olabel),
+ increment_final_ilabel(increment_final_ilabel),
+ increment_final_olabel(increment_final_olabel) {}
+};
+
+// A factor iterator takes as argument a weight w and returns a sequence of
+// pairs of weights (xi, yi) such that the sum of the products xi times yi is
+// equal to w. If w is fully factored, the iterator should return nothing.
+//
+// template <class W>
+// class FactorIterator {
+// public:
+// explicit FactorIterator(W w);
+//
+// bool Done() const;
+//
+// void Next();
+//
+// std::pair<W, W> Value() const;
+//
+// void Reset();
+// }
+
+// Factors trivially.
+template <class W>
+class IdentityFactor {
+ public:
+ explicit IdentityFactor(const W &weight) {}
+
+ bool Done() const { return true; }
+
+ void Next() {}
+
+ std::pair<W, W> Value() const { return std::make_pair(W::One(), W::One()); }
+
+ void Reset() {}
+};
+
+// Factors a StringWeight w as 'ab' where 'a' is a label.
+template <typename Label, StringType S = STRING_LEFT>
+class StringFactor {
+ public:
+ explicit StringFactor(const StringWeight<Label, S> &weight)
+ : weight_(weight), done_(weight.Size() <= 1) {}
+
+ bool Done() const { return done_; }
+
+ void Next() { done_ = true; }
+
+ std::pair<StringWeight<Label, S>, StringWeight<Label, S>> Value() const {
+ StringWeightIterator<Label, S> siter(weight_);
+ StringWeight<Label, S> w1(siter.Value());
+ StringWeight<Label, S> w2;
+ for (siter.Next(); !siter.Done(); siter.Next()) w2.PushBack(siter.Value());
+ return std::make_pair(w1, w2);
+ }
+
+ void Reset() { done_ = weight_.Size() <= 1; }
+
+ private:
+ const StringWeight<Label, S> weight_;
+ bool done_;
+};
+
+// Factor a GallicWeight using StringFactor.
+template <class Label, class W, GallicType G = GALLIC_LEFT>
+class GallicFactor {
+ public:
+ using GW = GallicWeight<Label, W, G>;
+
+ explicit GallicFactor(const GW &weight)
+ : weight_(weight), done_(weight.Value1().Size() <= 1) {}
+
+ bool Done() const { return done_; }
+
+ void Next() { done_ = true; }
+
+ std::pair<GW, GW> Value() const {
+ StringFactor<Label, GALLIC_STRING_TYPE(G)> siter(weight_.Value1());
+ GW w1(siter.Value().first, weight_.Value2());
+ GW w2(siter.Value().second, W::One());
+ return std::make_pair(w1, w2);
+ }
+
+ void Reset() { done_ = weight_.Value1().Size() <= 1; }
+
+ private:
+ const GW weight_;
+ bool done_;
+};
+
+// Specialization for the (general) GALLIC type GallicWeight.
+template <class Label, class W>
+class GallicFactor<Label, W, GALLIC> {
+ public:
+ using GW = GallicWeight<Label, W, GALLIC>;
+ using GRW = GallicWeight<Label, W, GALLIC_RESTRICT>;
+
+ explicit GallicFactor(const GW &weight)
+ : iter_(weight),
+ done_(weight.Size() == 0 ||
+ (weight.Size() == 1 && weight.Back().Value1().Size() <= 1)) {}
+
+ bool Done() const { return done_ || iter_.Done(); }
+
+ void Next() { iter_.Next(); }
+
+ void Reset() { iter_.Reset(); }
+
+ std::pair<GW, GW> Value() const {
+ const auto weight = iter_.Value();
+ StringFactor<Label, GALLIC_STRING_TYPE(GALLIC_RESTRICT)> siter(
+ weight.Value1());
+ GRW w1(siter.Value().first, weight.Value2());
+ GRW w2(siter.Value().second, W::One());
+ return std::make_pair(GW(w1), GW(w2));
+ }
+
+ private:
+ UnionWeightIterator<GRW, GallicUnionWeightOptions<Label, W>> iter_;
+ bool done_;
+};
+
+namespace internal {
+
+// Implementation class for FactorWeight
+template <class Arc, class FactorIterator>
+class FactorWeightFstImpl : public CacheImpl<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheBaseImpl<CacheState<Arc>>::PushArc;
+ using CacheBaseImpl<CacheState<Arc>>::HasStart;
+ using CacheBaseImpl<CacheState<Arc>>::HasFinal;
+ using CacheBaseImpl<CacheState<Arc>>::HasArcs;
+ using CacheBaseImpl<CacheState<Arc>>::SetArcs;
+ using CacheBaseImpl<CacheState<Arc>>::SetFinal;
+ using CacheBaseImpl<CacheState<Arc>>::SetStart;
+
+ struct Element {
+ Element() {}
+
+ Element(StateId s, Weight weight_) : state(s), weight(std::move(weight_)) {}
+
+ StateId state; // Input state ID.
+ Weight weight; // Residual weight.
+ };
+
+ FactorWeightFstImpl(const Fst<Arc> &fst, const FactorWeightOptions<Arc> &opts)
+ : CacheImpl<Arc>(opts),
+ fst_(fst.Copy()),
+ delta_(opts.delta),
+ mode_(opts.mode),
+ final_ilabel_(opts.final_ilabel),
+ final_olabel_(opts.final_olabel),
+ increment_final_ilabel_(opts.increment_final_ilabel),
+ increment_final_olabel_(opts.increment_final_olabel) {
+ SetType("factor_weight");
+ const auto props = fst.Properties(kFstProperties, false);
+ SetProperties(FactorWeightProperties(props), kCopyProperties);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ if (mode_ == 0) {
+ LOG(WARNING) << "FactorWeightFst: Factor mode is set to 0; "
+ << "factoring neither arc weights nor final weights";
+ }
+ }
+
+ FactorWeightFstImpl(const FactorWeightFstImpl<Arc, FactorIterator> &impl)
+ : CacheImpl<Arc>(impl),
+ fst_(impl.fst_->Copy(true)),
+ delta_(impl.delta_),
+ mode_(impl.mode_),
+ final_ilabel_(impl.final_ilabel_),
+ final_olabel_(impl.final_olabel_),
+ increment_final_ilabel_(impl.increment_final_ilabel_),
+ increment_final_olabel_(impl.increment_final_olabel_) {
+ SetType("factor_weight");
+ 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(FindState(Element(fst_->Start(), Weight::One())));
+ }
+ return CacheImpl<Arc>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) {
+ const auto &element = elements_[s];
+ // TODO(sorenj): fix so cast is unnecessary
+ const auto weight =
+ element.state == kNoStateId
+ ? element.weight
+ : (Weight)Times(element.weight, fst_->Final(element.state));
+ FactorIterator siter(weight);
+ if (!(mode_ & kFactorFinalWeights) || siter.Done()) {
+ SetFinal(s, weight);
+ } else {
+ SetFinal(s, Weight::Zero());
+ }
+ }
+ return CacheImpl<Arc>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::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<Arc>::Properties(mask);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<Arc>::InitArcIterator(s, data);
+ }
+
+ // Finds state corresponding to an element, creating new state if element not
+ // found.
+ StateId FindState(const Element &element) {
+ if (!(mode_ & kFactorArcWeights) && element.weight == Weight::One() &&
+ element.state != kNoStateId) {
+ while (unfactored_.size() <= element.state)
+ unfactored_.push_back(kNoStateId);
+ if (unfactored_[element.state] == kNoStateId) {
+ unfactored_[element.state] = elements_.size();
+ elements_.push_back(element);
+ }
+ return unfactored_[element.state];
+ } else {
+ const auto insert_result =
+ element_map_.insert(std::make_pair(element, elements_.size()));
+ if (insert_result.second) {
+ elements_.push_back(element);
+ }
+ return insert_result.first->second;
+ }
+ }
+
+ // Computes the outgoing transitions from a state, creating new destination
+ // states as needed.
+ void Expand(StateId s) {
+ const auto element = elements_[s];
+ if (element.state != kNoStateId) {
+ for (ArcIterator<Fst<Arc>> ait(*fst_, element.state); !ait.Done();
+ ait.Next()) {
+ const auto &arc = ait.Value();
+ const auto weight = Times(element.weight, arc.weight);
+ FactorIterator fiter(weight);
+ if (!(mode_ & kFactorArcWeights) || fiter.Done()) {
+ const auto dest = FindState(Element(arc.nextstate, Weight::One()));
+ PushArc(s, Arc(arc.ilabel, arc.olabel, weight, dest));
+ } else {
+ for (; !fiter.Done(); fiter.Next()) {
+ const auto &pair = fiter.Value();
+ const auto dest =
+ FindState(Element(arc.nextstate, pair.second.Quantize(delta_)));
+ PushArc(s, Arc(arc.ilabel, arc.olabel, pair.first, dest));
+ }
+ }
+ }
+ }
+ if ((mode_ & kFactorFinalWeights) &&
+ ((element.state == kNoStateId) ||
+ (fst_->Final(element.state) != Weight::Zero()))) {
+ const auto weight =
+ element.state == kNoStateId
+ ? element.weight
+ : Times(element.weight, fst_->Final(element.state));
+ auto ilabel = final_ilabel_;
+ auto olabel = final_olabel_;
+ for (FactorIterator fiter(weight); !fiter.Done(); fiter.Next()) {
+ const auto &pair = fiter.Value();
+ const auto dest =
+ FindState(Element(kNoStateId, pair.second.Quantize(delta_)));
+ PushArc(s, Arc(ilabel, olabel, pair.first, dest));
+ if (increment_final_ilabel_) ++ilabel;
+ if (increment_final_olabel_) ++olabel;
+ }
+ }
+ SetArcs(s);
+ }
+
+ private:
+ // Equality function for Elements, assume weights have been quantized.
+ class ElementEqual {
+ public:
+ bool operator()(const Element &x, const Element &y) const {
+ return x.state == y.state && x.weight == y.weight;
+ }
+ };
+
+ // Hash function for Elements to Fst states.
+ class ElementKey {
+ public:
+ size_t operator()(const Element &x) const {
+ static constexpr auto prime = 7853;
+ return static_cast<size_t>(x.state * prime + x.weight.Hash());
+ }
+ };
+
+ using ElementMap =
+ std::unordered_map<Element, StateId, ElementKey, ElementEqual>;
+
+ std::unique_ptr<const Fst<Arc>> fst_;
+ float delta_;
+ uint32 mode_; // Factoring arc and/or final weights.
+ Label final_ilabel_; // ilabel of arc created when factoring final weights.
+ Label final_olabel_; // olabel of arc created when factoring final weights.
+ bool increment_final_ilabel_; // When factoring final weights results in
+ bool increment_final_olabel_; // mutiple arcs, increment labels?
+ std::vector<Element> elements_; // mapping from FST state to Element.
+ ElementMap element_map_; // mapping from Element to FST state.
+ // Mapping between old/new StateId for states that do not need to be factored
+ // when mode_ is 0 or kFactorFinalWeights.
+ std::vector<StateId> unfactored_;
+};
+
+} // namespace internal
+
+// FactorWeightFst takes as template parameter a FactorIterator as defined
+// above. The result of weight factoring is a transducer equivalent to the
+// input whose path weights have been factored according to the FactorIterator.
+// States and transitions will be added as necessary. The algorithm is a
+// generalization to arbitrary weights of the second step of the input
+// epsilon-normalization algorithm.
+//
+// This class attaches interface to implementation and handles reference
+// counting, delegating most methods to ImplToFst.
+template <class A, class FactorIterator>
+class FactorWeightFst
+ : public ImplToFst<internal::FactorWeightFstImpl<A, FactorIterator>> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::FactorWeightFstImpl<Arc, FactorIterator>;
+
+ friend class ArcIterator<FactorWeightFst<Arc, FactorIterator>>;
+ friend class StateIterator<FactorWeightFst<Arc, FactorIterator>>;
+
+ explicit FactorWeightFst(const Fst<Arc> &fst)
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, FactorWeightOptions<Arc>())) {}
+
+ FactorWeightFst(const Fst<Arc> &fst, const FactorWeightOptions<Arc> &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ FactorWeightFst(const FactorWeightFst<Arc, FactorIterator> &fst, bool copy)
+ : ImplToFst<Impl>(fst, copy) {}
+
+ // Get a copy of this FactorWeightFst. See Fst<>::Copy() for further doc.
+ FactorWeightFst<Arc, FactorIterator> *Copy(bool copy = false) const override {
+ return new FactorWeightFst<Arc, FactorIterator>(*this, copy);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ FactorWeightFst &operator=(const FactorWeightFst &) = delete;
+};
+
+// Specialization for FactorWeightFst.
+template <class Arc, class FactorIterator>
+class StateIterator<FactorWeightFst<Arc, FactorIterator>>
+ : public CacheStateIterator<FactorWeightFst<Arc, FactorIterator>> {
+ public:
+ explicit StateIterator(const FactorWeightFst<Arc, FactorIterator> &fst)
+ : CacheStateIterator<FactorWeightFst<Arc, FactorIterator>>(
+ fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for FactorWeightFst.
+template <class Arc, class FactorIterator>
+class ArcIterator<FactorWeightFst<Arc, FactorIterator>>
+ : public CacheArcIterator<FactorWeightFst<Arc, FactorIterator>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const FactorWeightFst<Arc, FactorIterator> &fst, StateId s)
+ : CacheArcIterator<FactorWeightFst<Arc, FactorIterator>>(
+ fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class Arc, class FactorIterator>
+inline void FactorWeightFst<Arc, FactorIterator>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<FactorWeightFst<Arc, FactorIterator>>(*this);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_FACTOR_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Classes for storing filter state in various algorithms like composition.
+
+#ifndef FST_LIB_FILTER_STATE_H_
+#define FST_LIB_FILTER_STATE_H_
+
+#include <forward_list>
+#include <utility>
+
+#include <fst/fst-decl.h> // For optional argument declarations
+#include <fst/fst.h>
+#include <fst/matcher.h>
+
+
+namespace fst {
+
+// The filter state interface represents the state of a (e.g., composition)
+// filter.
+//
+// class FilterState {
+// public:
+// // Required constructors.
+//
+// FilterState();
+//
+// FilterState(const FilterState &fs);
+//
+// // An invalid filter state.
+// static const FilterState NoState();
+//
+// // Maps state to integer for hashing.
+// size_t Hash() const;
+//
+// // Equality of filter states.
+// bool operator==(const FilterState &fs) const;
+//
+// // Inequality of filter states.
+// bool operator!=(const FilterState &fs) const;
+//
+// // Assignment to filter states.
+// FilterState &operator=(const FilterState& fs);
+// };
+
+// Filter state that is a signed integral type.
+template <typename T>
+class IntegerFilterState {
+ public:
+ IntegerFilterState() : state_(kNoStateId) {}
+
+ explicit IntegerFilterState(T s) : state_(s) {}
+
+ static const IntegerFilterState NoState() { return IntegerFilterState(); }
+
+ size_t Hash() const { return static_cast<size_t>(state_); }
+
+ bool operator==(const IntegerFilterState &fs) const {
+ return state_ == fs.state_;
+ }
+
+ bool operator!=(const IntegerFilterState &fs) const {
+ return state_ != fs.state_;
+ }
+
+ T GetState() const { return state_; }
+
+ void SetState(T state) { state_ = state; }
+
+ private:
+ T state_;
+};
+
+using CharFilterState = IntegerFilterState<signed char>;
+using ShortFilterState = IntegerFilterState<short>; // NOLINT
+using IntFilterState = IntegerFilterState<int>;
+
+// Filter state that is a weight (class).
+template <class W>
+class WeightFilterState {
+ public:
+ WeightFilterState() : weight_(W::Zero()) {}
+
+ explicit WeightFilterState(W weight) : weight_(std::move(weight)) {}
+
+ static const WeightFilterState NoState() { return WeightFilterState(); }
+
+ size_t Hash() const { return weight_.Hash(); }
+
+ bool operator==(const WeightFilterState &fs) const {
+ return weight_ == fs.weight_;
+ }
+
+ bool operator!=(const WeightFilterState &fs) const {
+ return weight_ != fs.weight_;
+ }
+
+ W GetWeight() const { return weight_; }
+
+ void SetWeight(W weight) { weight_ = std::move(weight); }
+
+ private:
+ W weight_;
+};
+
+// Filter state is a list of signed integer types T. Order matters
+// for equality.
+template <typename T>
+class ListFilterState {
+ public:
+ ListFilterState() {}
+
+ explicit ListFilterState(T s) { list_.push_front(s); }
+
+ static const ListFilterState NoState() { return ListFilterState(kNoStateId); }
+
+ size_t Hash() const {
+ size_t h = 0;
+ for (const auto &elem : list_) h ^= h << 1 ^ elem;
+ return h;
+ }
+
+ bool operator==(const ListFilterState &fs) const { return list_ == fs.list_; }
+
+ bool operator!=(const ListFilterState &fs) const { return list_ != fs.list_; }
+
+ const std::forward_list<T> &GetState() const { return list_; }
+
+ std::forward_list<T> *GetMutableState() { return &list_; }
+
+ void SetState(const std::forward_list<T> &state) { list_ = state; }
+
+ private:
+ std::forward_list<T> list_;
+};
+
+// Filter state that is the combination of two filter states.
+template <class FS1, class FS2>
+class PairFilterState {
+ public:
+ PairFilterState() : fs1_(FS1::NoState()), fs2_(FS2::NoState()) {}
+
+ PairFilterState(const FS1 &fs1, const FS2 &fs2) : fs1_(fs1), fs2_(fs2) {}
+
+ static const PairFilterState NoState() { return PairFilterState(); }
+
+ size_t Hash() const {
+ const auto h1 = fs1_.Hash();
+ static constexpr auto lshift = 5;
+ static constexpr auto rshift = CHAR_BIT * sizeof(size_t) - 5;
+ return h1 << lshift ^ h1 >> rshift ^ fs2_.Hash();
+ }
+
+ bool operator==(const PairFilterState &fs) const {
+ return fs1_ == fs.fs1_ && fs2_ == fs.fs2_;
+ }
+
+ bool operator!=(const PairFilterState &fs) const {
+ return fs1_ != fs.fs1_ || fs2_ != fs.fs2_;
+ }
+
+ const FS1 &GetState1() const { return fs1_; }
+
+ const FS2 &GetState2() const { return fs2_; }
+
+ void SetState(const FS1 &fs1, const FS2 &fs2) {
+ fs1_ = fs1;
+ fs2_ = fs2;
+ }
+
+ private:
+ FS1 fs1_;
+ FS2 fs2_;
+};
+
+// Single non-blocking filter state.
+class TrivialFilterState {
+ public:
+ explicit TrivialFilterState(bool state = false) : state_(state) {}
+
+ static const TrivialFilterState NoState() { return TrivialFilterState(); }
+
+ size_t Hash() const { return 0; }
+
+ bool operator==(const TrivialFilterState &fs) const {
+ return state_ == fs.state_;
+ }
+
+ bool operator!=(const TrivialFilterState &fs) const {
+ return state_ != fs.state_;
+ }
+
+ private:
+ bool state_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_FILTER_STATE_H_
--- /dev/null
+// 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.
+//
+// Google-style flag handling declarations and inline definitions.
+
+#ifndef FST_LIB_FLAGS_H_
+#define FST_LIB_FLAGS_H_
+
+#include <cstdlib>
+
+#include <iostream>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+
+#include <fst/types.h>
+#include <fst/lock.h>
+
+using std::string;
+
+// FLAGS USAGE:
+//
+// Definition example:
+//
+// DEFINE_int32(length, 0, "length");
+//
+// This defines variable FLAGS_length, initialized to 0.
+//
+// Declaration example:
+//
+// DECLARE_int32(length);
+//
+// SET_FLAGS() can be used to set flags from the command line
+// using, for example, '--length=2'.
+//
+// ShowUsage() can be used to print out command and flag usage.
+
+#define DECLARE_bool(name) extern bool FLAGS_ ## name
+#define DECLARE_string(name) extern string FLAGS_ ## name
+#define DECLARE_int32(name) extern int32 FLAGS_ ## name
+#define DECLARE_int64(name) extern int64 FLAGS_ ## name
+#define DECLARE_double(name) extern double FLAGS_ ## name
+
+template <typename T>
+struct FlagDescription {
+ FlagDescription(T *addr, const char *doc, const char *type,
+ const char *file, const T val)
+ : address(addr),
+ doc_string(doc),
+ type_name(type),
+ file_name(file),
+ default_value(val) {}
+
+ T *address;
+ const char *doc_string;
+ const char *type_name;
+ const char *file_name;
+ const T default_value;
+};
+
+template <typename T>
+class FlagRegister {
+ public:
+ static FlagRegister<T> *GetRegister() {
+ static auto reg = new FlagRegister<T>;
+ return reg;
+ }
+
+ const FlagDescription<T> &GetFlagDescription(const string &name) const {
+ fst::MutexLock l(&flag_lock_);
+ auto it = flag_table_.find(name);
+ return it != flag_table_.end() ? it->second : 0;
+ }
+
+ void SetDescription(const string &name,
+ const FlagDescription<T> &desc) {
+ fst::MutexLock l(&flag_lock_);
+ flag_table_.insert(make_pair(name, desc));
+ }
+
+ bool SetFlag(const string &val, bool *address) const {
+ if (val == "true" || val == "1" || val.empty()) {
+ *address = true;
+ return true;
+ } else if (val == "false" || val == "0") {
+ *address = false;
+ return true;
+ }
+ else {
+ return false;
+ }
+ }
+
+ bool SetFlag(const string &val, string *address) const {
+ *address = val;
+ return true;
+ }
+
+ bool SetFlag(const string &val, int32 *address) const {
+ char *p = 0;
+ *address = strtol(val.c_str(), &p, 0);
+ return !val.empty() && *p == '\0';
+ }
+
+ bool SetFlag(const string &val, int64 *address) const {
+ char *p = 0;
+ *address = strtoll(val.c_str(), &p, 0);
+ return !val.empty() && *p == '\0';
+ }
+
+ bool SetFlag(const string &val, double *address) const {
+ char *p = 0;
+ *address = strtod(val.c_str(), &p);
+ return !val.empty() && *p == '\0';
+ }
+
+ bool SetFlag(const string &arg, const string &val) const {
+ for (typename std::map< string, FlagDescription<T> >::const_iterator it =
+ flag_table_.begin();
+ it != flag_table_.end();
+ ++it) {
+ const string &name = it->first;
+ const FlagDescription<T> &desc = it->second;
+ if (arg == name)
+ return SetFlag(val, desc.address);
+ }
+ return false;
+ }
+
+ void GetUsage(std::set<std::pair<string, string>> *usage_set) const {
+ for (auto it = flag_table_.begin(); it != flag_table_.end(); ++it) {
+ const string &name = it->first;
+ const FlagDescription<T> &desc = it->second;
+ string usage = " --" + name;
+ usage += ": type = ";
+ usage += desc.type_name;
+ usage += ", default = ";
+ usage += GetDefault(desc.default_value) + "\n ";
+ usage += desc.doc_string;
+ usage_set->insert(make_pair(desc.file_name, usage));
+ }
+ }
+
+ private:
+ string GetDefault(bool default_value) const {
+ return default_value ? "true" : "false";
+ }
+
+ string GetDefault(const string &default_value) const {
+ return "\"" + default_value + "\"";
+ }
+
+ template <class V>
+ string GetDefault(const V &default_value) const {
+ std::ostringstream strm;
+ strm << default_value;
+ return strm.str();
+ }
+
+ mutable fst::Mutex flag_lock_; // Multithreading lock.
+ std::map<string, FlagDescription<T>> flag_table_;
+};
+
+template <typename T>
+class FlagRegisterer {
+ public:
+ FlagRegisterer(const string &name, const FlagDescription<T> &desc) {
+ auto registr = FlagRegister<T>::GetRegister();
+ registr->SetDescription(name, desc);
+ }
+
+ private:
+ FlagRegisterer(const FlagRegisterer &) = delete;
+ FlagRegisterer &operator=(const FlagRegisterer &) = delete;
+};
+
+
+#define DEFINE_VAR(type, name, value, doc) \
+ type FLAGS_ ## name = value; \
+ static FlagRegisterer<type> \
+ name ## _flags_registerer(#name, FlagDescription<type>(&FLAGS_ ## name, \
+ doc, \
+ #type, \
+ __FILE__, \
+ value))
+
+#define DEFINE_bool(name, value, doc) DEFINE_VAR(bool, name, value, doc)
+#define DEFINE_string(name, value, doc) \
+ DEFINE_VAR(string, name, value, doc)
+#define DEFINE_int32(name, value, doc) DEFINE_VAR(int32, name, value, doc)
+#define DEFINE_int64(name, value, doc) DEFINE_VAR(int64, name, value, doc)
+#define DEFINE_double(name, value, doc) DEFINE_VAR(double, name, value, doc)
+
+
+// Temporary directory.
+DECLARE_string(tmpdir);
+
+void SetFlags(const char *usage, int *argc, char ***argv, bool remove_flags,
+ const char *src = "");
+
+#define SET_FLAGS(usage, argc, argv, rmflags) \
+SetFlags(usage, argc, argv, rmflags, __FILE__)
+
+// Deprecated; for backward compatibility.
+inline void InitFst(const char *usage, int *argc, char ***argv, bool rmflags) {
+ return SetFlags(usage, argc, argv, rmflags);
+}
+
+void ShowUsage(bool long_usage = true);
+
+#endif // FST_LIB_FLAGS_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Float weight set and associated semiring operation definitions.
+
+#ifndef FST_LIB_FLOAT_WEIGHT_H_
+#define FST_LIB_FLOAT_WEIGHT_H_
+
+#include <climits>
+#include <cstdlib>
+
+#include <limits>
+#include <sstream>
+#include <string>
+
+#include <fst/util.h>
+#include <fst/weight.h>
+
+
+namespace fst {
+
+// Numeric limits class.
+template <class T>
+class FloatLimits {
+ public:
+ static constexpr T PosInfinity() {
+ return std::numeric_limits<T>::infinity();
+ }
+
+ static constexpr T NegInfinity() { return -PosInfinity(); }
+
+ static constexpr T NumberBad() { return std::numeric_limits<T>::quiet_NaN(); }
+};
+
+// Weight class to be templated on floating-points types.
+template <class T = float>
+class FloatWeightTpl {
+ public:
+ using ValueType = T;
+
+ FloatWeightTpl() {}
+
+ FloatWeightTpl(T f) : value_(f) {}
+
+ FloatWeightTpl(const FloatWeightTpl<T> &weight) : value_(weight.value_) {}
+
+ FloatWeightTpl<T> &operator=(const FloatWeightTpl<T> &weight) {
+ value_ = weight.value_;
+ return *this;
+ }
+
+ std::istream &Read(std::istream &strm) { return ReadType(strm, &value_); }
+
+ std::ostream &Write(std::ostream &strm) const {
+ return WriteType(strm, value_);
+ }
+
+ size_t Hash() const {
+ union {
+ T f;
+ size_t s;
+ } u;
+ u.s = 0;
+ u.f = value_;
+ return u.s;
+ }
+
+ const T &Value() const { return value_; }
+
+ protected:
+ void SetValue(const T &f) { value_ = f; }
+
+ static constexpr const char *GetPrecisionString() {
+ return sizeof(T) == 4
+ ? ""
+ : sizeof(T) == 1
+ ? "8"
+ : sizeof(T) == 2 ? "16"
+ : sizeof(T) == 8 ? "64" : "unknown";
+ }
+
+ private:
+ T value_;
+};
+
+// Single-precision float weight.
+using FloatWeight = FloatWeightTpl<float>;
+
+template <class T>
+inline bool operator==(const FloatWeightTpl<T> &w1,
+ const FloatWeightTpl<T> &w2) {
+ // Volatile qualifier thwarts over-aggressive compiler optimizations that
+ // lead to problems esp. with NaturalLess().
+ volatile T v1 = w1.Value();
+ volatile T v2 = w2.Value();
+ return v1 == v2;
+}
+
+inline bool operator==(const FloatWeightTpl<double> &w1,
+ const FloatWeightTpl<double> &w2) {
+ return operator==<double>(w1, w2);
+}
+
+inline bool operator==(const FloatWeightTpl<float> &w1,
+ const FloatWeightTpl<float> &w2) {
+ return operator==<float>(w1, w2);
+}
+
+template <class T>
+inline bool operator!=(const FloatWeightTpl<T> &w1,
+ const FloatWeightTpl<T> &w2) {
+ return !(w1 == w2);
+}
+
+inline bool operator!=(const FloatWeightTpl<double> &w1,
+ const FloatWeightTpl<double> &w2) {
+ return operator!=<double>(w1, w2);
+}
+
+inline bool operator!=(const FloatWeightTpl<float> &w1,
+ const FloatWeightTpl<float> &w2) {
+ return operator!=<float>(w1, w2);
+}
+
+template <class T>
+inline bool ApproxEqual(const FloatWeightTpl<T> &w1,
+ const FloatWeightTpl<T> &w2, float delta = kDelta) {
+ return w1.Value() <= w2.Value() + delta && w2.Value() <= w1.Value() + delta;
+}
+
+template <class T>
+inline std::ostream &operator<<(std::ostream &strm,
+ const FloatWeightTpl<T> &w) {
+ if (w.Value() == FloatLimits<T>::PosInfinity()) {
+ return strm << "Infinity";
+ } else if (w.Value() == FloatLimits<T>::NegInfinity()) {
+ return strm << "-Infinity";
+ } else if (w.Value() != w.Value()) { // Fails for NaN.
+ return strm << "BadNumber";
+ } else {
+ return strm << w.Value();
+ }
+}
+
+template <class T>
+inline std::istream &operator>>(std::istream &strm, FloatWeightTpl<T> &w) {
+ string s;
+ strm >> s;
+ if (s == "Infinity") {
+ w = FloatWeightTpl<T>(FloatLimits<T>::PosInfinity());
+ } else if (s == "-Infinity") {
+ w = FloatWeightTpl<T>(FloatLimits<T>::NegInfinity());
+ } else {
+ char *p;
+ T f = strtod(s.c_str(), &p);
+ if (p < s.c_str() + s.size()) {
+ strm.clear(std::ios::badbit);
+ } else {
+ w = FloatWeightTpl<T>(f);
+ }
+ }
+ return strm;
+}
+
+// Tropical semiring: (min, +, inf, 0).
+template <class T>
+class TropicalWeightTpl : public FloatWeightTpl<T> {
+ public:
+ using typename FloatWeightTpl<T>::ValueType;
+ using FloatWeightTpl<T>::Value;
+ using ReverseWeight = TropicalWeightTpl<T>;
+
+ constexpr TropicalWeightTpl() : FloatWeightTpl<T>() {}
+
+ constexpr TropicalWeightTpl(T f) : FloatWeightTpl<T>(f) {}
+
+ constexpr TropicalWeightTpl(const TropicalWeightTpl<T> &weight)
+ : FloatWeightTpl<T>(weight) {}
+
+ static const TropicalWeightTpl<T> &Zero() {
+ static const TropicalWeightTpl zero(FloatLimits<T>::PosInfinity());
+ return zero;
+ }
+
+ static const TropicalWeightTpl<T> &One() {
+ static const TropicalWeightTpl one(0.0F);
+ return one;
+ }
+
+ static const TropicalWeightTpl<T> &NoWeight() {
+ static const TropicalWeightTpl no_weight(FloatLimits<T>::NumberBad());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type =
+ string("tropical") + FloatWeightTpl<T>::GetPrecisionString();
+ return type;
+ }
+
+ bool Member() const {
+ // First part fails for IEEE NaN.
+ return Value() == Value() && Value() != FloatLimits<T>::NegInfinity();
+ }
+
+ TropicalWeightTpl<T> Quantize(float delta = kDelta) const {
+ if (Value() == FloatLimits<T>::NegInfinity() ||
+ Value() == FloatLimits<T>::PosInfinity() || Value() != Value()) {
+ return *this;
+ } else {
+ return TropicalWeightTpl<T>(floor(Value() / delta + 0.5F) * delta);
+ }
+ }
+
+ TropicalWeightTpl<T> Reverse() const { return *this; }
+
+ static constexpr uint64 Properties() {
+ return kLeftSemiring | kRightSemiring | kCommutative | kPath | kIdempotent;
+ }
+};
+
+// Single precision tropical weight.
+using TropicalWeight = TropicalWeightTpl<float>;
+
+template <class T>
+inline TropicalWeightTpl<T> Plus(const TropicalWeightTpl<T> &w1,
+ const TropicalWeightTpl<T> &w2) {
+ if (!w1.Member() || !w2.Member()) return TropicalWeightTpl<T>::NoWeight();
+ return w1.Value() < w2.Value() ? w1 : w2;
+}
+
+inline TropicalWeightTpl<float> Plus(const TropicalWeightTpl<float> &w1,
+ const TropicalWeightTpl<float> &w2) {
+ return Plus<float>(w1, w2);
+}
+
+inline TropicalWeightTpl<double> Plus(const TropicalWeightTpl<double> &w1,
+ const TropicalWeightTpl<double> &w2) {
+ return Plus<double>(w1, w2);
+}
+
+template <class T>
+inline TropicalWeightTpl<T> Times(const TropicalWeightTpl<T> &w1,
+ const TropicalWeightTpl<T> &w2) {
+ if (!w1.Member() || !w2.Member()) return TropicalWeightTpl<T>::NoWeight();
+ T f1 = w1.Value(), f2 = w2.Value();
+ if (f1 == FloatLimits<T>::PosInfinity()) {
+ return w1;
+ } else if (f2 == FloatLimits<T>::PosInfinity()) {
+ return w2;
+ } else {
+ return TropicalWeightTpl<T>(f1 + f2);
+ }
+}
+
+inline TropicalWeightTpl<float> Times(const TropicalWeightTpl<float> &w1,
+ const TropicalWeightTpl<float> &w2) {
+ return Times<float>(w1, w2);
+}
+
+inline TropicalWeightTpl<double> Times(const TropicalWeightTpl<double> &w1,
+ const TropicalWeightTpl<double> &w2) {
+ return Times<double>(w1, w2);
+}
+
+template <class T>
+inline TropicalWeightTpl<T> Divide(const TropicalWeightTpl<T> &w1,
+ const TropicalWeightTpl<T> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ if (!w1.Member() || !w2.Member()) return TropicalWeightTpl<T>::NoWeight();
+ T f1 = w1.Value(), f2 = w2.Value();
+ if (f2 == FloatLimits<T>::PosInfinity()) {
+ return FloatLimits<T>::NumberBad();
+ } else if (f1 == FloatLimits<T>::PosInfinity()) {
+ return FloatLimits<T>::PosInfinity();
+ } else {
+ return TropicalWeightTpl<T>(f1 - f2);
+ }
+}
+
+inline TropicalWeightTpl<float> Divide(const TropicalWeightTpl<float> &w1,
+ const TropicalWeightTpl<float> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ return Divide<float>(w1, w2, typ);
+}
+
+inline TropicalWeightTpl<double> Divide(const TropicalWeightTpl<double> &w1,
+ const TropicalWeightTpl<double> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ return Divide<double>(w1, w2, typ);
+}
+
+template <class T>
+inline TropicalWeightTpl<T> Power(const TropicalWeightTpl<T> &weight,
+ T scalar) {
+ return TropicalWeightTpl<T>(weight.Value() * scalar);
+}
+
+// Log semiring: (log(e^-x + e^-y), +, inf, 0).
+template <class T>
+class LogWeightTpl : public FloatWeightTpl<T> {
+ public:
+ using typename FloatWeightTpl<T>::ValueType;
+ using FloatWeightTpl<T>::Value;
+ using ReverseWeight = LogWeightTpl;
+
+ constexpr LogWeightTpl() : FloatWeightTpl<T>() {}
+
+ constexpr LogWeightTpl(T f) : FloatWeightTpl<T>(f) {}
+
+ constexpr LogWeightTpl(const LogWeightTpl<T> &weight)
+ : FloatWeightTpl<T>(weight) {}
+
+ static const LogWeightTpl &Zero() {
+ static const LogWeightTpl zero(FloatLimits<T>::PosInfinity());
+ return zero;
+ }
+
+ static const LogWeightTpl &One() {
+ static const LogWeightTpl one(0.0F);
+ return one;
+ }
+
+ static const LogWeightTpl &NoWeight() {
+ static const LogWeightTpl no_weight(FloatLimits<T>::NumberBad());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type =
+ string("log") + FloatWeightTpl<T>::GetPrecisionString();
+ return type;
+ }
+
+ bool Member() const {
+ // First part fails for IEEE NaN.
+ return Value() == Value() && Value() != FloatLimits<T>::NegInfinity();
+ }
+
+ LogWeightTpl<T> Quantize(float delta = kDelta) const {
+ if (Value() == FloatLimits<T>::NegInfinity() ||
+ Value() == FloatLimits<T>::PosInfinity() || Value() != Value()) {
+ return *this;
+ } else {
+ return LogWeightTpl<T>(floor(Value() / delta + 0.5F) * delta);
+ }
+ }
+
+ LogWeightTpl<T> Reverse() const { return *this; }
+
+ static constexpr uint64 Properties() {
+ return kLeftSemiring | kRightSemiring | kCommutative;
+ }
+};
+
+// Single-precision log weight.
+using LogWeight = LogWeightTpl<float>;
+
+// Double-precision log weight.
+using Log64Weight = LogWeightTpl<double>;
+
+template <class T>
+inline T LogExp(T x) {
+ return log(1.0F + exp(-x));
+}
+
+template <class T>
+inline LogWeightTpl<T> Plus(const LogWeightTpl<T> &w1,
+ const LogWeightTpl<T> &w2) {
+ T f1 = w1.Value(), f2 = w2.Value();
+ if (f1 == FloatLimits<T>::PosInfinity()) {
+ return w2;
+ } else if (f2 == FloatLimits<T>::PosInfinity()) {
+ return w1;
+ } else if (f1 > f2) {
+ return LogWeightTpl<T>(f2 - LogExp(f1 - f2));
+ } else {
+ return LogWeightTpl<T>(f1 - LogExp(f2 - f1));
+ }
+}
+
+inline LogWeightTpl<float> Plus(const LogWeightTpl<float> &w1,
+ const LogWeightTpl<float> &w2) {
+ return Plus<float>(w1, w2);
+}
+
+inline LogWeightTpl<double> Plus(const LogWeightTpl<double> &w1,
+ const LogWeightTpl<double> &w2) {
+ return Plus<double>(w1, w2);
+}
+
+template <class T>
+inline LogWeightTpl<T> Times(const LogWeightTpl<T> &w1,
+ const LogWeightTpl<T> &w2) {
+ if (!w1.Member() || !w2.Member()) return LogWeightTpl<T>::NoWeight();
+ T f1 = w1.Value(), f2 = w2.Value();
+ if (f1 == FloatLimits<T>::PosInfinity()) {
+ return w1;
+ } else if (f2 == FloatLimits<T>::PosInfinity()) {
+ return w2;
+ } else {
+ return LogWeightTpl<T>(f1 + f2);
+ }
+}
+
+inline LogWeightTpl<float> Times(const LogWeightTpl<float> &w1,
+ const LogWeightTpl<float> &w2) {
+ return Times<float>(w1, w2);
+}
+
+inline LogWeightTpl<double> Times(const LogWeightTpl<double> &w1,
+ const LogWeightTpl<double> &w2) {
+ return Times<double>(w1, w2);
+}
+
+template <class T>
+inline LogWeightTpl<T> Divide(const LogWeightTpl<T> &w1,
+ const LogWeightTpl<T> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ if (!w1.Member() || !w2.Member()) return LogWeightTpl<T>::NoWeight();
+ T f1 = w1.Value(), f2 = w2.Value();
+ if (f2 == FloatLimits<T>::PosInfinity()) {
+ return FloatLimits<T>::NumberBad();
+ } else if (f1 == FloatLimits<T>::PosInfinity()) {
+ return FloatLimits<T>::PosInfinity();
+ } else {
+ return LogWeightTpl<T>(f1 - f2);
+ }
+}
+
+inline LogWeightTpl<float> Divide(const LogWeightTpl<float> &w1,
+ const LogWeightTpl<float> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ return Divide<float>(w1, w2, typ);
+}
+
+inline LogWeightTpl<double> Divide(const LogWeightTpl<double> &w1,
+ const LogWeightTpl<double> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ return Divide<double>(w1, w2, typ);
+}
+
+template <class T>
+inline LogWeightTpl<T> Power(const LogWeightTpl<T> &weight, T scalar) {
+ return LogWeightTpl<T>(weight.Value() * scalar);
+}
+
+// MinMax semiring: (min, max, inf, -inf).
+template <class T>
+class MinMaxWeightTpl : public FloatWeightTpl<T> {
+ public:
+ using typename FloatWeightTpl<T>::ValueType;
+ using FloatWeightTpl<T>::Value;
+
+ using ReverseWeight = MinMaxWeightTpl<T>;
+
+ MinMaxWeightTpl() : FloatWeightTpl<T>() {}
+
+ MinMaxWeightTpl(T f) : FloatWeightTpl<T>(f) {}
+
+ MinMaxWeightTpl(const MinMaxWeightTpl<T> &weight)
+ : FloatWeightTpl<T>(weight) {}
+
+ static const MinMaxWeightTpl &Zero() {
+ static const MinMaxWeightTpl zero(FloatLimits<T>::PosInfinity());
+ return zero;
+ }
+
+ static const MinMaxWeightTpl &One() {
+ static const MinMaxWeightTpl one(FloatLimits<T>::NegInfinity());
+ return one;
+ }
+
+ static const MinMaxWeightTpl &NoWeight() {
+ static const MinMaxWeightTpl no_weight(FloatLimits<T>::NumberBad());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type =
+ string("minmax") + FloatWeightTpl<T>::GetPrecisionString();
+ return type;
+ }
+
+ bool Member() const {
+ // Fails for IEEE NaN
+ return Value() == Value();
+ }
+
+ MinMaxWeightTpl<T> Quantize(float delta = kDelta) const {
+ // If one of infinities, or a NaN
+ if (Value() == FloatLimits<T>::NegInfinity() ||
+ Value() == FloatLimits<T>::PosInfinity() || Value() != Value()) {
+ return *this;
+ } else {
+ return MinMaxWeightTpl<T>(floor(Value() / delta + 0.5F) * delta);
+ }
+ }
+
+ MinMaxWeightTpl<T> Reverse() const { return *this; }
+
+ static constexpr uint64 Properties() {
+ return kLeftSemiring | kRightSemiring | kCommutative | kIdempotent | kPath;
+ }
+};
+
+// Single-precision min-max weight.
+using MinMaxWeight = MinMaxWeightTpl<float>;
+
+// Min.
+template <class T>
+inline MinMaxWeightTpl<T> Plus(const MinMaxWeightTpl<T> &w1,
+ const MinMaxWeightTpl<T> &w2) {
+ if (!w1.Member() || !w2.Member()) return MinMaxWeightTpl<T>::NoWeight();
+ return w1.Value() < w2.Value() ? w1 : w2;
+}
+
+inline MinMaxWeightTpl<float> Plus(const MinMaxWeightTpl<float> &w1,
+ const MinMaxWeightTpl<float> &w2) {
+ return Plus<float>(w1, w2);
+}
+
+inline MinMaxWeightTpl<double> Plus(const MinMaxWeightTpl<double> &w1,
+ const MinMaxWeightTpl<double> &w2) {
+ return Plus<double>(w1, w2);
+}
+
+// Max.
+template <class T>
+inline MinMaxWeightTpl<T> Times(const MinMaxWeightTpl<T> &w1,
+ const MinMaxWeightTpl<T> &w2) {
+ if (!w1.Member() || !w2.Member()) return MinMaxWeightTpl<T>::NoWeight();
+ return w1.Value() >= w2.Value() ? w1 : w2;
+}
+
+inline MinMaxWeightTpl<float> Times(const MinMaxWeightTpl<float> &w1,
+ const MinMaxWeightTpl<float> &w2) {
+ return Times<float>(w1, w2);
+}
+
+inline MinMaxWeightTpl<double> Times(const MinMaxWeightTpl<double> &w1,
+ const MinMaxWeightTpl<double> &w2) {
+ return Times<double>(w1, w2);
+}
+
+// Defined only for special cases.
+template <class T>
+inline MinMaxWeightTpl<T> Divide(const MinMaxWeightTpl<T> &w1,
+ const MinMaxWeightTpl<T> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ if (!w1.Member() || !w2.Member()) return MinMaxWeightTpl<T>::NoWeight();
+ // min(w1, x) = w2, w1 >= w2 => min(w1, x) = w2, x = w2.
+ return w1.Value() >= w2.Value() ? w1 : FloatLimits<T>::NumberBad();
+}
+
+inline MinMaxWeightTpl<float> Divide(const MinMaxWeightTpl<float> &w1,
+ const MinMaxWeightTpl<float> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ return Divide<float>(w1, w2, typ);
+}
+
+inline MinMaxWeightTpl<double> Divide(const MinMaxWeightTpl<double> &w1,
+ const MinMaxWeightTpl<double> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ return Divide<double>(w1, w2, typ);
+}
+
+// Converts to tropical.
+template <>
+struct WeightConvert<LogWeight, TropicalWeight> {
+ TropicalWeight operator()(const LogWeight &w) const { return w.Value(); }
+};
+
+template <>
+struct WeightConvert<Log64Weight, TropicalWeight> {
+ TropicalWeight operator()(const Log64Weight &w) const { return w.Value(); }
+};
+
+// Converts to log.
+template <>
+struct WeightConvert<TropicalWeight, LogWeight> {
+ LogWeight operator()(const TropicalWeight &w) const { return w.Value(); }
+};
+
+template <>
+struct WeightConvert<Log64Weight, LogWeight> {
+ LogWeight operator()(const Log64Weight &w) const { return w.Value(); }
+};
+
+// Converts to log64.
+template <>
+struct WeightConvert<TropicalWeight, Log64Weight> {
+ Log64Weight operator()(const TropicalWeight &w) const { return w.Value(); }
+};
+
+template <>
+struct WeightConvert<LogWeight, Log64Weight> {
+ Log64Weight operator()(const LogWeight &w) const { return w.Value(); }
+};
+
+// This function object returns random integers chosen from [0,
+// num_random_weights). The boolean 'allow_zero' determines whether Zero() and
+// zero divisors should be returned in the random weight generation. This is
+// intended primary for testing.
+template <class Weight>
+class FloatWeightGenerate {
+ public:
+ explicit FloatWeightGenerate(
+ bool allow_zero = true,
+ const size_t num_random_weights = kNumRandomWeights)
+ : allow_zero_(allow_zero), num_random_weights_(num_random_weights) {}
+
+ Weight operator()() const {
+ int n = rand() % (num_random_weights_ + allow_zero_); // NOLINT
+ if (allow_zero_ && n == num_random_weights_) return Weight::Zero();
+ return Weight(n);
+ }
+
+ private:
+ // Permits Zero() and zero divisors.
+ bool allow_zero_;
+ // Number of alternative random weights.
+ const size_t num_random_weights_;
+};
+
+template <class T>
+class WeightGenerate<TropicalWeightTpl<T>>
+ : public FloatWeightGenerate<TropicalWeightTpl<T>> {
+ public:
+ using Weight = TropicalWeightTpl<T>;
+ using Generate = FloatWeightGenerate<Weight>;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t num_random_weights = kNumRandomWeights)
+ : Generate(allow_zero, num_random_weights) {}
+
+ Weight operator()() const { return Weight(Generate::operator()()); }
+};
+
+template <class T>
+class WeightGenerate<LogWeightTpl<T>>
+ : public FloatWeightGenerate<LogWeightTpl<T>> {
+ public:
+ using Weight = LogWeightTpl<T>;
+ using Generate = FloatWeightGenerate<Weight>;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t num_random_weights = kNumRandomWeights)
+ : Generate(allow_zero, num_random_weights) {}
+
+ Weight operator()() const { return Weight(Generate::operator()()); }
+};
+
+// This function object returns random integers chosen from [0,
+// num_random_weights). The boolean 'allow_zero' determines whether Zero() and
+// zero divisors should be returned in the random weight generation. This is
+// intended primary for testing.
+template <class T>
+class WeightGenerate<MinMaxWeightTpl<T>> {
+ public:
+ using Weight = MinMaxWeightTpl<T>;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t num_random_weights = kNumRandomWeights)
+ : allow_zero_(allow_zero), num_random_weights_(num_random_weights) {}
+
+ Weight operator()() const {
+ int n = (rand() % (2 * num_random_weights_ + allow_zero_)) - // NOLINT
+ num_random_weights_;
+ if (allow_zero_ && n == num_random_weights_) {
+ return Weight::Zero();
+ } else if (n == -num_random_weights_) {
+ return Weight::One();
+ } else {
+ return Weight(n);
+ }
+ }
+
+ private:
+ // Permits Zero() and zero divisors.
+ bool allow_zero_;
+ // Number of alternative random weights.
+ const size_t num_random_weights_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_FLOAT_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// This file contains declarations of classes in the Fst template library.
+
+#ifndef FST_LIB_FST_DECL_H_
+#define FST_LIB_FST_DECL_H_
+
+#include <sys/types.h>
+#include <memory> // for allocator<>
+
+#include <fst/types.h>
+
+namespace fst {
+
+// Symbol table and iterator.
+
+class SymbolTable;
+
+class SymbolTableIterator;
+
+// Weight templates and weights.
+
+template <class T>
+class FloatWeightTpl;
+
+template <class T>
+class TropicalWeightTpl;
+
+template <class T>
+class LogWeightTpl;
+
+template <class T>
+class MinMaxWeightTpl;
+
+using FloatWeight = FloatWeightTpl<float>;
+
+using TropicalWeight = TropicalWeightTpl<float>;
+
+using LogWeight = LogWeightTpl<float>;
+
+using MinMaxWeight = MinMaxWeightTpl<float>;
+
+// Arc templates and arcs.
+
+template <class Weight>
+class ArcTpl;
+
+using StdArc = ArcTpl<TropicalWeight>;
+
+using LogArc = ArcTpl<LogWeight>;
+
+// Stores.
+
+template <class Element, class U>
+class DefaultCompactStore;
+
+template <class Arc>
+class DefaultCacheStore;
+
+// FST templates.
+
+template <class Arc, class Compactor, class U = uint32,
+ class CompactStore = DefaultCompactStore<typename Compactor::Element, U>,
+ class CacheStore = DefaultCacheStore<Arc>>
+class CompactFst;
+
+template <class Arc, class U = uint32>
+class ConstFst;
+
+template <class Arc, class Weight, class Matcher>
+class EditFst;
+
+template <class Arc>
+class ExpandedFst;
+
+template <class Arc>
+class Fst;
+
+template <class Arc>
+class MutableFst;
+
+template <class Arc, class Allocator = std::allocator<Arc>>
+class VectorState;
+
+template <class Arc, class State = VectorState<Arc>>
+class VectorFst;
+
+template <class Arc, class U = ssize_t>
+class DefaultReplaceStateTable;
+
+// On-the-fly operations.
+
+template <class Arc, class Compare>
+class ArcSortFst;
+
+template <class Arc>
+class ClosureFst;
+
+template <class Arc, class Store = DefaultCacheStore<Arc>>
+class ComposeFst;
+
+template <class Arc>
+class ConcatFst;
+
+template <class Arc>
+class DeterminizeFst;
+
+template <class Arc>
+class DifferenceFst;
+
+template <class Arc>
+class IntersectFst;
+
+template <class Arc>
+class InvertFst;
+
+template <class AArc, class BArc, class Mapper>
+class ArcMapFst;
+
+template <class Arc>
+class ProjectFst;
+
+template <class AArc, class BArc, class Selector>
+class RandGenFst;
+
+template <class Arc>
+class RelabelFst;
+
+template <class Arc, class StateTable = DefaultReplaceStateTable<Arc>,
+ class Store = DefaultCacheStore<Arc>>
+class ReplaceFst;
+
+template <class Arc>
+class RmEpsilonFst;
+
+template <class Arc>
+class UnionFst;
+
+// Heap.
+
+template <class T, class Compare>
+class Heap;
+
+// Compactors.
+
+template <class Arc>
+class AcceptorCompactor;
+
+template <class Arc>
+class StringCompactor;
+
+template <class Arc>
+class UnweightedAcceptorCompactor;
+
+template <class Arc>
+class UnweightedCompactor;
+
+template <class Arc>
+class WeightedStringCompactor;
+
+// Compact FSTs.
+
+template <class Arc, class U = uint32>
+using CompactStringFst = CompactFst<Arc, StringCompactor<Arc>, U>;
+
+template <class Arc, class U = uint32>
+using CompactWeightedStringFst =
+ CompactFst<Arc, WeightedStringCompactor<Arc>, U>;
+
+template <class Arc, class U = uint32>
+using CompactAcceptorFst = CompactFst<Arc, AcceptorCompactor<Arc>, U>;
+
+template <class Arc, class U = uint32>
+using CompactUnweightedFst = CompactFst<Arc, UnweightedCompactor<Arc>, U>;
+
+template <class Arc, class U = uint32>
+using CompactUnweightedAcceptorFst =
+ CompactFst<Arc, UnweightedAcceptorCompactor<Arc>, U>;
+
+// StdArc aliases for FSTs.
+
+using StdConstFst = ConstFst<StdArc>;
+using StdExpandedFst = ExpandedFst<StdArc>;
+using StdFst = Fst<StdArc>;
+using StdMutableFst = MutableFst<StdArc>;
+using StdVectorFst = VectorFst<StdArc>;
+
+// StdArc aliases for on-the-fly operations.
+
+template <class Compare>
+using StdArcSortFst = ArcSortFst<StdArc, Compare>;
+
+using StdClosureFst = ClosureFst<StdArc>;
+
+using StdComposeFst = ComposeFst<StdArc>;
+
+using StdConcatFst = ConcatFst<StdArc>;
+
+using StdDeterminizeFst = DeterminizeFst<StdArc>;
+
+using StdDifferenceFst = DifferenceFst<StdArc>;
+
+using StdIntersectFst = IntersectFst<StdArc>;
+
+using StdInvertFst = InvertFst<StdArc>;
+
+using StdProjectFst = ProjectFst<StdArc>;
+
+using StdRelabelFst = RelabelFst<StdArc>;
+
+using StdReplaceFst = ReplaceFst<StdArc>;
+
+using StdRmEpsilonFst = RmEpsilonFst<StdArc>;
+
+using StdUnionFst = UnionFst<StdArc>;
+
+// Filter states.
+
+template <class T>
+class IntegerFilterState;
+
+using CharFilterState = IntegerFilterState<signed char>;
+
+using ShortFilterState = IntegerFilterState<short>; // NOLINT
+
+using IntFilterState = IntegerFilterState<int>;
+
+// Matchers and filters.
+
+template <class FST>
+class Matcher;
+
+template <class Matcher1, class Matcher2 = Matcher1>
+class NullComposeFilter;
+
+template <class Matcher1, class Matcher2 = Matcher1>
+class TrivialComposeFilter;
+
+template <class Matcher1, class Matcher2 = Matcher1>
+class SequenceComposeFilter;
+
+template <class Matcher1, class Matcher2 = Matcher1>
+class AltSequenceComposeFilter;
+
+template <class Matcher1, class Matcher2 = Matcher1>
+class MatchComposeFilter;
+
+} // namespace fst
+
+#endif // FST_LIB_FST_DECL_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// FST abstract base class definition, state and arc iterator interface, and
+// suggested base implementation.
+
+#ifndef FST_LIB_FST_H_
+#define FST_LIB_FST_H_
+
+#include <sys/types.h>
+
+#include <cmath>
+#include <cstddef>
+
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include <fst/compat.h>
+#include <fst/types.h>
+#include <fstream>
+
+#include <fst/arc.h>
+#include <fst/memory.h>
+#include <fst/properties.h>
+#include <fst/register.h>
+#include <fst/symbol-table.h>
+#include <fst/util.h>
+
+
+DECLARE_bool(fst_align);
+
+namespace fst {
+
+bool IsFstHeader(std::istream &, const string &);
+
+class FstHeader;
+template <class Arc>
+
+struct StateIteratorData;
+template <class Arc>
+
+struct ArcIteratorData;
+
+template <class Arc>
+class MatcherBase;
+
+struct FstReadOptions {
+ // FileReadMode(s) are advisory, there are many conditions than prevent a
+ // file from being mapped, READ mode will be selected in these cases with
+ // a warning indicating why it was chosen.
+ enum FileReadMode { READ, MAP };
+
+ string source; // Where you're reading from.
+ const FstHeader *header; // Pointer to FST header; if non-zero, use
+ // this info (don't read a stream header).
+ const SymbolTable *isymbols; // Pointer to input symbols; if non-zero, use
+ // this info (read and skip stream isymbols)
+ const SymbolTable *osymbols; // Pointer to output symbols; if non-zero, use
+ // this info (read and skip stream osymbols)
+ FileReadMode mode; // Read or map files (advisory, if possible)
+ bool read_isymbols; // Read isymbols, if any (default: true).
+ bool read_osymbols; // Read osymbols, if any (default: true).
+
+ explicit FstReadOptions(const string &source = "<unspecified>",
+ const FstHeader *header = nullptr,
+ const SymbolTable *isymbols = nullptr,
+ const SymbolTable *osymbols = nullptr);
+
+ explicit FstReadOptions(const string &source, const SymbolTable *isymbols,
+ const SymbolTable *osymbols = nullptr);
+
+ // Helper function to convert strings FileReadModes into their enum value.
+ static FileReadMode ReadMode(const string &mode);
+
+ // Outputs a debug string for the FstReadOptions object.
+ string DebugString() const;
+};
+
+struct FstWriteOptions {
+ string source; // Where you're writing to.
+ bool write_header; // Write the header?
+ bool write_isymbols; // Write input symbols?
+ bool write_osymbols; // Write output symbols?
+ bool align; // Write data aligned (may fail on pipes)?
+ bool stream_write; // Avoid seek operations in writing.
+
+ explicit FstWriteOptions(const string &source = "<unspecifed>",
+ bool write_header = true, bool write_isymbols = true,
+ bool write_osymbols = true,
+ bool align = FLAGS_fst_align,
+ bool stream_write = false)
+ : source(source),
+ write_header(write_header),
+ write_isymbols(write_isymbols),
+ write_osymbols(write_osymbols),
+ align(align),
+ stream_write(stream_write) {}
+};
+
+// Header class.
+//
+// This is the recommended file header representation.
+
+class FstHeader {
+ public:
+ enum {
+ HAS_ISYMBOLS = 0x1, // Has input symbol table.
+ HAS_OSYMBOLS = 0x2, // Has output symbol table.
+ IS_ALIGNED = 0x4, // Memory-aligned (where appropriate).
+ } Flags;
+
+ FstHeader() : version_(0), flags_(0), properties_(0), start_(-1),
+ numstates_(0), numarcs_(0) {}
+
+ const string &FstType() const { return fsttype_; }
+
+ const string &ArcType() const { return arctype_; }
+
+ int32 Version() const { return version_; }
+
+ int32 GetFlags() const { return flags_; }
+
+ uint64 Properties() const { return properties_; }
+
+ int64 Start() const { return start_; }
+
+ int64 NumStates() const { return numstates_; }
+
+ int64 NumArcs() const { return numarcs_; }
+
+ void SetFstType(const string &type) { fsttype_ = type; }
+
+ void SetArcType(const string &type) { arctype_ = type; }
+
+ void SetVersion(int32 version) { version_ = version; }
+
+ void SetFlags(int32 flags) { flags_ = flags; }
+
+ void SetProperties(uint64 properties) { properties_ = properties; }
+
+ void SetStart(int64 start) { start_ = start; }
+
+ void SetNumStates(int64 numstates) { numstates_ = numstates; }
+
+ void SetNumArcs(int64 numarcs) { numarcs_ = numarcs; }
+
+ bool Read(std::istream &strm, const string &source,
+ bool rewind = false);
+
+ bool Write(std::ostream &strm, const string &source) const;
+
+ // Outputs a debug string for the FstHeader object.
+ string DebugString() const;
+
+ private:
+ string fsttype_; // E.g. "vector".
+ string arctype_; // E.g. "standard".
+ int32 version_; // Type version number.
+ int32 flags_; // File format bits.
+ uint64 properties_; // FST property bits.
+ int64 start_; // Start state.
+ int64 numstates_; // # of states.
+ int64 numarcs_; // # of arcs.
+};
+
+// Specifies matcher action.
+enum MatchType {
+ MATCH_INPUT = 1, // Match input label.
+ MATCH_OUTPUT = 2, // Match output label.
+ MATCH_BOTH = 3, // Match input or output label.
+ MATCH_NONE = 4, // Match nothing.
+ MATCH_UNKNOWN = 5
+}; // Otherwise, match type unknown.
+
+constexpr int kNoStateId = -1; // Not a valid state ID.
+constexpr int kNoLabel = -1; // Not a valid label.
+
+// A generic FST, templated on the arc definition, with common-demoninator
+// methods (use StateIterator and ArcIterator to iterate over its states and
+// arcs).
+template <class A>
+class Fst {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ virtual ~Fst() {}
+
+ // Initial state.
+ virtual StateId Start() const = 0;
+
+ // State's final weight.
+ virtual Weight Final(StateId) const = 0;
+
+ // State's arc count.
+ virtual size_t NumArcs(StateId) const = 0;
+
+ // State's input epsilon count.
+ virtual size_t NumInputEpsilons(StateId) const = 0;
+
+ // State's output epsilon count.
+ virtual size_t NumOutputEpsilons(StateId) const = 0;
+
+ // Property bits. If test = false, return stored properties bits for mask
+ // (some possibly unknown); if test = true, return property bits for mask
+ // (computing o.w. unknown).
+ virtual uint64 Properties(uint64 mask, bool test) const = 0;
+
+ // FST type name.
+ virtual const string &Type() const = 0;
+
+ // Gets a copy of this Fst. The copying behaves as follows:
+ //
+ // (1) The copying is constant time if safe = false or if safe = true
+ // and is on an otherwise unaccessed FST.
+ //
+ // (2) If safe = true, the copy is thread-safe in that the original
+ // and copy can be safely accessed (but not necessarily mutated) by
+ // separate threads. For some FST types, 'Copy(true)' should only be
+ // called on an FST that has not otherwise been accessed. Behavior is
+ // otherwise undefined.
+ //
+ // (3) If a MutableFst is copied and then mutated, then the original is
+ // unmodified and vice versa (often by a copy-on-write on the initial
+ // mutation, which may not be constant time).
+ virtual Fst<Arc> *Copy(bool safe = false) const = 0;
+
+ // Reads an FST from an input stream; returns nullptr on error.
+ static Fst<Arc> *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;
+ }
+ const auto &fst_type = hdr.FstType();
+ const auto reader = FstRegister<Arc>::GetRegister()->GetReader(fst_type);
+ if (!reader) {
+ LOG(ERROR) << "Fst::Read: Unknown FST type " << fst_type
+ << " (arc type = " << Arc::Type() << "): " << ropts.source;
+ return nullptr;
+ }
+ return reader(strm, ropts);
+ }
+
+ // Reads an FST from a file; returns nullptr on error. An empty filename
+ // results in reading from standard input.
+ static Fst<Arc> *Read(const string &filename) {
+ if (!filename.empty()) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "Fst::Read: Can't open file: " << filename;
+ return nullptr;
+ }
+ return Read(strm, FstReadOptions(filename));
+ } else {
+ return Read(std::cin, FstReadOptions("standard input"));
+ }
+ }
+
+ // Writes an FST to an output stream; returns false on error.
+ virtual bool Write(std::ostream &strm, const FstWriteOptions &opts) const {
+ LOG(ERROR) << "Fst::Write: No write stream method for " << Type()
+ << " FST type";
+ return false;
+ }
+
+ // Writes an FST to a file; returns false on error; an empty filename
+ // results in writing to standard output.
+ virtual bool Write(const string &filename) const {
+ LOG(ERROR) << "Fst::Write: No write filename method for " << Type()
+ << " FST type";
+ return false;
+ }
+
+ // Returns input label symbol table; return nullptr if not specified.
+ virtual const SymbolTable *InputSymbols() const = 0;
+
+ // Return output label symbol table; return nullptr if not specified.
+ virtual const SymbolTable *OutputSymbols() const = 0;
+
+ // For generic state iterator construction (not normally called directly by
+ // users).
+ virtual void InitStateIterator(StateIteratorData<Arc> *data) const = 0;
+
+ // For generic arc iterator construction (not normally called directly by
+ // users).
+ virtual void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const = 0;
+
+ // For generic matcher construction (not normally called directly by users).
+ virtual MatcherBase<Arc> *InitMatcher(MatchType match_type) const;
+
+ protected:
+ bool WriteFile(const string &filename) const {
+ if (!filename.empty()) {
+ std::ofstream strm(filename.c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "Fst::Write: Can't open file: " << filename;
+ return false;
+ }
+ bool val = Write(strm, FstWriteOptions(filename));
+ if (!val) LOG(ERROR) << "Fst::Write failed: " << filename;
+ return val;
+ } else {
+ return Write(std::cout, FstWriteOptions("standard output"));
+ }
+ }
+};
+
+// A useful alias when using StdArc.
+using StdFst = Fst<StdArc>;
+
+// State and arc iterator definitions.
+//
+// State iterator interface templated on the Arc definition; used for
+// StateIterator specializations returned by the InitStateIterator FST method.
+template <class Arc>
+class StateIteratorBase {
+ public:
+ using StateId = typename Arc::StateId;
+
+ virtual ~StateIteratorBase() {}
+
+ // End of iterator?
+ virtual bool Done() const = 0;
+ // Returns current state (when !Done()).
+ virtual StateId Value() const = 0;
+ // Advances to next state (when !Done()).
+ virtual void Next() = 0;
+ // Resets to initial condition.
+ virtual void Reset() = 0;
+};
+
+// StateIterator initialization data.
+
+template <class Arc>
+struct StateIteratorData {
+ using StateId = typename Arc::StateId;
+
+ // Specialized iterator if non-zero.
+ StateIteratorBase<Arc> *base;
+ // Otherwise, the total number of states.
+ StateId nstates;
+
+ StateIteratorData() : base(nullptr), nstates(0) {}
+
+ StateIteratorData(const StateIteratorData &) = delete;
+ StateIteratorData &operator=(const StateIteratorData &) = delete;
+};
+
+// Generic state iterator, templated on the FST definition (a wrapper
+// around a pointer to a specific one). Here is a typical use:
+//
+// for (StateIterator<StdFst> siter(fst);
+// !siter.Done();
+// siter.Next()) {
+// StateId s = siter.Value();
+// ...
+// }
+template <class FST>
+class StateIterator {
+ public:
+ using Arc = typename FST::Arc;
+ using StateId = typename Arc::StateId;
+
+ explicit StateIterator(const FST &fst) : s_(0) {
+ fst.InitStateIterator(&data_);
+ }
+
+ ~StateIterator() { delete data_.base; }
+
+ bool Done() const {
+ return data_.base ? data_.base->Done() : s_ >= data_.nstates;
+ }
+
+ StateId Value() const { return data_.base ? data_.base->Value() : s_; }
+
+ void Next() {
+ if (data_.base) {
+ data_.base->Next();
+ } else {
+ ++s_;
+ }
+ }
+
+ void Reset() {
+ if (data_.base) {
+ data_.base->Reset();
+ } else {
+ s_ = 0;
+ }
+ }
+
+ private:
+ StateIteratorData<Arc> data_;
+ StateId s_;
+};
+
+// Flags to control the behavior on an arc iterator.
+static constexpr uint32 kArcILabelValue =
+ 0x0001; // Value() gives valid ilabel.
+static constexpr uint32 kArcOLabelValue = 0x0002; // " " " olabel.
+static constexpr uint32 kArcWeightValue = 0x0004; // " " " weight.
+static constexpr uint32 kArcNextStateValue =
+ 0x0008; // " " " nextstate.
+static constexpr uint32 kArcNoCache = 0x0010; // No need to cache arcs.
+
+static constexpr uint32 kArcValueFlags =
+ kArcILabelValue | kArcOLabelValue | kArcWeightValue | kArcNextStateValue;
+
+static constexpr uint32 kArcFlags = kArcValueFlags | kArcNoCache;
+
+// Arc iterator interface, templated on the arc definition; used for arc
+// iterator specializations that are returned by the InitArcIterator FST method.
+template <class Arc>
+class ArcIteratorBase {
+ public:
+ using StateId = typename Arc::StateId;
+
+ virtual ~ArcIteratorBase() {}
+
+ // End of iterator?
+ virtual bool Done() const = 0;
+ // Returns current arc (when !Done()).
+ virtual const Arc &Value() const = 0;
+ // Advances to next arc (when !Done()).
+ virtual void Next() = 0;
+ // Returns current position.
+ virtual size_t Position() const = 0;
+ // Returns to initial condition.
+ virtual void Reset() = 0;
+ // Advances to arbitrary arc by position.
+ virtual void Seek(size_t) = 0;
+ // Returns current behavorial flags
+ virtual uint32 Flags() const = 0;
+ // Sets behavorial flags.
+ virtual void SetFlags(uint32, uint32) = 0;
+};
+
+// ArcIterator initialization data.
+template <class Arc>
+struct ArcIteratorData {
+ ArcIteratorData()
+ : base(nullptr), arcs(nullptr), narcs(0), ref_count(nullptr) {}
+
+ ArcIteratorData(const ArcIteratorData &) = delete;
+
+ ArcIteratorData &operator=(const ArcIteratorData &) = delete;
+
+ ArcIteratorBase<Arc> *base; // Specialized iterator if non-zero.
+ const Arc *arcs; // O.w. arcs pointer
+ size_t narcs; // ... and arc count.
+ int *ref_count; // ... and reference count if non-zero.
+};
+
+// Generic arc iterator, templated on the FST definition (a wrapper around a
+// pointer to a specific one). Here is a typical use:
+//
+// for (ArcIterator<StdFst> aiter(fst, s);
+// !aiter.Done();
+// aiter.Next()) {
+// StdArc &arc = aiter.Value();
+// ...
+// }
+template <class FST>
+class ArcIterator {
+ public:
+ using Arc = typename FST::Arc;
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const FST &fst, StateId s) : i_(0) {
+ fst.InitArcIterator(s, &data_);
+ }
+
+ explicit ArcIterator(const ArcIteratorData<Arc> &data) : data_(data), i_(0) {
+ if (data_.ref_count) ++(*data_.ref_count);
+ }
+
+ ~ArcIterator() {
+ if (data_.base) {
+ delete data_.base;
+ } else if (data_.ref_count) {
+ --(*data_.ref_count);
+ }
+ }
+
+ bool Done() const {
+ return data_.base ? data_.base->Done() : i_ >= data_.narcs;
+ }
+
+ const Arc &Value() const {
+ return data_.base ? data_.base->Value() : data_.arcs[i_];
+ }
+
+ void Next() {
+ if (data_.base) {
+ data_.base->Next();
+ } else {
+ ++i_;
+ }
+ }
+
+ void Reset() {
+ if (data_.base) {
+ data_.base->Reset();
+ } else {
+ i_ = 0;
+ }
+ }
+
+ void Seek(size_t a) {
+ if (data_.base) {
+ data_.base->Seek(a);
+ } else {
+ i_ = a;
+ }
+ }
+
+ size_t Position() const { return data_.base ? data_.base->Position() : i_; }
+
+ uint32 Flags() const {
+ if (data_.base) {
+ return data_.base->Flags();
+ } else {
+ return kArcValueFlags;
+ }
+ }
+
+ void SetFlags(uint32 flags, uint32 mask) {
+ if (data_.base) data_.base->SetFlags(flags, mask);
+ }
+
+ private:
+ ArcIteratorData<Arc> data_;
+ size_t i_;
+};
+
+} // namespace fst
+
+// ArcIterator placement operator new and destroy function; new needs to be in
+// the global namespace.
+
+template <class FST>
+void *operator new(size_t size,
+ fst::MemoryPool<fst::ArcIterator<FST>> *pool) {
+ return pool->Allocate();
+}
+
+namespace fst {
+
+template <class FST>
+void Destroy(ArcIterator<FST> *aiter, MemoryPool<ArcIterator<FST>> *pool) {
+ if (aiter) {
+ aiter->~ArcIterator<FST>();
+ pool->Free(aiter);
+ }
+}
+
+// Matcher definitions.
+
+template <class Arc>
+MatcherBase<Arc> *Fst<Arc>::InitMatcher(MatchType match_type) const {
+ return nullptr; // One should just use the default matcher.
+}
+
+// FST accessors, useful in high-performance applications.
+
+namespace internal {
+
+// General case, requires non-abstract, 'final' methods. Use for inlining.
+
+template <class F>
+inline typename F::Arc::Weight Final(const F &fst, typename F::Arc::StateId s) {
+ return fst.F::Final(s);
+}
+
+template <class F>
+inline ssize_t NumArcs(const F &fst, typename F::Arc::StateId s) {
+ return fst.F::NumArcs(s);
+}
+
+template <class F>
+inline ssize_t NumInputEpsilons(const F &fst, typename F::Arc::StateId s) {
+ return fst.F::NumInputEpsilons(s);
+}
+
+template <class F>
+inline ssize_t NumOutputEpsilons(const F &fst, typename F::Arc::StateId s) {
+ return fst.F::NumOutputEpsilons(s);
+}
+
+// Fst<Arc> case, abstract methods.
+
+template <class Arc>
+inline typename Arc::Weight Final(const Fst<Arc> &fst,
+ typename Arc::StateId s) {
+ return fst.Final(s);
+}
+
+template <class Arc>
+inline size_t NumArcs(const Fst<Arc> &fst, typename Arc::StateId s) {
+ return fst.NumArcs(s);
+}
+
+template <class Arc>
+inline size_t NumInputEpsilons(const Fst<Arc> &fst, typename Arc::StateId s) {
+ return fst.NumInputEpsilons(s);
+}
+
+template <class Arc>
+inline size_t NumOutputEpsilons(const Fst<Arc> &fst, typename Arc::StateId s) {
+ return fst.NumOutputEpsilons(s);
+}
+
+} // namespace internal
+
+// FST implementation base.
+//
+// This is the recommended FST implementation base class. It will handle
+// reference counts, property bits, type information and symbols.
+
+namespace internal {
+
+template <class Arc>
+class FstImpl {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ FstImpl() : properties_(0), type_("null") {}
+
+ FstImpl(const FstImpl<Arc> &impl)
+ : properties_(impl.properties_),
+ type_(impl.type_),
+ isymbols_(impl.isymbols_ ? impl.isymbols_->Copy() : nullptr),
+ osymbols_(impl.osymbols_ ? impl.osymbols_->Copy() : nullptr) {}
+
+ virtual ~FstImpl() {}
+
+ const string &Type() const { return type_; }
+
+ void SetType(const string &type) { type_ = type; }
+
+ virtual uint64 Properties() const { return properties_; }
+
+ virtual uint64 Properties(uint64 mask) const { return properties_ & mask; }
+
+ void SetProperties(uint64 props) {
+ properties_ &= kError; // kError can't be cleared.
+ properties_ |= props;
+ }
+
+ void SetProperties(uint64 props, uint64 mask) {
+ properties_ &= ~mask | kError; // kError can't be cleared.
+ properties_ |= props & mask;
+ }
+
+ // Allows (only) setting error bit on const FST implementations.
+ void SetProperties(uint64 props, uint64 mask) const {
+ if (mask != kError) {
+ FSTERROR() << "FstImpl::SetProperties() const: Can only set kError";
+ }
+ properties_ |= kError;
+ }
+
+ const SymbolTable *InputSymbols() const { return isymbols_.get(); }
+
+ const SymbolTable *OutputSymbols() const { return osymbols_.get(); }
+
+ SymbolTable *InputSymbols() { return isymbols_.get(); }
+
+ SymbolTable *OutputSymbols() { return osymbols_.get(); }
+
+ void SetInputSymbols(const SymbolTable *isyms) {
+ isymbols_.reset(isyms ? isyms->Copy() : nullptr);
+ }
+
+ void SetOutputSymbols(const SymbolTable *osyms) {
+ osymbols_.reset(osyms ? osyms->Copy() : nullptr);
+ }
+
+ // Reads header and symbols from input stream, initializes FST, and returns
+ // the header. If opts.header is non-null, skips reading and uses the option
+ // value instead. If opts.[io]symbols is non-null, reads in (if present), but
+ // uses the option value.
+ bool ReadHeader(std::istream &strm, const FstReadOptions &opts,
+ int min_version, FstHeader *hdr);
+
+ // Writes header and symbols to output stream. If opts.header is false, skips
+ // writing header. If opts.[io]symbols is false, skips writing those symbols.
+ // This method is needed for implementations that implement Write methods.
+ void WriteHeader(std::ostream &strm, const FstWriteOptions &opts,
+ int version, FstHeader *hdr) const {
+ if (opts.write_header) {
+ hdr->SetFstType(type_);
+ hdr->SetArcType(Arc::Type());
+ hdr->SetVersion(version);
+ hdr->SetProperties(properties_);
+ int32 file_flags = 0;
+ if (isymbols_ && opts.write_isymbols) {
+ file_flags |= FstHeader::HAS_ISYMBOLS;
+ }
+ if (osymbols_ && opts.write_osymbols) {
+ file_flags |= FstHeader::HAS_OSYMBOLS;
+ }
+ if (opts.align) file_flags |= FstHeader::IS_ALIGNED;
+ hdr->SetFlags(file_flags);
+ hdr->Write(strm, opts.source);
+ }
+ if (isymbols_ && opts.write_isymbols) isymbols_->Write(strm);
+ if (osymbols_ && opts.write_osymbols) osymbols_->Write(strm);
+ }
+
+ // Writes out header and symbols to output stream. If opts.header is false,
+ // skips writing header. If opts.[io]symbols is false, skips writing those
+ // symbols. `type` is the FST type being written. This method is used in the
+ // cross-type serialization methods Fst::WriteFst.
+ static void WriteFstHeader(const Fst<Arc> &fst, std::ostream &strm,
+ const FstWriteOptions &opts, int version,
+ const string &type, uint64 properties,
+ FstHeader *hdr) {
+ if (opts.write_header) {
+ hdr->SetFstType(type);
+ hdr->SetArcType(Arc::Type());
+ hdr->SetVersion(version);
+ hdr->SetProperties(properties);
+ int32 file_flags = 0;
+ if (fst.InputSymbols() && opts.write_isymbols) {
+ file_flags |= FstHeader::HAS_ISYMBOLS;
+ }
+ if (fst.OutputSymbols() && opts.write_osymbols) {
+ file_flags |= FstHeader::HAS_OSYMBOLS;
+ }
+ if (opts.align) file_flags |= FstHeader::IS_ALIGNED;
+ hdr->SetFlags(file_flags);
+ hdr->Write(strm, opts.source);
+ }
+ if (fst.InputSymbols() && opts.write_isymbols) {
+ fst.InputSymbols()->Write(strm);
+ }
+ if (fst.OutputSymbols() && opts.write_osymbols) {
+ fst.OutputSymbols()->Write(strm);
+ }
+ }
+
+ // In serialization routines where the header cannot be written until after
+ // the machine has been serialized, this routine can be called to seek to the
+ // beginning of the file an rewrite the header with updated fields. It
+ // repositions the file pointer back at the end of the file. Returns true on
+ // success, false on failure.
+ static bool UpdateFstHeader(const Fst<Arc> &fst, std::ostream &strm,
+ const FstWriteOptions &opts, int version,
+ const string &type, uint64 properties,
+ FstHeader *hdr, size_t header_offset) {
+ strm.seekp(header_offset);
+ if (!strm) {
+ LOG(ERROR) << "Fst::UpdateFstHeader: Write failed: " << opts.source;
+ return false;
+ }
+ WriteFstHeader(fst, strm, opts, version, type, properties, hdr);
+ if (!strm) {
+ LOG(ERROR) << "Fst::UpdateFstHeader: Write failed: " << opts.source;
+ return false;
+ }
+ strm.seekp(0, std::ios_base::end);
+ if (!strm) {
+ LOG(ERROR) << "Fst::UpdateFstHeader: Write failed: " << opts.source;
+ return false;
+ }
+ return true;
+ }
+
+ protected:
+ mutable uint64 properties_; // Property bits.
+
+ private:
+ string type_; // Unique name of FST class.
+ std::unique_ptr<SymbolTable> isymbols_;
+ std::unique_ptr<SymbolTable> osymbols_;
+};
+
+template <class Arc>
+bool FstImpl<Arc>::ReadHeader(std::istream &strm, const FstReadOptions &opts,
+ int min_version, FstHeader *hdr) {
+ if (opts.header) {
+ *hdr = *opts.header;
+ } else if (!hdr->Read(strm, opts.source)) {
+ return false;
+ }
+ if (FLAGS_v >= 2) {
+ LOG(INFO) << "FstImpl::ReadHeader: source: " << opts.source
+ << ", fst_type: " << hdr->FstType()
+ << ", arc_type: " << Arc::Type()
+ << ", version: " << hdr->Version()
+ << ", flags: " << hdr->GetFlags();
+ }
+ if (hdr->FstType() != type_) {
+ LOG(ERROR) << "FstImpl::ReadHeader: FST not of type " << type_
+ << ": " << opts.source;
+ return false;
+ }
+ if (hdr->ArcType() != Arc::Type()) {
+ LOG(ERROR) << "FstImpl::ReadHeader: Arc not of type " << Arc::Type()
+ << ": " << opts.source;
+ return false;
+ }
+ if (hdr->Version() < min_version) {
+ LOG(ERROR) << "FstImpl::ReadHeader: Obsolete " << type_
+ << " FST version: " << opts.source;
+ return false;
+ }
+ properties_ = hdr->Properties();
+ if (hdr->GetFlags() & FstHeader::HAS_ISYMBOLS) {
+ isymbols_.reset(SymbolTable::Read(strm, opts.source));
+ }
+ // Deletes input symbol table.
+ if (!opts.read_isymbols) SetInputSymbols(nullptr);
+ if (hdr->GetFlags() & FstHeader::HAS_OSYMBOLS) {
+ osymbols_.reset(SymbolTable::Read(strm, opts.source));
+ }
+ // Deletes output symbol table.
+ if (!opts.read_osymbols) SetOutputSymbols(nullptr);
+ if (opts.isymbols) {
+ isymbols_.reset(opts.isymbols->Copy());
+ }
+ if (opts.osymbols) {
+ osymbols_.reset(opts.osymbols->Copy());
+ }
+ return true;
+}
+
+} // namespace internal
+
+template <class Arc>
+uint64 TestProperties(const Fst<Arc> &fst, uint64 mask, uint64 *known);
+
+// This is a helper class template useful for attaching an FST interface to
+// its implementation, handling reference counting.
+template <class Impl, class FST = Fst<typename Impl::Arc>>
+class ImplToFst : public FST {
+ public:
+ using Arc = typename Impl::Arc;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using FST::operator=;
+
+ StateId Start() const override { return impl_->Start(); }
+
+ Weight Final(StateId s) const override { return impl_->Final(s); }
+
+ size_t NumArcs(StateId s) const override { return impl_->NumArcs(s); }
+
+ size_t NumInputEpsilons(StateId s) const override {
+ return impl_->NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) const override {
+ return impl_->NumOutputEpsilons(s);
+ }
+
+ uint64 Properties(uint64 mask, bool test) const override {
+ if (test) {
+ uint64 knownprops, testprops = TestProperties(*this, mask, &knownprops);
+ impl_->SetProperties(testprops, knownprops);
+ return testprops & mask;
+ } else {
+ return impl_->Properties(mask);
+ }
+ }
+
+ const string &Type() const override { return impl_->Type(); }
+
+ const SymbolTable *InputSymbols() const override {
+ return impl_->InputSymbols();
+ }
+
+ const SymbolTable *OutputSymbols() const override {
+ return impl_->OutputSymbols();
+ }
+
+ protected:
+ explicit ImplToFst(std::shared_ptr<Impl> impl) : impl_(std::move(impl)) {}
+
+ // This constructor presumes there is a copy constructor for the
+ // implementation.
+ ImplToFst(const ImplToFst<Impl, FST> &fst, bool safe) {
+ if (safe) {
+ impl_ = std::make_shared<Impl>(*(fst.impl_));
+ } else {
+ impl_ = fst.impl_;
+ }
+ }
+
+ // Returns raw pointers to the shared object.
+ const Impl *GetImpl() const { return impl_.get(); }
+
+ Impl *GetMutableImpl() const { return impl_.get(); }
+
+ // Returns a ref-counted smart poiner to the implementation.
+ std::shared_ptr<Impl> GetSharedImpl() const { return impl_; }
+
+ bool Unique() const { return impl_.unique(); }
+
+ void SetImpl(std::shared_ptr<Impl> impl) { impl_ = impl; }
+
+ private:
+ template <class IFST, class OFST>
+ friend void Cast(const IFST &ifst, OFST *ofst);
+
+ std::shared_ptr<Impl> impl_;
+};
+
+// Converts FSTs by casting their implementations, where this makes sense
+// (which excludes implementations with weight-dependent virtual methods).
+// Must be a friend of the FST classes involved (currently the concrete FSTs:
+// ConstFst, CompactFst, and VectorFst). This can only be safely used for arc
+// types that have identical storage characteristics.
+template <class IFST, class OFST>
+void Cast(const IFST &ifst, OFST *ofst) {
+ using OImpl = typename OFST::Impl;
+ ofst->impl_ = std::shared_ptr<OImpl>(ifst.impl_,
+ reinterpret_cast<OImpl *>(ifst.impl_.get()));
+}
+
+// FST serialization.
+
+template <class Arc>
+void FstToString(const Fst<Arc> &fst, string *result) {
+ std::ostringstream ostrm;
+ fst.Write(ostrm, FstWriteOptions("FstToString"));
+ *result = ostrm.str();
+}
+
+template <class Arc>
+void FstToString(const Fst<Arc> &fst, string *result,
+ const FstWriteOptions &options) {
+ std::ostringstream ostrm;
+ fst.Write(ostrm, options);
+ *result = ostrm.str();
+}
+
+template <class Arc>
+Fst<Arc> *StringToFst(const string &s) {
+ std::istringstream istrm(s);
+ return Fst<Arc>::Read(istrm, FstReadOptions("StringToFst"));
+}
+
+} // namespace fst
+
+#endif // FST_LIB_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// This is a library for constructing, combining, optimizing, and searching
+// "weighted finite-state transducers" (FSTs). Weighted finite-state transducers
+// are automata where each transition has an input label, an output label, and a
+// weight. The more familiar finite-state acceptor is represented as a
+// transducer with each transition's input and output the same. Finite-state
+// acceptors are used to represent sets of strings (specifically, "regular" or
+// "rational sets"); finite-state transducers are used to represent binary
+// relations between pairs of strings (specifically, "rational transductions").
+// The weights can be used to represent the cost of taking a particular
+// transition.
+//
+// In this library, transducers are templated on the Arc (transition)
+// definition, which allows changing the label, weight, and state ID sets.
+// Labels and state IDs are restricted to signed integral types but the weight
+// can be an arbitrary type whose members satisfy certain algebraic ("semiring")
+// properties.
+//
+// This convenience file includes all other FST header files.
+
+#ifndef FST_LIB_FSTLIB_H_
+#define FST_LIB_FSTLIB_H_
+
+
+// Abstract FST classes.
+#include <fst/expanded-fst.h>
+#include <fst/fst.h>
+#include <fst/mutable-fst.h>
+
+// Concrete FST classes.
+#include <fst/compact-fst.h>
+#include <fst/const-fst.h>
+#include <fst/edit-fst.h>
+#include <fst/vector-fst.h>
+
+// FST algorithms and delayed FST classes.
+#include <fst/arc-map.h>
+#include <fst/arcsort.h>
+#include <fst/closure.h>
+#include <fst/compose.h>
+#include <fst/concat.h>
+#include <fst/connect.h>
+#include <fst/determinize.h>
+#include <fst/difference.h>
+#include <fst/disambiguate.h>
+#include <fst/encode.h>
+#include <fst/epsnormalize.h>
+#include <fst/equal.h>
+#include <fst/equivalent.h>
+#include <fst/factor-weight.h>
+#include <fst/intersect.h>
+#include <fst/invert.h>
+#include <fst/isomorphic.h>
+#include <fst/map.h>
+#include <fst/minimize.h>
+#include <fst/project.h>
+#include <fst/prune.h>
+#include <fst/push.h>
+#include <fst/randequivalent.h>
+#include <fst/randgen.h>
+#include <fst/rational.h>
+#include <fst/relabel.h>
+#include <fst/replace.h>
+#include <fst/replace-util.h>
+#include <fst/reverse.h>
+#include <fst/reweight.h>
+#include <fst/rmepsilon.h>
+#include <fst/rmfinalepsilon.h>
+#include <fst/shortest-distance.h>
+#include <fst/shortest-path.h>
+#include <fst/state-map.h>
+#include <fst/statesort.h>
+#include <fst/synchronize.h>
+#include <fst/topsort.h>
+#include <fst/union.h>
+#include <fst/verify.h>
+#include <fst/visit.h>
+
+// Weights.
+#include <fst/expectation-weight.h>
+#include <fst/float-weight.h>
+#include <fst/lexicographic-weight.h>
+#include <fst/pair-weight.h>
+#include <fst/power-weight.h>
+#include <fst/product-weight.h>
+#include <fst/signed-log-weight.h>
+#include <fst/sparse-power-weight.h>
+#include <fst/sparse-tuple-weight.h>
+#include <fst/string-weight.h>
+#include <fst/tuple-weight.h>
+#include <fst/weight.h>
+
+// Auxiliary classes for composition.
+#include <fst/compose-filter.h>
+#include <fst/lookahead-filter.h>
+#include <fst/lookahead-matcher.h>
+#include <fst/matcher-fst.h>
+#include <fst/matcher.h>
+#include <fst/state-table.h>
+
+// Data structures.
+#include <fst/heap.h>
+#include <fst/interval-set.h>
+#include <fst/queue.h>
+#include <fst/union-find.h>
+
+// Miscellaneous.
+#include <fst/accumulator.h>
+#include <fst/add-on.h>
+#include <fst/arc.h>
+#include <fst/arcfilter.h>
+#include <fst/cache.h>
+#include <fst/complement.h>
+#include <fst/dfs-visit.h>
+#include <fst/generic-register.h>
+#include <fst/label-reachable.h>
+#include <fst/partition.h>
+#include <fst/properties.h>
+#include <fst/register.h>
+#include <fst/state-reachable.h>
+#include <fst/string.h>
+#include <fst/symbol-table.h>
+#include <fst/symbol-table-ops.h>
+#include <fst/test-properties.h>
+#include <fst/util.h>
+
+
+#endif // FST_LIB_FSTLIB_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_LIB_GENERIC_REGISTER_H_
+#define FST_LIB_GENERIC_REGISTER_H_
+
+#ifndef FST_NO_DYNAMIC_LINKING
+#include <dlfcn.h>
+#include <fst/compat.h>
+#endif
+#include <map>
+#include <string>
+
+#include <fst/types.h>
+
+// Generic class representing a globally-stored correspondence between
+// objects of KeyType and EntryType.
+//
+// KeyType must:
+//
+// * be such as can be stored as a key in a std::map<>.
+// * be concatenable with a const char* with the + operator
+// (or you must subclass and redefine LoadEntryFromSharedObject)
+//
+// EntryType must be default constructible.
+//
+// The third template parameter should be the type of a subclass of this class
+// (think CRTP). This is to allow GetRegister() to instantiate and return an
+// object of the appropriate type.
+
+namespace fst {
+
+template <class KeyType, class EntryType, class RegisterType>
+class GenericRegister {
+ public:
+ using Key = KeyType;
+ using Entry = EntryType;
+
+ static RegisterType *GetRegister() {
+ static auto reg = new RegisterType;
+ return reg;
+ }
+
+ void SetEntry(const KeyType &key, const EntryType &entry) {
+ MutexLock l(®ister_lock_);
+ register_table_.insert(std::make_pair(key, entry));
+ }
+
+ EntryType GetEntry(const KeyType &key) const {
+ const auto *entry = LookupEntry(key);
+ if (entry) {
+ return *entry;
+ } else {
+ return LoadEntryFromSharedObject(key);
+ }
+ }
+
+ virtual ~GenericRegister() {}
+
+ protected:
+ // Override this if you want to be able to load missing definitions from
+ // shared object files.
+ virtual EntryType LoadEntryFromSharedObject(const KeyType &key) const {
+#ifdef FST_NO_DYNAMIC_LINKING
+ return EntryType();
+#else
+ const auto so_filename = ConvertKeyToSoFilename(key);
+ void *handle = dlopen(so_filename.c_str(), RTLD_LAZY);
+ if (handle == nullptr) {
+ LOG(ERROR) << "GenericRegister::GetEntry: " << dlerror();
+ return EntryType();
+ }
+#ifdef RUN_MODULE_INITIALIZERS
+ RUN_MODULE_INITIALIZERS();
+#endif
+ // We assume that the DSO constructs a static object in its global scope
+ // that does the registration. Thus we need only load it, not call any
+ // methods.
+ const auto *entry = this->LookupEntry(key);
+ if (entry == nullptr) {
+ LOG(ERROR) << "GenericRegister::GetEntry: "
+ << "lookup failed in shared object: " << so_filename;
+ return EntryType();
+ }
+ return *entry;
+#endif // FST_NO_DYNAMIC_LINKING
+ }
+
+ // Override this to define how to turn a key into an SO filename.
+ virtual string ConvertKeyToSoFilename(const KeyType &key) const = 0;
+
+ virtual const EntryType *LookupEntry(const KeyType &key) const {
+ MutexLock l(®ister_lock_);
+ const auto it = register_table_.find(key);
+ if (it != register_table_.end()) {
+ return &it->second;
+ } else {
+ return nullptr;
+ }
+ }
+
+ private:
+ mutable Mutex register_lock_;
+ std::map<KeyType, EntryType> register_table_;
+};
+
+// Generic register-er class capable of creating new register entries in the
+// given RegisterType template parameter. This type must define types Key and
+// Entry, and have appropriate static GetRegister() and instance SetEntry()
+// functions. An easy way to accomplish this is to have RegisterType be the
+// type of a subclass of GenericRegister.
+template <class RegisterType>
+class GenericRegisterer {
+ public:
+ using Key = typename RegisterType::Key;
+ using Entry = typename RegisterType::Entry;
+
+ GenericRegisterer(Key key, Entry entry) {
+ RegisterType::GetRegister()->SetEntry(key, entry);
+ }
+};
+
+} // namespace fst
+
+#endif // FST_LIB_GENERIC_REGISTER_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Implementation of a heap as in STL, but allows tracking positions in heap
+// using a key. The key can be used to do an in-place update of values in the
+// heap.
+
+#ifndef FST_LIB_HEAP_H_
+#define FST_LIB_HEAP_H_
+
+#include <utility>
+#include <vector>
+
+#include <fst/compat.h>
+namespace fst {
+
+// A templated heap implementation that supports in-place update of values.
+//
+// The templated heap implementation is a little different from the STL
+// priority_queue and the *_heap operations in STL. This heap supports
+// indexing of values in the heap via an associated key.
+//
+// Each value is internally associated with a key which is returned to the
+// calling functions on heap insert. This key can be used to later update
+// the specific value in the heap.
+//
+// T: the element type of the hash. It can be POD, Data or a pointer to Data.
+// Compare: comparison functor for determining min-heapness.
+template <class T, class Compare>
+class Heap {
+ public:
+ using Value = T;
+
+ static constexpr int kNoKey = -1;
+
+ // Initializes with a specific comparator.
+ explicit Heap(Compare comp = Compare()) : comp_(comp), size_(0) {}
+
+ // Inserts a value into the heap.
+ int Insert(const Value &value) {
+ if (size_ < values_.size()) {
+ values_[size_] = value;
+ pos_[key_[size_]] = size_;
+ } else {
+ values_.push_back(value);
+ pos_.push_back(size_);
+ key_.push_back(size_);
+ }
+ ++size_;
+ return Insert(value, size_ - 1);
+ }
+
+ // Updates a value at position given by the key. The pos_ array is first
+ // indexed by the key. The position gives the position in the heap array.
+ // Once we have the position we can then use the standard heap operations
+ // to calculate the parent and child positions.
+ void Update(int key, const Value &value) {
+ const auto i = pos_[key];
+ const bool is_better = comp_(value, values_[Parent(i)]);
+ values_[i] = value;
+ if (is_better) {
+ Insert(value, i);
+ } else {
+ Heapify(i);
+ }
+ }
+
+ // Returns the greatest (max=true) / least (max=false) value.
+ Value Pop() {
+ Value top = values_.front();
+ Swap(0, size_-1);
+ size_--;
+ Heapify(0);
+ return top;
+ }
+
+ // Returns the greatest (max=true) / least (max=false) value w.r.t.
+ // the comparison function from the heap.
+ const Value &Top() const { return values_.front(); }
+
+ // Returns the element for the given key.
+ const Value &Get(int key) const { return values_[pos_[key]]; }
+
+ // Checks if the heap is empty.
+ bool Empty() const { return size_ == 0; }
+
+ void Clear() { size_ = 0; }
+
+ int Size() const { return size_; }
+
+ void Reserve(int size) {
+ values_.reserve(size);
+ pos_.reserve(size);
+ key_.reserve(size);
+ }
+
+ private:
+ // The following private routines are used in a supportive role
+ // for managing the heap and keeping the heap properties.
+
+ // Computes left child of parent.
+ static int Left(int i) {
+ return 2 * (i + 1) - 1; // 0 -> 1, 1 -> 3
+ }
+
+ // Computes right child of parent.
+ static int Right(int i) {
+ return 2 * (i + 1); // 0 -> 2, 1 -> 4
+ }
+
+ // Given a child computes parent.
+ static int Parent(int i) {
+ return (i - 1) / 2; // 0 -> 0, 1 -> 0, 2 -> 0, 3 -> 1, 4 -> 1, ...
+ }
+
+ // Swaps a child and parent. Use to move element up/down tree. Note the use of
+ // a little trick here. When we swap we need to swap:
+ //
+ // - the value
+ // - the associated keys
+ // - the position of the value in the heap
+ void Swap(int j, int k) {
+ const auto tkey = key_[j];
+ pos_[key_[j] = key_[k]] = j;
+ pos_[key_[k] = tkey] = k;
+ using std::swap;
+ swap(values_[j], values_[k]);
+ }
+
+ // Heapifies the subtree rooted at index i.
+ void Heapify(int i) {
+ const auto l = Left(i);
+ const auto r = Right(i);
+ auto largest = (l < size_ && comp_(values_[l], values_[i])) ? l : i;
+ if (r < size_ && comp_(values_[r], values_[largest])) largest = r;
+ if (largest != i) {
+ Swap(i, largest);
+ Heapify(largest);
+ }
+ }
+
+ // Inserts (updates) element at subtree rooted at index i.
+ int Insert(const Value &value, int i) {
+ int p;
+ while (i > 0 && !comp_(values_[p = Parent(i)], value)) {
+ Swap(i, p);
+ i = p;
+ }
+ return key_[i];
+ }
+
+ private:
+ const Compare comp_;
+
+ std::vector<int> pos_;
+ std::vector<int> key_;
+ std::vector<Value> values_;
+ int size_;
+};
+
+template <class T, class Compare>
+constexpr int Heap<T, Compare>::kNoKey;
+
+} // namespace fst
+
+#endif // FST_LIB_HEAP_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// This library implements an unrestricted Thompson/Pike UTF-8 parser and
+// serializer. UTF-8 is a restricted subset of this byte stream encoding. See
+// http://en.wikipedia.org/wiki/UTF-8 for a good description of the encoding
+// details.
+
+#ifndef FST_LIB_ICU_H_
+#define FST_LIB_ICU_H_
+
+#include <sstream>
+#include <vector>
+
+namespace fst {
+
+// This function writes UTF-8 codepoints into a vector of Labels, truncating if
+// necessary. It is possible to use this sensibly with as little as 16 bits of
+// Label precision (i.e., when all characters are within the Basic Multilingual
+// Plane). With 21 bits, one can encode all UTF-8 codepoints, including those
+// from the various Astral Planes. Naturally, it is safe to use this with larger
+// Labels (e.g., 64 bits).
+template <class Label>
+bool UTF8StringToLabels(const string &str, std::vector<Label> *labels) {
+ const auto *data = str.data();
+ const auto length = str.size();
+ for (size_t i = 0; i < length;) {
+ int c = data[i++] & 0xff;
+ if ((c & 0x80) == 0) {
+ labels->push_back(c);
+ } else {
+ if ((c & 0xc0) == 0x80) {
+ LOG(ERROR) << "UTF8StringToLabels: Continuation byte as lead byte";
+ return false;
+ }
+ int count =
+ (c >= 0xc0) + (c >= 0xe0) + (c >= 0xf0) + (c >= 0xf8) + (c >= 0xfc);
+ int32 code = c & ((1 << (6 - count)) - 1);
+ while (count != 0) {
+ if (i == length) {
+ LOG(ERROR) << "UTF8StringToLabels: Truncated UTF-8 byte sequence";
+ return false;
+ }
+ char cb = data[i++];
+ if ((cb & 0xc0) != 0x80) {
+ LOG(ERROR) << "UTF8StringToLabels: Missing/invalid continuation byte";
+ return false;
+ }
+ code = (code << 6) | (cb & 0x3f);
+ count--;
+ }
+ if (code < 0) {
+ // Should be unreachable.
+ LOG(ERROR) << "UTF8StringToLabels: Invalid character found: " << c;
+ return false;
+ }
+ labels->push_back(code);
+ }
+ }
+ return true;
+}
+
+template <class Label>
+bool LabelsToUTF8String(const std::vector<Label> &labels, string *str) {
+ std::ostringstream ostr;
+ for (size_t i = 0; i < labels.size(); ++i) {
+ int32 code = labels[i];
+ if (code < 0) {
+ LOG(ERROR) << "LabelsToUTF8String: Invalid character found: " << code;
+ return false;
+ } else if (code < 0x80) {
+ ostr << static_cast<char>(code);
+ } else if (code < 0x800) {
+ ostr << static_cast<char>((code >> 6) | 0xc0);
+ ostr << static_cast<char>((code & 0x3f) | 0x80);
+ } else if (code < 0x10000) {
+ ostr << static_cast<char>((code >> 12) | 0xe0);
+ ostr << static_cast<char>(((code >> 6) & 0x3f) | 0x80);
+ ostr << static_cast<char>((code & 0x3f) | 0x80);
+ } else if (code < 0x200000) {
+ ostr << static_cast<char>((code >> 18) | 0xf0);
+ ostr << static_cast<char>(((code >> 12) & 0x3f) | 0x80);
+ ostr << static_cast<char>(((code >> 6) & 0x3f) | 0x80);
+ ostr << static_cast<char>((code & 0x3f) | 0x80);
+ } else if (code < 0x4000000) {
+ ostr << static_cast<char>((code >> 24) | 0xf8);
+ ostr << static_cast<char>(((code >> 18) & 0x3f) | 0x80);
+ ostr << static_cast<char>(((code >> 12) & 0x3f) | 0x80);
+ ostr << static_cast<char>(((code >> 6) & 0x3f) | 0x80);
+ ostr << static_cast<char>((code & 0x3f) | 0x80);
+ } else {
+ ostr << static_cast<char>((code >> 30) | 0xfc);
+ ostr << static_cast<char>(((code >> 24) & 0x3f) | 0x80);
+ ostr << static_cast<char>(((code >> 18) & 0x3f) | 0x80);
+ ostr << static_cast<char>(((code >> 12) & 0x3f) | 0x80);
+ ostr << static_cast<char>(((code >> 6) & 0x3f) | 0x80);
+ ostr << static_cast<char>((code & 0x3f) | 0x80);
+ }
+ }
+ *str = ostr.str();
+ return true;
+}
+
+} // namespace fst
+
+#endif // FST_LIB_ICU_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Class to compute the intersection of two FSAs.
+
+#ifndef FST_LIB_INTERSECT_H_
+#define FST_LIB_INTERSECT_H_
+
+#include <algorithm>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/compose.h>
+
+
+namespace fst {
+
+using IntersectOptions = ComposeOptions;
+
+template <class Arc, class M = Matcher<Fst<Arc>>,
+ class Filter = SequenceComposeFilter<M>,
+ class StateTable =
+ GenericComposeStateTable<Arc, typename Filter::FilterState>>
+struct IntersectFstOptions
+ : public ComposeFstOptions<Arc, M, Filter, StateTable> {
+ IntersectFstOptions() {}
+
+ explicit IntersectFstOptions(const CacheOptions &opts, M *matcher1 = nullptr,
+ M *matcher2 = nullptr, Filter *filter = nullptr,
+ StateTable *state_table = nullptr)
+ : ComposeFstOptions<Arc, M, Filter, StateTable>(opts, matcher1, matcher2,
+ filter, state_table) {}
+};
+
+// Computes the intersection (Hadamard product) of two FSAs. This version is a
+// delayed FST. 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 ComposeFst.
+//
+// Caveats: same as ComposeFst.
+template <class A>
+class IntersectFst : public ComposeFst<A> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using ComposeFst<A>::CreateBase;
+ using ComposeFst<A>::CreateBase1;
+ using ComposeFst<A>::Properties;
+
+ IntersectFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const CacheOptions &opts = CacheOptions())
+ : ComposeFst<Arc>(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 <class M, class Filter, class StateTable>
+ IntersectFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const IntersectFstOptions<Arc, M, Filter, StateTable> &opts)
+ : ComposeFst<Arc>(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<Arc> &fst, bool safe = false)
+ : ComposeFst<Arc>(fst, safe) {}
+
+ // Get a copy of this IntersectFst. See Fst<>::Copy() for further doc.
+ IntersectFst<Arc> *Copy(bool safe = false) const override {
+ return new IntersectFst<Arc>(*this, safe);
+ }
+
+ private:
+ using ImplToFst<internal::ComposeFstImplBase<A>>::GetImpl;
+ using ImplToFst<internal::ComposeFstImplBase<A>>::GetMutableImpl;
+};
+
+// Specialization for IntersectFst.
+template <class Arc>
+class StateIterator<IntersectFst<Arc>> : public StateIterator<ComposeFst<Arc>> {
+ public:
+ explicit StateIterator(const IntersectFst<Arc> &fst)
+ : StateIterator<ComposeFst<Arc>>(fst) {}
+};
+
+// Specialization for IntersectFst.
+template <class Arc>
+class ArcIterator<IntersectFst<Arc>> : public ArcIterator<ComposeFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const IntersectFst<Arc> &fst, StateId s)
+ : ArcIterator<ComposeFst<Arc>>(fst, s) {}
+};
+
+// Useful alias when using StdArc.
+using StdIntersectFst = IntersectFst<StdArc>;
+
+// 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 <class Arc>
+void Intersect(const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ MutableFst<Arc> *ofst,
+ const IntersectOptions &opts = IntersectOptions()) {
+ using M = Matcher<Fst<Arc>>;
+ if (opts.filter_type == AUTO_FILTER) {
+ CacheOptions nopts;
+ nopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = IntersectFst<Arc>(ifst1, ifst2, nopts);
+ } else if (opts.filter_type == SEQUENCE_FILTER) {
+ IntersectFstOptions<Arc> iopts;
+ iopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = IntersectFst<Arc>(ifst1, ifst2, iopts);
+ } else if (opts.filter_type == ALT_SEQUENCE_FILTER) {
+ IntersectFstOptions<Arc, M, AltSequenceComposeFilter<M>> iopts;
+ iopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = IntersectFst<Arc>(ifst1, ifst2, iopts);
+ } else if (opts.filter_type == MATCH_FILTER) {
+ IntersectFstOptions<Arc, M, MatchComposeFilter<M>> iopts;
+ iopts.gc_limit = 0; // Cache only the last state for fastest copy.
+ *ofst = IntersectFst<Arc>(ifst1, ifst2, iopts);
+ }
+ if (opts.connect) Connect(ofst);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_INTERSECT_H_
--- /dev/null
+// 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_LIB_INTERVAL_SET_H_
+#define FST_LIB_INTERVAL_SET_H_
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+
+#include <fst/util.h>
+
+
+namespace fst {
+
+// Half-open integral interval [a, b) of signed integers of type T.
+template <class T>
+struct IntInterval {
+ T begin;
+ T end;
+
+ IntInterval() : begin(-1), end(-1) {}
+
+ IntInterval(T begin, T end) : begin(begin), end(end) {}
+
+ bool operator<(const IntInterval<T> &i) const {
+ return begin < i.begin || (begin == i.begin && end > i.end);
+ }
+
+ bool operator==(const IntInterval<T> &i) const {
+ return begin == i.begin && end == i.end;
+ }
+
+ bool operator!=(const IntInterval<T> &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<T> in a vector. In addition, keeps the count of points in
+// all intervals.
+template <class T>
+class VectorIntervalStore {
+ public:
+ using Interval = IntInterval<T>;
+ using Iterator = typename std::vector<Interval>::const_iterator;
+
+ VectorIntervalStore() : count_(-1) {}
+
+ std::vector<Interval> *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<Interval> intervals_;
+ T count_;
+};
+
+// Stores and operates on a set of half-open integral intervals [a, b)
+// of signed integers of type T.
+template <class T, class Store = VectorIntervalStore<T>>
+class IntervalSet {
+ public:
+ using Interval = IntInterval<T>;
+
+ template <class... A>
+ explicit IntervalSet(A... args) : intervals_(args...) {}
+
+ // Returns the interval set as a vector.
+ std::vector<Interval> *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<T, Store> &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<T, Store> &iset) const {
+ return Size() == iset.Size() &&
+ std::equal(intervals_.begin(), intervals_.end(),
+ iset.intervals_.begin());
+ }
+
+ // Requires intervals be normalized.
+ bool operator!=(const IntervalSet<T, Store> &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<T, Store> &iset,
+ IntervalSet<T, Store> *oset) const;
+
+ // Complements the set w.r.t [0, maxval). Requires intervals be normalized.
+ // The result is normalized.
+ void Complement(T maxval, IntervalSet<T, Store> *oset) const;
+
+ // Subtract an interval set from the set. Requires intervals be normalized.
+ // The result is normalized.
+ void Difference(const IntervalSet<T, Store> &iset,
+ IntervalSet<T, Store> *oset) const;
+
+ // Determines if an interval set overlaps with the set. Requires intervals be
+ // normalized.
+ bool Overlaps(const IntervalSet<T, Store> &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<T, Store> &iset) const;
+
+ // Determines if an interval set is contained within the set. Requires
+ // intervals be normalized.
+ bool Contains(const IntervalSet<T, Store> &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 <typename T, class Store>
+void IntervalSet<T, Store>::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 <typename T, class Store>
+void IntervalSet<T, Store>::Intersect(const IntervalSet<T, Store> &iset,
+ IntervalSet<T, Store> *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 <typename T, class Store>
+void IntervalSet<T, Store>::Complement(T maxval,
+ IntervalSet<T, Store> *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 <typename T, class Store>
+void IntervalSet<T, Store>::Difference(const IntervalSet<T, Store> &iset,
+ IntervalSet<T, Store> *oset) const {
+ if (Empty()) {
+ oset->MutableIntervals()->clear();
+ oset->intervals_.SetCount(0);
+ } else {
+ IntervalSet<T, Store> 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 <typename T, class Store>
+bool IntervalSet<T, Store>::Overlaps(const IntervalSet<T, Store> &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 <typename T, class Store>
+bool IntervalSet<T, Store>::StrictlyOverlaps(
+ const IntervalSet<T, Store> &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 <typename T, class Store>
+bool IntervalSet<T, Store>::Contains(const IntervalSet<T, Store> &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 <typename T, class Store>
+std::ostream &operator<<(std::ostream &strm, const IntervalSet<T, Store> &s) {
+ strm << "{";
+ for (auto 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_LIB_INTERVAL_SET_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes to invert an FST.
+
+#ifndef FST_LIB_INVERT_H_
+#define FST_LIB_INVERT_H_
+
+#include <fst/arc-map.h>
+#include <fst/mutable-fst.h>
+
+
+namespace fst {
+
+// Mapper to implement inversion of an arc.
+template <class A>
+struct InvertMapper {
+ using FromArc = A;
+ using ToArc = A;
+
+ InvertMapper() {}
+
+ ToArc operator()(const FromArc &arc) {
+ return ToArc(arc.olabel, arc.ilabel, arc.weight, arc.nextstate);
+ }
+
+ MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ MapSymbolsAction InputSymbolsAction() const { return MAP_CLEAR_SYMBOLS; }
+
+ MapSymbolsAction OutputSymbolsAction() const { return MAP_CLEAR_SYMBOLS; }
+
+ uint64 Properties(uint64 props) { return InvertProperties(props); }
+};
+
+// Inverts the transduction corresponding to an FST by exchanging the
+// FST's input and output labels. This version modifies its input.
+//
+// Complexity:
+//
+// Time: O(V + E)
+// Space: O(1)
+//
+// where V is the number of states and E is the number of arcs.
+template <class Arc>
+inline void Invert(MutableFst<Arc> *fst) {
+ std::unique_ptr<SymbolTable> input(
+ fst->InputSymbols() ? fst->InputSymbols()->Copy() : nullptr);
+ std::unique_ptr<SymbolTable> output(
+ fst->OutputSymbols() ? fst->OutputSymbols()->Copy() : nullptr);
+ ArcMap(fst, InvertMapper<Arc>());
+ 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 A>
+class InvertFst : public ArcMapFst<A, A, InvertMapper<A>> {
+ public:
+ using Arc = A;
+
+ using Mapper = InvertMapper<Arc>;
+ using Impl = internal::ArcMapFstImpl<A, A, InvertMapper<A>>;
+
+ explicit InvertFst(const Fst<Arc> &fst)
+ : ArcMapFst<Arc, Arc, Mapper>(fst, Mapper()) {
+ GetMutableImpl()->SetOutputSymbols(fst.InputSymbols());
+ GetMutableImpl()->SetInputSymbols(fst.OutputSymbols());
+ }
+
+ // See Fst<>::Copy() for doc.
+ InvertFst(const InvertFst<Arc> &fst, bool safe = false)
+ : ArcMapFst<Arc, Arc, Mapper>(fst, safe) {}
+
+ // Get a copy of this InvertFst. See Fst<>::Copy() for further doc.
+ InvertFst<Arc> *Copy(bool safe = false) const override {
+ return new InvertFst(*this, safe);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetMutableImpl;
+};
+
+// Specialization for InvertFst.
+template <class Arc>
+class StateIterator<InvertFst<Arc>>
+ : public StateIterator<ArcMapFst<Arc, Arc, InvertMapper<Arc>>> {
+ public:
+ explicit StateIterator(const InvertFst<Arc> &fst)
+ : StateIterator<ArcMapFst<Arc, Arc, InvertMapper<Arc>>>(fst) {}
+};
+
+// Specialization for InvertFst.
+template <class Arc>
+class ArcIterator<InvertFst<Arc>>
+ : public ArcIterator<ArcMapFst<Arc, Arc, InvertMapper<Arc>>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const InvertFst<Arc> &fst, StateId s)
+ : ArcIterator<ArcMapFst<Arc, Arc, InvertMapper<Arc>>>(fst, s) {}
+};
+
+// Useful alias when using StdArc.
+using StdInvertFst = InvertFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_INVERT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Function to test two FSTs are isomorphic, i.e., they are equal up to a state
+// and arc re-ordering. FSTs should be deterministic when viewed as
+// unweighted automata.
+
+#ifndef FST_LIB_ISOMORPHIC_H_
+#define FST_LIB_ISOMORPHIC_H_
+
+#include <algorithm>
+#include <list>
+#include <vector>
+
+#include <fst/fst.h>
+
+
+namespace fst {
+namespace internal {
+
+// Orders weights for equality checking.
+template <class Weight>
+bool WeightCompare(Weight w1, Weight w2, float delta, bool *error) {
+ if (Weight::Properties() & kIdempotent) {
+ NaturalLess<Weight> less;
+ return less(w1, w2);
+ } else { // No natural order; use hash
+ const auto q1 = w1.Quantize(delta);
+ const auto q2 = w2.Quantize(delta);
+ auto n1 = q1.Hash();
+ auto n2 = q2.Hash();
+ // Hash not unique; very unlikely to happen.
+ if (n1 == n2 && q1 != q2) {
+ VLOG(1) << "Isomorphic: Weight hash collision";
+ *error = true;
+ }
+ return n1 < n2;
+ }
+}
+
+template <class Arc>
+class Isomorphism {
+ using StateId = typename Arc::StateId;
+
+ public:
+ Isomorphism(const Fst<Arc> &fst1, const Fst<Arc> &fst2, float delta)
+ : fst1_(fst1.Copy()),
+ fst2_(fst2.Copy()),
+ delta_(delta),
+ error_(false),
+ comp_(delta, &error_) {}
+
+ // Checks if input FSTs are isomorphic.
+ bool IsIsomorphic() {
+ if (fst1_->Start() == kNoStateId && fst2_->Start() == kNoStateId) {
+ return true;
+ }
+ if (fst1_->Start() == kNoStateId || fst2_->Start() == kNoStateId) {
+ return false;
+ }
+ PairState(fst1_->Start(), fst2_->Start());
+ while (!queue_.empty()) {
+ const auto &pr = queue_.front();
+ if (!IsIsomorphicState(pr.first, pr.second)) return false;
+ queue_.pop_front();
+ }
+ return true;
+ }
+
+ bool Error() const { return error_; }
+
+ private:
+ // Orders arcs for equality checking.
+ class ArcCompare {
+ public:
+ ArcCompare(float delta, bool *error) : delta_(delta), error_(error) {}
+
+ bool operator()(const Arc &arc1, const Arc &arc2) const {
+ if (arc1.ilabel < arc2.ilabel) return true;
+ if (arc1.ilabel > arc2.ilabel) return false;
+ if (arc1.olabel < arc2.olabel) return true;
+ if (arc1.olabel > arc2.olabel) return false;
+ return WeightCompare(arc1.weight, arc2.weight, delta_, error_);
+ }
+
+ private:
+ float delta_;
+ bool *error_;
+ };
+
+ // Maintains state correspondences and queue.
+ bool PairState(StateId s1, StateId s2) {
+ if (state_pairs_.size() <= s1) state_pairs_.resize(s1 + 1, kNoStateId);
+ if (state_pairs_[s1] == s2) {
+ return true; // already seen this pair
+ } else if (state_pairs_[s1] != kNoStateId) {
+ return false; // s1 already paired with another s2
+ }
+ state_pairs_[s1] = s2;
+ queue_.push_back(std::make_pair(s1, s2));
+ return true;
+ }
+
+ // Checks if state pair is isomorphic
+ bool IsIsomorphicState(StateId s1, StateId s2);
+
+ std::unique_ptr<Fst<Arc>> fst1_;
+ std::unique_ptr<Fst<Arc>> fst2_;
+ float delta_; // Weight equality delta.
+ std::vector<Arc> arcs1_; // For sorting arcs on FST1.
+ std::vector<Arc> arcs2_; // For sorting arcs on FST2.
+ std::vector<StateId> state_pairs_; // Maintains state correspondences.
+ std::list<std::pair<StateId, StateId>> queue_; // Queue of state pairs.
+ bool error_; // Error flag.
+ ArcCompare comp_;
+};
+
+template <class Arc>
+bool Isomorphism<Arc>::IsIsomorphicState(StateId s1, StateId s2) {
+ if (!ApproxEqual(fst1_->Final(s1), fst2_->Final(s2), delta_)) return false;
+ auto narcs1 = fst1_->NumArcs(s1);
+ auto narcs2 = fst2_->NumArcs(s2);
+ if (narcs1 != narcs2) return false;
+ ArcIterator<Fst<Arc>> aiter1(*fst1_, s1);
+ ArcIterator<Fst<Arc>> aiter2(*fst2_, s2);
+ arcs1_.clear();
+ arcs1_.reserve(narcs1);
+ arcs2_.clear();
+ arcs2_.reserve(narcs2);
+ for (; !aiter1.Done(); aiter1.Next(), aiter2.Next()) {
+ arcs1_.push_back(aiter1.Value());
+ arcs2_.push_back(aiter2.Value());
+ }
+ std::sort(arcs1_.begin(), arcs1_.end(), comp_);
+ std::sort(arcs2_.begin(), arcs2_.end(), comp_);
+ for (size_t i = 0; i < arcs1_.size(); ++i) {
+ const auto &arc1 = arcs1_[i];
+ const auto &arc2 = arcs2_[i];
+ if (arc1.ilabel != arc2.ilabel) return false;
+ if (arc1.olabel != arc2.olabel) return false;
+ if (!ApproxEqual(arc1.weight, arc2.weight, delta_)) return false;
+ if (!PairState(arc1.nextstate, arc2.nextstate)) return false;
+ if (i > 0) { // Checks for non-determinism.
+ const auto &arc0 = arcs1_[i - 1];
+ if (arc1.ilabel == arc0.ilabel && arc1.olabel == arc0.olabel &&
+ ApproxEqual(arc1.weight, arc0.weight, delta_)) {
+ VLOG(1) << "Isomorphic: Non-determinism as an unweighted automaton";
+ error_ = true;
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+} // namespace internal
+
+// Tests if two FSTs have the same states and arcs up to a reordering.
+// Inputs should be non-deterministic when viewed as unweighted automata.
+template <class Arc>
+bool Isomorphic(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ float delta = kDelta) {
+ internal::Isomorphism<Arc> iso(fst1, fst2, delta);
+ bool result = iso.IsIsomorphic();
+ if (iso.Error()) {
+ FSTERROR() << "Isomorphic: Cannot determine if inputs are isomorphic";
+ return false;
+ } else {
+ return result;
+ }
+}
+
+} // namespace fst
+
+#endif // FST_LIB_ISOMORPHIC_H_
--- /dev/null
+// 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_LIB_LABEL_REACHABLE_H_
+#define FST_LIB_LABEL_REACHABLE_H_
+
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/accumulator.h>
+#include <fst/arcsort.h>
+#include <fst/interval-set.h>
+#include <fst/state-reachable.h>
+#include <fst/util.h>
+#include <fst/vector-fst.h>
+
+
+namespace fst {
+
+// Stores shareable data for label reachable class copies.
+template <typename Label>
+class LabelReachableData {
+ public:
+ using LabelIntervalSet = IntervalSet<Label>;
+ using Interval = typename LabelIntervalSet::Interval;
+
+ explicit LabelReachableData(bool reach_input, bool keep_relabel_data = true)
+ : reach_input_(reach_input),
+ keep_relabel_data_(keep_relabel_data),
+ have_relabel_data_(true),
+ final_label_(kNoLabel) {}
+
+ ~LabelReachableData() {}
+
+ bool ReachInput() const { return reach_input_; }
+
+ std::vector<LabelIntervalSet> *MutableIntervalSets() {
+ return &interval_sets_;
+ }
+
+ const LabelIntervalSet &GetIntervalSet(int s) const {
+ return interval_sets_[s];
+ }
+
+ int NumIntervalSets() const { return interval_sets_.size(); }
+
+ std::unordered_map<Label, Label> *Label2Index() {
+ if (!have_relabel_data_) {
+ FSTERROR() << "LabelReachableData: No relabeling data";
+ }
+ return &label2index_;
+ }
+
+ void SetFinalLabel(Label final_label) { final_label_ = final_label; }
+
+ Label FinalLabel() const { return final_label_; }
+
+ static LabelReachableData<Label> *Read(std::istream &istrm,
+ const FstReadOptions &opts) {
+ auto *data = new LabelReachableData<Label>();
+ ReadType(istrm, &data->reach_input_);
+ ReadType(istrm, &data->keep_relabel_data_);
+ data->have_relabel_data_ = data->keep_relabel_data_;
+ if (data->keep_relabel_data_) ReadType(istrm, &data->label2index_);
+ ReadType(istrm, &data->final_label_);
+ ReadType(istrm, &data->interval_sets_);
+ return data;
+ }
+
+ bool Write(std::ostream &ostrm, const FstWriteOptions &opts) const {
+ WriteType(ostrm, reach_input_);
+ WriteType(ostrm, keep_relabel_data_);
+ if (keep_relabel_data_) WriteType(ostrm, label2index_);
+ WriteType(ostrm, FinalLabel());
+ WriteType(ostrm, interval_sets_);
+ return true;
+ }
+
+ private:
+ LabelReachableData() {}
+
+ bool reach_input_; // Input labels considered?
+ bool keep_relabel_data_; // Save label2index_ to file?
+ bool have_relabel_data_; // Using label2index_?
+ Label final_label_; // Final label.
+ std::unordered_map<Label, Label> label2index_; // Finds index for a label.
+ std::vector<LabelIntervalSet> interval_sets_; // Interval sets per state.
+};
+
+// Tests reachability of labels from a given state. If reach_input is true, then
+// input labels are considered, o.w. output labels are considered. To test for
+// reachability from a state s, first do SetState(s), then a label l can be
+// reached from state s of FST f iff Reach(r) is true where r = Relabel(l). The
+// relabeling is required to ensure a compact representation of the reachable
+// labels.
+
+// The whole FST can be relabeled instead with Relabel(&f, reach_input) so that
+// the test Reach(r) applies directly to the labels of the transformed FST f.
+// The relabeled FST will also be sorted appropriately for composition.
+//
+// Reachablity of a final state from state s (via an epsilon path) can be
+// tested with ReachFinal().
+//
+// Reachability can also be tested on the set of labels specified by an arc
+// iterator, useful for FST composition. In particular, Reach(aiter, ...) is
+// true if labels on the input (output) side of the transitions of the arc
+// iterator, when iter_input is true (false), can be reached from the state s.
+// The iterator labels must have already been relabeled.
+//
+// With the arc iterator test of reachability, the begin position, end position
+// and accumulated arc weight of the matches can be returned. The optional
+// template argument controls how reachable arc weights are accumulated. The
+// default uses semiring Plus(). Alternative ones can be used to distribute the
+// weights in composition in various ways.
+template <class Arc, class Accumulator = DefaultAccumulator<Arc>,
+ class D = LabelReachableData<typename Arc::Label>>
+class LabelReachable {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using Data = D;
+
+ using LabelIntervalSet = typename Data::LabelIntervalSet;
+
+ using Interval = typename LabelIntervalSet::Interval;
+
+ LabelReachable(const Fst<Arc> &fst, bool reach_input,
+ Accumulator *accumulator = nullptr,
+ bool keep_relabel_data = true)
+ : fst_(new VectorFst<Arc>(fst)),
+ s_(kNoStateId),
+ data_(std::make_shared<Data>(reach_input, keep_relabel_data)),
+ accumulator_(accumulator ? accumulator : new Accumulator()),
+ ncalls_(0),
+ nintervals_(0),
+ reach_fst_input_(false),
+ error_(false) {
+ const auto ins = fst_->NumStates();
+ TransformFst();
+ FindIntervals(ins);
+ fst_.reset();
+ }
+
+ explicit LabelReachable(std::shared_ptr<Data> data,
+ Accumulator *accumulator = nullptr)
+ : s_(kNoStateId),
+ data_(std::move(data)),
+ accumulator_(accumulator ? accumulator : new Accumulator()),
+ ncalls_(0),
+ nintervals_(0),
+ reach_fst_input_(false),
+ error_(false) {}
+
+ LabelReachable(const LabelReachable<Arc, Accumulator, Data> &reachable,
+ bool safe = false)
+ : s_(kNoStateId),
+ data_(reachable.data_),
+ accumulator_(new Accumulator(*reachable.accumulator_, safe)),
+ ncalls_(0),
+ nintervals_(0),
+ reach_fst_input_(reachable.reach_fst_input_),
+ error_(reachable.error_) {}
+
+ ~LabelReachable() {
+ if (ncalls_ > 0) {
+ VLOG(2) << "# of calls: " << ncalls_;
+ VLOG(2) << "# of intervals/call: " << (nintervals_ / ncalls_);
+ }
+ }
+
+ // Relabels w.r.t labels that give compact label sets.
+ Label Relabel(Label label) {
+ if (label == 0 || error_) return label;
+ auto &label2index = *data_->Label2Index();
+ auto &relabel = label2index[label];
+ if (!relabel) relabel = label2index.size() + 1; // Adds new label.
+ return relabel;
+ }
+
+ // Relabels FST w.r.t to labels that give compact label sets.
+ void Relabel(MutableFst<Arc> *fst, bool relabel_input) {
+ for (StateIterator<MutableFst<Arc>> siter(*fst); !siter.Done();
+ siter.Next()) {
+ for (MutableArcIterator<MutableFst<Arc>> aiter(fst, siter.Value());
+ !aiter.Done(); aiter.Next()) {
+ auto arc = aiter.Value();
+ if (relabel_input) {
+ arc.ilabel = Relabel(arc.ilabel);
+ } else {
+ arc.olabel = Relabel(arc.olabel);
+ }
+ aiter.SetValue(arc);
+ }
+ }
+ if (relabel_input) {
+ ArcSort(fst, ILabelCompare<Arc>());
+ fst->SetInputSymbols(nullptr);
+ } else {
+ ArcSort(fst, OLabelCompare<Arc>());
+ fst->SetOutputSymbols(nullptr);
+ }
+ }
+
+ // Returns relabeling pairs (cf. relabel.h::Relabel()). If avoid_collisions is
+ // true, extra pairs are added to ensure no collisions when relabeling
+ // automata that have labels unseen here.
+ void RelabelPairs(std::vector<std::pair<Label, Label>> *pairs,
+ bool avoid_collisions = false) {
+ pairs->clear();
+ const auto &label2index = *data_->Label2Index();
+ // Maps labels to their new values in [1, label2index().size()].
+ for (auto it = label2index.begin(); it != label2index.end(); ++it) {
+ if (it->second != data_->FinalLabel()) {
+ pairs->push_back(std::make_pair(it->first, it->second));
+ }
+ }
+ if (avoid_collisions) {
+ // Ensures any label in [1, label2index().size()] is mapped either
+ // by the above step or to label2index() + 1 (to avoid collisions).
+ for (size_t i = 1; i <= label2index.size(); ++i) {
+ const auto it = label2index.find(i);
+ if (it == label2index.end() || it->second == data_->FinalLabel()) {
+ pairs->push_back(std::make_pair(i, label2index.size() + 1));
+ }
+ }
+ }
+ }
+
+ // Set current state. Optionally set state associated
+ // with arc iterator to be passed to Reach.
+ void SetState(StateId s, StateId aiter_s = kNoStateId) {
+ s_ = s;
+ if (aiter_s != kNoStateId) {
+ accumulator_->SetState(aiter_s);
+ if (accumulator_->Error()) error_ = true;
+ }
+ }
+
+ // Can reach this label from current state?
+ // Original labels must be transformed by the Relabel methods above.
+ bool Reach(Label label) const {
+ if (label == 0 || error_) return false;
+ return data_->GetIntervalSet(s_).Member(label);
+ }
+
+ // Can reach final state (via epsilon transitions) from this state?
+ bool ReachFinal() const {
+ if (error_) return false;
+ return data_->GetIntervalSet(s_).Member(data_->FinalLabel());
+ }
+
+ // Initialize with secondary FST to be used with Reach(Iterator,...).
+ // If reach_input = true, then arc input labels are considered in
+ // Reach(aiter, ...), o.w. output labels are considered. If copy is true, then
+ // the FST is a copy of the FST used in the previous call to this method
+ // (useful to avoid unnecessary updates).
+ template <class FST>
+ void ReachInit(const FST &fst, bool reach_input, bool copy = false) {
+ reach_fst_input_ = reach_input;
+ if (!fst.Properties(reach_fst_input_ ? kILabelSorted : kOLabelSorted,
+ true)) {
+ FSTERROR() << "LabelReachable::ReachInit: Fst is not sorted";
+ error_ = true;
+ }
+ accumulator_->Init(fst, copy);
+ if (accumulator_->Error()) error_ = true;
+ }
+
+ // Can reach any arc iterator label between iterator positions
+ // aiter_begin and aiter_end?
+ // Arc iterator labels must be transformed by the Relabel methods
+ // above. If compute_weight is true, user may call ReachWeight().
+ template <class Iterator>
+ bool Reach(Iterator *aiter, ssize_t aiter_begin, ssize_t aiter_end,
+ bool compute_weight) {
+ if (error_) return false;
+ const auto &interval_set = data_->GetIntervalSet(s_);
+ ++ncalls_;
+ nintervals_ += interval_set.Size();
+ reach_begin_ = -1;
+ reach_end_ = -1;
+ reach_weight_ = Weight::Zero();
+ const auto flags = aiter->Flags(); // Save flags to restore them on exit.
+ aiter->SetFlags(kArcNoCache, kArcNoCache); // Makes caching optional.
+ aiter->Seek(aiter_begin);
+ if (2 * (aiter_end - aiter_begin) < interval_set.Size()) {
+ // Checks each arc against intervals, setting arc iterator flags to only
+ // compute the ilabel or olabel values, since they are the only values
+ // required for most of the arcs processed.
+ aiter->SetFlags(reach_fst_input_ ? kArcILabelValue : kArcOLabelValue,
+ kArcValueFlags);
+ Label reach_label = kNoLabel;
+ for (auto aiter_pos = aiter_begin; aiter_pos < aiter_end;
+ aiter->Next(), ++aiter_pos) {
+ const auto &arc = aiter->Value();
+ const auto label = reach_fst_input_ ? arc.ilabel : arc.olabel;
+ if (label == reach_label || Reach(label)) {
+ reach_label = label;
+ if (reach_begin_ < 0) reach_begin_ = aiter_pos;
+ reach_end_ = aiter_pos + 1;
+ if (compute_weight) {
+ if (!(aiter->Flags() & kArcWeightValue)) {
+ // If arc.weight wasn't computed by the call to aiter->Value()
+ // above, we need to call aiter->Value() again after having set
+ // the arc iterator flags to compute the arc weight value.
+ aiter->SetFlags(kArcWeightValue, kArcValueFlags);
+ const auto &arcb = aiter->Value();
+ // Call the accumulator.
+ reach_weight_ = accumulator_->Sum(reach_weight_, arcb.weight);
+ // Only ilabel or olabel required to process the following arcs.
+ aiter->SetFlags(
+ reach_fst_input_ ? kArcILabelValue : kArcOLabelValue,
+ kArcValueFlags);
+ } else {
+ // Calls the accumulator.
+ reach_weight_ = accumulator_->Sum(reach_weight_, arc.weight);
+ }
+ }
+ }
+ }
+ } else {
+ // Checks each interval against arcs.
+ auto begin_low = aiter_begin;
+ auto end_low = aiter_begin;
+ for (const auto &interval : interval_set) {
+ begin_low = LowerBound(aiter, end_low, aiter_end, interval.begin);
+ end_low = LowerBound(aiter, begin_low, aiter_end, interval.end);
+ if (end_low - begin_low > 0) {
+ if (reach_begin_ < 0) reach_begin_ = begin_low;
+ reach_end_ = end_low;
+ if (compute_weight) {
+ aiter->SetFlags(kArcWeightValue, kArcValueFlags);
+ reach_weight_ =
+ accumulator_->Sum(reach_weight_, aiter, begin_low, end_low);
+ }
+ }
+ }
+ }
+ aiter->SetFlags(flags, kArcFlags); // Restores original flag values.
+ return reach_begin_ >= 0;
+ }
+
+ // Returns iterator position of first matching arc.
+ ssize_t ReachBegin() const { return reach_begin_; }
+
+ // Returns iterator position one past last matching arc.
+ ssize_t ReachEnd() const { return reach_end_; }
+
+ // Return the sum of the weights for matching arcs. Valid only if
+ // compute_weight was true in Reach() call.
+ Weight ReachWeight() const { return reach_weight_; }
+
+ // Access to the relabeling map. Excludes epsilon (0) label but
+ // includes kNoLabel that is used internally for super-final
+ // transitons.
+ const std::unordered_map<Label, Label> &Label2Index() const {
+ return *data_->Label2Index();
+ }
+
+ const Data *GetData() const { return data_.get(); }
+
+ std::shared_ptr<Data> GetSharedData() const { return data_; }
+
+ bool Error() const { return error_ || accumulator_->Error(); }
+
+ private:
+ // Redirects labeled arcs (input or output labels determined by ReachInput())
+ // to new label-specific final states. Each original final state is
+ // redirected via a transition labeled with kNoLabel to a new
+ // kNoLabel-specific final state. Creates super-initial state for all states
+ // with zero in-degree.
+ void TransformFst() {
+ auto ins = fst_->NumStates();
+ auto ons = ins;
+ std::vector<ssize_t> indeg(ins, 0);
+ // Redirects labeled arcs to new final states.
+ for (StateId s = 0; s < ins; ++s) {
+ for (MutableArcIterator<VectorFst<Arc>> aiter(fst_.get(), s);
+ !aiter.Done(); aiter.Next()) {
+ auto arc = aiter.Value();
+ const auto label = data_->ReachInput() ? arc.ilabel : arc.olabel;
+ if (label) {
+ auto insert_result = label2state_.insert(std::make_pair(label, ons));
+ if (insert_result.second) {
+ indeg.push_back(0);
+ ++ons;
+ }
+ arc.nextstate = label2state_[label];
+ aiter.SetValue(arc);
+ }
+ ++indeg[arc.nextstate]; // Finds in-degrees for next step.
+ }
+ // Redirects final weights to new final state.
+ const auto final_weight = fst_->Final(s);
+ if (final_weight != Weight::Zero()) {
+ auto insert_result = label2state_.insert(std::make_pair(kNoLabel, ons));
+ if (insert_result.second) {
+ indeg.push_back(0);
+ ++ons;
+ }
+ Arc arc(kNoLabel, kNoLabel, final_weight, label2state_[kNoLabel]);
+ fst_->AddArc(s, arc);
+ ++indeg[arc.nextstate]; // Finds in-degrees for next step.
+ fst_->SetFinal(s, Weight::Zero());
+ }
+ }
+ // Adds new final states to the FST.
+ while (fst_->NumStates() < ons) {
+ StateId s = fst_->AddState();
+ fst_->SetFinal(s, Weight::One());
+ }
+ // Creates a super-initial state for all states with zero in-degree.
+ const auto start = fst_->AddState();
+ fst_->SetStart(start);
+ for (StateId s = 0; s < start; ++s) {
+ if (indeg[s] == 0) {
+ Arc arc(0, 0, Weight::One(), s);
+ fst_->AddArc(start, arc);
+ }
+ }
+ }
+
+ void FindIntervals(StateId ins) {
+ StateReachable<Arc, Label, LabelIntervalSet> state_reachable(*fst_);
+ if (state_reachable.Error()) {
+ error_ = true;
+ return;
+ }
+ auto &state2index = state_reachable.State2Index();
+ auto &interval_sets = *data_->MutableIntervalSets();
+ interval_sets = state_reachable.IntervalSets();
+ interval_sets.resize(ins);
+ auto &label2index = *data_->Label2Index();
+ for (const auto &kv : label2state_) {
+ Label i = state2index[kv.second];
+ label2index[kv.first] = i;
+ if (kv.first == kNoLabel) data_->SetFinalLabel(i);
+ }
+ label2state_.clear();
+ double nintervals = 0;
+ ssize_t non_intervals = 0;
+ for (StateId s = 0; s < ins; ++s) {
+ nintervals += interval_sets[s].Size();
+ if (interval_sets[s].Size() > 1) {
+ ++non_intervals;
+ VLOG(3) << "state: " << s
+ << " # of intervals: " << interval_sets[s].Size();
+ }
+ }
+ VLOG(2) << "# of states: " << ins;
+ VLOG(2) << "# of intervals: " << nintervals;
+ VLOG(2) << "# of intervals/state: " << nintervals / ins;
+ VLOG(2) << "# of non-interval states: " << non_intervals;
+ }
+
+ template <class Iterator>
+ ssize_t LowerBound(Iterator *aiter, ssize_t aiter_begin, ssize_t aiter_end,
+ Label match_label) const {
+ // Only needs to compute the ilabel or olabel of arcs when performing the
+ // binary search.
+ aiter->SetFlags(reach_fst_input_ ? kArcILabelValue : kArcOLabelValue,
+ kArcValueFlags);
+ ssize_t low = aiter_begin;
+ ssize_t high = aiter_end;
+ while (low < high) {
+ ssize_t mid = (low + high) / 2;
+ aiter->Seek(mid);
+ auto label =
+ reach_fst_input_ ? aiter->Value().ilabel : aiter->Value().olabel;
+ if (label > match_label) {
+ high = mid;
+ } else if (label < match_label) {
+ low = mid + 1;
+ } else {
+ // Finds first matching label (when non-deterministic).
+ for (ssize_t i = mid; i > low; --i) {
+ aiter->Seek(i - 1);
+ label =
+ reach_fst_input_ ? aiter->Value().ilabel : aiter->Value().olabel;
+ if (label != match_label) {
+ aiter->Seek(i);
+ aiter->SetFlags(kArcValueFlags, kArcValueFlags);
+ return i;
+ }
+ }
+ aiter->SetFlags(kArcValueFlags, kArcValueFlags);
+ return low;
+ }
+ }
+ aiter->Seek(low);
+ aiter->SetFlags(kArcValueFlags, kArcValueFlags);
+ return low;
+ }
+
+ std::unique_ptr<VectorFst<Arc>> fst_;
+ // Current state
+ StateId s_;
+ // Finds final state for a label
+ std::unordered_map<Label, StateId> label2state_;
+ // Iterator position of first match.
+ ssize_t reach_begin_;
+ // Iterator position after last match.
+ ssize_t reach_end_;
+ // Gives weight sum of arc iterator arcs with reachable labels.
+ Weight reach_weight_;
+ // Shareable data between copies.
+ std::shared_ptr<Data> data_;
+ // Sums arc weights.
+ std::unique_ptr<Accumulator> accumulator_;
+ double ncalls_;
+ double nintervals_;
+ bool reach_fst_input_;
+ bool error_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_LABEL_REACHABLE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Lexicographic weight set and associated semiring operation definitions.
+//
+// A lexicographic weight is a sequence of weights, each of which must have the
+// path property and Times() must be (strongly) cancellative
+// (for all a,b,c != Zero(): Times(c, a) = Times(c, b) => a = b,
+// Times(a, c) = Times(b, c) => a = b).
+// The + operation on two weights a and b is the lexicographically
+// prior of a and b.
+
+#ifndef FST_LIB_LEXICOGRAPHIC_WEIGHT_H_
+#define FST_LIB_LEXICOGRAPHIC_WEIGHT_H_
+
+#include <cstdlib>
+
+#include <string>
+
+#include <fst/pair-weight.h>
+#include <fst/weight.h>
+
+
+namespace fst {
+
+template <class W1, class W2>
+class LexicographicWeight : public PairWeight<W1, W2> {
+ public:
+ using ReverseWeight = LexicographicWeight<typename W1::ReverseWeight,
+ typename W2::ReverseWeight>;
+
+ using PairWeight<W1, W2>::Value1;
+ using PairWeight<W1, W2>::Value2;
+ using PairWeight<W1, W2>::SetValue1;
+ using PairWeight<W1, W2>::SetValue2;
+ using PairWeight<W1, W2>::Zero;
+ using PairWeight<W1, W2>::One;
+ using PairWeight<W1, W2>::NoWeight;
+ using PairWeight<W1, W2>::Quantize;
+ using PairWeight<W1, W2>::Reverse;
+
+ LexicographicWeight() {}
+
+ explicit LexicographicWeight(const PairWeight<W1, W2> &w)
+ : PairWeight<W1, W2>(w) {}
+
+ LexicographicWeight(W1 w1, W2 w2) : PairWeight<W1, W2>(w1, w2) {
+ if ((W1::Properties() & kPath) != kPath) {
+ FSTERROR() << "LexicographicWeight must "
+ << "have the path property: " << W1::Type();
+ SetValue1(W1::NoWeight());
+ }
+ if ((W2::Properties() & kPath) != kPath) {
+ FSTERROR() << "LexicographicWeight must "
+ << "have the path property: " << W2::Type();
+ SetValue2(W2::NoWeight());
+ }
+ }
+
+ static const LexicographicWeight &Zero() {
+ static const LexicographicWeight zero(PairWeight<W1, W2>::Zero());
+ return zero;
+ }
+
+ static const LexicographicWeight &One() {
+ static const LexicographicWeight one(PairWeight<W1, W2>::One());
+ return one;
+ }
+
+ static const LexicographicWeight &NoWeight() {
+ static const LexicographicWeight no_weight(PairWeight<W1, W2>::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type = W1::Type() + "_LT_" + W2::Type();
+ return type;
+ }
+
+ bool Member() const {
+ if (!Value1().Member() || !Value2().Member()) return false;
+ // Lexicographic weights cannot mix zeroes and non-zeroes.
+ if (Value1() == W1::Zero() && Value2() == W2::Zero()) return true;
+ if (Value1() != W1::Zero() && Value2() != W2::Zero()) return true;
+ return false;
+ }
+
+ LexicographicWeight Quantize(float delta = kDelta) const {
+ return LexicographicWeight(PairWeight<W1, W2>::Quantize());
+ }
+
+ ReverseWeight Reverse() const {
+ return ReverseWeight(PairWeight<W1, W2>::Reverse());
+ }
+
+ static constexpr uint64 Properties() {
+ return W1::Properties() & W2::Properties() &
+ (kLeftSemiring | kRightSemiring | kPath | kIdempotent |
+ kCommutative);
+ }
+};
+
+template <class W1, class W2>
+inline LexicographicWeight<W1, W2> Plus(const LexicographicWeight<W1, W2> &w,
+ const LexicographicWeight<W1, W2> &v) {
+ if (!w.Member() || !v.Member()) {
+ return LexicographicWeight<W1, W2>::NoWeight();
+ }
+ NaturalLess<W1> less1;
+ NaturalLess<W2> less2;
+ if (less1(w.Value1(), v.Value1())) return w;
+ if (less1(v.Value1(), w.Value1())) return v;
+ if (less2(w.Value2(), v.Value2())) return w;
+ if (less2(v.Value2(), w.Value2())) return v;
+ return w;
+}
+
+template <class W1, class W2>
+inline LexicographicWeight<W1, W2> Times(const LexicographicWeight<W1, W2> &w,
+ const LexicographicWeight<W1, W2> &v) {
+ return LexicographicWeight<W1, W2>(Times(w.Value1(), v.Value1()),
+ Times(w.Value2(), v.Value2()));
+}
+
+template <class W1, class W2>
+inline LexicographicWeight<W1, W2> Divide(const LexicographicWeight<W1, W2> &w,
+ const LexicographicWeight<W1, W2> &v,
+ DivideType typ = DIVIDE_ANY) {
+ return LexicographicWeight<W1, W2>(Divide(w.Value1(), v.Value1(), typ),
+ Divide(w.Value2(), v.Value2(), typ));
+}
+
+// This function object generates weights by calling the underlying generators
+// for the templated weight types, like all other pair weight types. However,
+// for lexicographic weights, we cannot generate zeroes for the two subweights
+// separately: weights are members iff both members are zero or both members
+// are non-zero. This is intended primarily for testing.
+template <class W1, class W2>
+class WeightGenerate<LexicographicWeight<W1, W2>> {
+ public:
+ using Weight = LexicographicWeight<W1, W1>;
+ using Generate1 = WeightGenerate<W1>;
+ using Generate2 = WeightGenerate<W2>;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t num_random_weights = kNumRandomWeights)
+ : generator1_(false, num_random_weights),
+ generator2_(false, num_random_weights), allow_zero_(allow_zero),
+ num_random_weights_(num_random_weights) {}
+
+ Weight operator()() const {
+ if (allow_zero_) {
+ const int n = rand() % (num_random_weights_ + 1); // NOLINT
+ if (n == num_random_weights_) return Weight(W1::Zero(), W2::Zero());
+ }
+ return Weight(generator1_(), generator2_());
+ }
+
+ private:
+ const Generate1 generator1_;
+ const Generate2 generator2_;
+ // Permits Zero() and zero divisors.
+ const bool allow_zero_;
+ // The number of alternative random weights.
+ const size_t num_random_weights_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_LEXICOGRAPHIC_WEIGHT_H_
--- /dev/null
+// 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.
+//
+// Google-compatibility locking declarations and inline definitions.
+
+#ifndef FST_LIB_LOCK_H_
+#define FST_LIB_LOCK_H_
+
+#include <mutex>
+
+namespace fst {
+
+using namespace std;
+
+class Mutex {
+ public:
+ Mutex() {}
+
+ inline void Lock() { mu_.lock(); }
+
+ inline void Unlock() { mu_.unlock(); }
+
+ private:
+ std::mutex mu_;
+
+ Mutex(const Mutex &) = delete;
+ Mutex &operator=(const Mutex &) = delete;
+};
+
+class MutexLock {
+ public:
+ explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
+
+ ~MutexLock() { mu_->Unlock(); }
+
+ private:
+ Mutex *mu_;
+
+ MutexLock(const MutexLock &) = delete;
+ MutexLock &operator=(const MutexLock &) = delete;
+};
+
+// Currently, we don't use a separate reader lock.
+// TODO(kbg): Implement this with std::shared_mutex once C++17 becomes widely
+// available.
+using ReaderMutexLock = MutexLock;
+
+} // namespace fst
+
+#endif // FST_LIB_LOCK_H_
--- /dev/null
+// 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.
+//
+// Google-style logging declarations and inline definitions.
+
+#ifndef FST_LIB_LOG_H_
+#define FST_LIB_LOG_H_
+
+#include <cassert>
+#include <iostream>
+#include <string>
+
+#include <fst/types.h>
+#include <fst/flags.h>
+
+using std::string;
+
+DECLARE_int32(v);
+
+class LogMessage {
+ public:
+ LogMessage(const string &type) : fatal_(type == "FATAL") {
+ std::cerr << type << ": ";
+ }
+ ~LogMessage() {
+ std::cerr << std::endl;
+ if(fatal_)
+ exit(1);
+ }
+ std::ostream &stream() { return std::cerr; }
+
+ private:
+ bool fatal_;
+};
+
+#define LOG(type) LogMessage(#type).stream()
+#define VLOG(level) if ((level) <= FLAGS_v) LOG(INFO)
+
+// Checks
+inline void FstCheck(bool x, const char* expr,
+ const char *file, int line) {
+ if (!x) {
+ LOG(FATAL) << "Check failed: \"" << expr
+ << "\" file: " << file
+ << " line: " << line;
+ }
+}
+
+#define CHECK(x) FstCheck(static_cast<bool>(x), #x, __FILE__, __LINE__)
+#define CHECK_EQ(x, y) CHECK((x) == (y))
+#define CHECK_LT(x, y) CHECK((x) < (y))
+#define CHECK_GT(x, y) CHECK((x) > (y))
+#define CHECK_LE(x, y) CHECK((x) <= (y))
+#define CHECK_GE(x, y) CHECK((x) >= (y))
+#define CHECK_NE(x, y) CHECK((x) != (y))
+
+// Debug checks
+#define DCHECK(x) assert(x)
+#define DCHECK_EQ(x, y) DCHECK((x) == (y))
+#define DCHECK_LT(x, y) DCHECK((x) < (y))
+#define DCHECK_GT(x, y) DCHECK((x) > (y))
+#define DCHECK_LE(x, y) DCHECK((x) <= (y))
+#define DCHECK_GE(x, y) DCHECK((x) >= (y))
+#define DCHECK_NE(x, y) DCHECK((x) != (y))
+
+
+// Ports
+#define ATTRIBUTE_DEPRECATED __attribute__((deprecated))
+
+#endif // FST_LIB_LOG_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Composition filters to support lookahead matchers, useful for improving
+// composition efficiency with certain inputs.
+
+#ifndef FST_LIB_LOOKAHEAD_FILTER_H_
+#define FST_LIB_LOOKAHEAD_FILTER_H_
+
+#include <vector>
+
+#include <fst/filter-state.h>
+#include <fst/fst.h>
+#include <fst/lookahead-matcher.h>
+
+
+namespace fst {
+
+// Identifies and verifies the capabilities of the matcher to be used for
+// lookahead with the composition filters below. This version is passed two
+// matchers.
+template <class Matcher1, class Matcher2>
+MatchType LookAheadMatchType(const Matcher1 &m1, const Matcher2 &m2) {
+ const auto type1 = m1.Type(false);
+ const auto type2 = m2.Type(false);
+ if (type1 == MATCH_OUTPUT && m1.Flags() & kOutputLookAheadMatcher) {
+ return MATCH_OUTPUT;
+ } else if (type2 == MATCH_INPUT && m2.Flags() & kInputLookAheadMatcher) {
+ return MATCH_INPUT;
+ } else if (m1.Flags() & kOutputLookAheadMatcher &&
+ m1.Type(true) == MATCH_OUTPUT) {
+ return MATCH_OUTPUT;
+ } else if (m2.Flags() & kInputLookAheadMatcher &&
+ m2.Type(true) == MATCH_INPUT) {
+ return MATCH_INPUT;
+ } else {
+ return MATCH_NONE;
+ }
+}
+
+// Identifies and verifies the capabilities of the matcher to be used for
+// lookahead with the composition filters below. This version uses the FST's
+// default matchers.
+template <class Arc>
+MatchType LookAheadMatchType(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {
+ LookAheadMatcher<Fst<Arc>> matcher1(fst1, MATCH_OUTPUT);
+ LookAheadMatcher<Fst<Arc>> matcher2(fst2, MATCH_INPUT);
+ return LookAheadMatchType(matcher1, matcher2);
+}
+
+// LookAheadSelector is a helper class for selecting among possibly distinct
+// FST and matcher types without using a common base class. This lets us avoid
+// virtual function calls. It stores and returns the appropriate FSTs and
+// matcher for lookahead. It is templated on the matcher types. General case
+// has no methods.
+template <class Matcher1, class Matcher2, MatchType MT>
+class LookAheadSelector {};
+
+// Stores and returns the appropriate FST and matcher for lookahead. Specialized
+// for two matchers of same type with the (match) type argument determining
+// which is used for lookahead.
+template <class Matcher, MatchType MT>
+class LookAheadSelector<Matcher, Matcher, MT> {
+ public:
+ using FST = typename Matcher::FST;
+
+ LookAheadSelector(Matcher *lmatcher1, Matcher *lmatcher2, MatchType type)
+ : lmatcher1_(lmatcher1->Copy()),
+ lmatcher2_(lmatcher2->Copy()),
+ type_(type) {}
+
+ LookAheadSelector(const LookAheadSelector<Matcher, Matcher, MT> &selector)
+ : lmatcher1_(selector.lmatcher1_->Copy()),
+ lmatcher2_(selector.lmatcher2_->Copy()),
+ type_(selector.type_) {}
+
+ const FST &GetFst() const {
+ return type_ == MATCH_OUTPUT ? lmatcher2_->GetFst() : lmatcher1_->GetFst();
+ }
+
+ Matcher *GetMatcher() const {
+ return type_ == MATCH_OUTPUT ? lmatcher1_.get() : lmatcher2_.get();
+ }
+
+ private:
+ std::unique_ptr<Matcher> lmatcher1_;
+ std::unique_ptr<Matcher> lmatcher2_;
+ MatchType type_;
+};
+
+// Stores and returns the appropriate FST and matcher for lookahead.
+// Specialized for lookahead on input labels.
+template <class Matcher1, class Matcher2>
+class LookAheadSelector<Matcher1, Matcher2, MATCH_INPUT> {
+ public:
+ using FST1 = typename Matcher1::FST;
+
+ LookAheadSelector(Matcher1 *lmatcher1, Matcher2 *lmatcher2, MatchType)
+ : fst_(lmatcher1->GetFst().Copy()), lmatcher_(lmatcher2->Copy()) {}
+
+ LookAheadSelector(
+ const LookAheadSelector<Matcher1, Matcher2, MATCH_INPUT> &selector)
+ : fst_(selector.fst_->Copy()), lmatcher_(selector.lmatcher_->Copy()) {}
+
+ const FST1 &GetFst() const { return *fst_; }
+
+ Matcher2 *GetMatcher() const { return lmatcher_.get(); }
+
+ private:
+ std::unique_ptr<const FST1> fst_;
+ std::unique_ptr<Matcher2> lmatcher_;
+};
+
+// Stores and returns the appropriate FST and matcher for lookahead.
+// Specialized for lookahead on output labels.
+template <class Matcher1, class Matcher2>
+class LookAheadSelector<Matcher1, Matcher2, MATCH_OUTPUT> {
+ public:
+ using FST2 = typename Matcher2::FST;
+
+ LookAheadSelector(Matcher1 *lmatcher1, Matcher2 *lmatcher2, MatchType)
+ : fst_(lmatcher2->GetFst().Copy()), lmatcher_(lmatcher1->Copy()) {}
+
+ LookAheadSelector(
+ const LookAheadSelector<Matcher1, Matcher2, MATCH_OUTPUT> &selector)
+ : fst_(selector.fst_->Copy()), lmatcher_(selector.lmatcher_->Copy()) {}
+
+ const FST2 &GetFst() const { return *fst_; }
+
+ Matcher1 *GetMatcher() const { return lmatcher_.get(); }
+
+ private:
+ std::unique_ptr<const FST2> fst_;
+ std::unique_ptr<Matcher1> lmatcher_;
+};
+
+// This filter uses a lookahead matcher in FilterArc(arc1, arc2) to examine the
+// future of the composition state (arc1.nextstate, arc2.nextstate), blocking
+// moving forward when its determined to be
+// non-coaccessible. It is templated on an underlying filter, typically the
+// epsilon filter. Which matcher is the lookahead matcher is determined by the
+// template argument MT unless it is MATCH_BOTH. In that case, both matcher
+// arguments must be lookahead matchers of the same type and one will be
+// selected by LookAheadMatchType() based on their capability.
+template <class Filter, class M1 = LookAheadMatcher<typename Filter::FST1>,
+ class M2 = M1, MatchType MT = MATCH_BOTH>
+class LookAheadComposeFilter {
+ public:
+ using Arc = typename Filter::Arc;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FST1 = typename Filter::FST1;
+ using FST2 = typename Filter::FST2;
+ using Matcher1 = typename Filter::Matcher1;
+ using Matcher2 = typename Filter::Matcher2;
+ using FilterState = typename Filter::FilterState;
+
+ LookAheadComposeFilter(const FST1 &fst1, const FST2 &fst2, M1 *matcher1,
+ M2 *matcher2)
+ : filter_(fst1, fst2, matcher1, matcher2),
+ lookahead_type_(MT == MATCH_BOTH
+ ? LookAheadMatchType(*filter_.GetMatcher1(),
+ *filter_.GetMatcher2())
+ : MT),
+ selector_(filter_.GetMatcher1(), filter_.GetMatcher2(),
+ lookahead_type_),
+ flags_(lookahead_type_ == MATCH_OUTPUT
+ ? filter_.GetMatcher1()->Flags()
+ : filter_.GetMatcher2()->Flags()) {
+ if (lookahead_type_ == MATCH_NONE) {
+ FSTERROR() << "LookAheadComposeFilter: 1st argument cannot "
+ << "match/look-ahead on output labels and 2nd argument "
+ << "cannot match/look-ahead on input labels";
+ }
+ selector_.GetMatcher()->InitLookAheadFst(selector_.GetFst());
+ }
+
+ LookAheadComposeFilter(
+ const LookAheadComposeFilter<Filter, M1, M2, MT> &filter,
+ bool safe = false)
+ : filter_(filter.filter_, safe),
+ lookahead_type_(filter.lookahead_type_),
+ selector_(filter_.GetMatcher1(), filter_.GetMatcher2(),
+ lookahead_type_),
+ flags_(filter.flags_) {
+ selector_.GetMatcher()->InitLookAheadFst(selector_.GetFst(), true);
+ }
+
+ FilterState Start() const { return filter_.Start(); }
+
+ void SetState(StateId s1, StateId s2, const FilterState &fs) {
+ filter_.SetState(s1, s2, fs);
+ }
+
+ FilterState FilterArc(Arc *arc1, Arc *arc2) const {
+ lookahead_arc_ = false;
+ const FilterState &fs = filter_.FilterArc(arc1, arc2);
+ if (fs == FilterState::NoState()) return FilterState::NoState();
+ return LookAheadOutput() ? LookAheadFilterArc(arc1, arc2, fs)
+ : LookAheadFilterArc(arc2, arc1, fs);
+ }
+
+ void FilterFinal(Weight *weight1, Weight *weight2) const {
+ filter_.FilterFinal(weight1, weight2);
+ }
+
+ // Returns matchers; ownership stays with filter.
+
+ Matcher1 *GetMatcher1() { return filter_.GetMatcher1(); }
+
+ Matcher2 *GetMatcher2() { return filter_.GetMatcher2(); }
+
+ const LookAheadSelector<Matcher1, Matcher2, MT> &Selector() const {
+ return selector_;
+ }
+
+ uint64 Properties(uint64 inprops) const {
+ auto outprops = filter_.Properties(inprops);
+ if (lookahead_type_ == MATCH_NONE) outprops |= kError;
+ return outprops;
+ }
+
+ uint32 LookAheadFlags() const { return flags_; }
+
+ bool LookAheadArc() const { return lookahead_arc_; }
+
+ bool LookAheadOutput() const {
+ if (MT == MATCH_OUTPUT) {
+ return true;
+ } else if (MT == MATCH_INPUT) {
+ return false;
+ } else if (lookahead_type_ == MATCH_OUTPUT) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private:
+ FilterState LookAheadFilterArc(Arc *arca, Arc *arcb,
+ const FilterState &fs) const {
+ auto &labela = LookAheadOutput() ? arca->olabel : arca->ilabel;
+ if (labela != 0 && !(flags_ & kLookAheadNonEpsilons)) return fs;
+ if (labela == 0 && !(flags_ & kLookAheadEpsilons)) return fs;
+ lookahead_arc_ = true;
+ selector_.GetMatcher()->SetState(arca->nextstate);
+ return selector_.GetMatcher()->LookAheadFst(selector_.GetFst(),
+ arcb->nextstate)
+ ? fs
+ : FilterState::NoState();
+ }
+
+ Filter filter_; // Underlying filter.
+ MatchType lookahead_type_; // Lookahead match type.
+ LookAheadSelector<Matcher1, Matcher2, MT> selector_;
+ uint32 flags_; // Lookahead flags.
+ mutable bool lookahead_arc_; // Look-ahead performed at last FilterArc()?
+
+ LookAheadComposeFilter &operator=(const LookAheadComposeFilter &) = delete;
+};
+
+// This filter adds weight-pushing to a lookahead composition filter using the
+// LookAheadWeight() method of matcher argument. It is templated on an
+// underlying lookahead filter, typically the basic lookahead filter.
+// Weight-pushing in composition brings weights forward as much as possible
+// based on the lookahead information.
+template <class Filter, class M1 = LookAheadMatcher<typename Filter::FST1>,
+ class M2 = M1, MatchType MT = MATCH_BOTH>
+class PushWeightsComposeFilter {
+ public:
+ using Arc = typename Filter::Arc;
+ using StateId = typename Filter::StateId;
+ using Weight = typename Filter::Weight;
+
+ using FST1 = typename Filter::FST1;
+ using FST2 = typename Filter::FST2;
+ using Matcher1 = typename Filter::Matcher1;
+ using Matcher2 = typename Filter::Matcher2;
+
+ using FilterState1 = typename Filter::FilterState;
+ using FilterState2 = WeightFilterState<Weight>;
+ using FilterState = PairFilterState<FilterState1, FilterState2>;
+
+ PushWeightsComposeFilter(const FST1 &fst1, const FST2 &fst2, M1 *matcher1,
+ M2 *matcher2)
+ : filter_(fst1, fst2, matcher1, matcher2), fs_(FilterState::NoState()) {}
+
+ PushWeightsComposeFilter(
+ const PushWeightsComposeFilter<Filter, M1, M2, MT> &filter,
+ bool safe = false)
+ : filter_(filter.filter_, safe), fs_(FilterState::NoState()) {}
+
+ FilterState Start() const {
+ return FilterState(filter_.Start(), FilterState2(Weight::One()));
+ }
+
+ void SetState(StateId s1, StateId s2, const FilterState &fs) {
+ fs_ = fs;
+ filter_.SetState(s1, s2, fs.GetState1());
+ }
+
+ FilterState FilterArc(Arc *arc1, Arc *arc2) const {
+ const auto &fs1 = filter_.FilterArc(arc1, arc2);
+ if (fs1 == FilterState1::NoState()) return FilterState::NoState();
+ if (!(LookAheadFlags() & kLookAheadWeight)) {
+ return FilterState(fs1, FilterState2(Weight::One()));
+ }
+ const auto &lweight = filter_.LookAheadArc()
+ ? Selector().GetMatcher()->LookAheadWeight()
+ : Weight::One();
+ const auto &fs2 = fs_.GetState2();
+ const auto &fweight = fs2.GetWeight();
+ // Disallows Zero() weight futures.
+ if (lweight == Weight::Zero()) return FilterState::NoState();
+ arc2->weight = Divide(Times(arc2->weight, lweight), fweight);
+ return FilterState(fs1, FilterState2(lweight.Quantize()));
+ }
+
+ void FilterFinal(Weight *weight1, Weight *weight2) const {
+ filter_.FilterFinal(weight1, weight2);
+ if (!(LookAheadFlags() & kLookAheadWeight) || *weight1 == Weight::Zero()) {
+ return;
+ }
+ const auto &fs2 = fs_.GetState2();
+ const auto &fweight = fs2.GetWeight();
+ *weight1 = Divide(*weight1, fweight);
+ }
+
+ // Returns matchers; ownership states with filter.
+
+ Matcher1 *GetMatcher1() { return filter_.GetMatcher1(); }
+
+ Matcher2 *GetMatcher2() { return filter_.GetMatcher2(); }
+
+ const LookAheadSelector<Matcher1, Matcher2, MT> &Selector() const {
+ return filter_.Selector();
+ }
+
+ uint32 LookAheadFlags() const { return filter_.LookAheadFlags(); }
+
+ bool LookAheadArc() const { return filter_.LookAheadArc(); }
+
+ bool LookAheadOutput() const { return filter_.LookAheadOutput(); }
+
+ uint64 Properties(uint64 props) const {
+ return filter_.Properties(props) & kWeightInvariantProperties;
+ }
+
+ private:
+ Filter filter_; // Underlying filter.
+ FilterState fs_; // Current filter state.
+
+ PushWeightsComposeFilter &operator=(const PushWeightsComposeFilter &) =
+ delete;
+};
+
+// This filter adds label-pushing to a lookahead composition filter using the
+// LookAheadPrefix() method of the matcher argument. It is templated on an
+// underlying filter, typically the basic lookahead or weight-pushing lookahead
+// filter. Label-pushing in composition matches labels as early as possible
+// based on the lookahead information.
+template <class Filter, class M1 = LookAheadMatcher<typename Filter::FST1>,
+ class M2 = M1, MatchType MT = MATCH_BOTH>
+class PushLabelsComposeFilter {
+ public:
+ using Arc = typename Filter::Arc;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FST1 = typename Filter::FST1;
+ using FST2 = typename Filter::FST2;
+ using Matcher1 = MultiEpsMatcher<typename Filter::Matcher1>;
+ using Matcher2 = MultiEpsMatcher<typename Filter::Matcher2>;
+ using FilterState1 = typename Filter::FilterState;
+ using FilterState2 = IntegerFilterState<Label>;
+ using FilterState = PairFilterState<FilterState1, FilterState2>;
+
+ PushLabelsComposeFilter(const FST1 &fst1, const FST2 &fst2, M1 *matcher1,
+ M2 *matcher2)
+ : filter_(fst1, fst2, matcher1, matcher2),
+ fs_(FilterState::NoState()),
+ fst1_(filter_.GetMatcher1()->GetFst()),
+ fst2_(filter_.GetMatcher2()->GetFst()),
+ matcher1_(fst1_, MATCH_OUTPUT,
+ filter_.LookAheadOutput() ? kMultiEpsList : kMultiEpsLoop,
+ filter_.GetMatcher1(), false),
+ matcher2_(fst2_, MATCH_INPUT,
+ filter_.LookAheadOutput() ? kMultiEpsLoop : kMultiEpsList,
+ filter_.GetMatcher2(), false) {}
+
+ PushLabelsComposeFilter(
+ const PushLabelsComposeFilter<Filter, M1, M2, MT> &filter,
+ bool safe = false)
+ : filter_(filter.filter_, safe),
+ fs_(FilterState::NoState()),
+ fst1_(filter_.GetMatcher1()->GetFst()),
+ fst2_(filter_.GetMatcher2()->GetFst()),
+ matcher1_(fst1_, MATCH_OUTPUT,
+ filter_.LookAheadOutput() ? kMultiEpsList : kMultiEpsLoop,
+ filter_.GetMatcher1(), false),
+ matcher2_(fst2_, MATCH_INPUT,
+ filter_.LookAheadOutput() ? kMultiEpsLoop : kMultiEpsList,
+ filter_.GetMatcher2(), false) {}
+
+ FilterState Start() const {
+ return FilterState(filter_.Start(), FilterState2(kNoLabel));
+ }
+
+ void SetState(StateId s1, StateId s2, const FilterState &fs) {
+ fs_ = fs;
+ filter_.SetState(s1, s2, fs.GetState1());
+ if (!(LookAheadFlags() & kLookAheadPrefix)) return;
+ narcsa_ = LookAheadOutput() ? internal::NumArcs(fst1_, s1)
+ : internal::NumArcs(fst2_, s2);
+ const auto &fs2 = fs_.GetState2();
+ const auto &flabel = fs2.GetState();
+ GetMatcher1()->ClearMultiEpsLabels();
+ GetMatcher2()->ClearMultiEpsLabels();
+ if (flabel != kNoLabel) { // Have a lookahead label?
+ GetMatcher1()->AddMultiEpsLabel(flabel); // Yes, make it a multi-epsilon
+ GetMatcher2()->AddMultiEpsLabel(flabel); // label so that it matches the
+ } // implicit epsilon arc to be
+ } // modified below when pushing.
+
+ FilterState FilterArc(Arc *arc1, Arc *arc2) const {
+ if (!(LookAheadFlags() & kLookAheadPrefix)) {
+ return FilterState(filter_.FilterArc(arc1, arc2), FilterState2(kNoLabel));
+ }
+ const auto &fs2 = fs_.GetState2();
+ const auto &flabel = fs2.GetState();
+ if (flabel != kNoLabel) { // Have a lookahead label?
+ return LookAheadOutput() ? PushedLabelFilterArc(arc1, arc2, flabel)
+ : PushedLabelFilterArc(arc2, arc1, flabel);
+ }
+ const auto &fs1 = filter_.FilterArc(arc1, arc2);
+ if (fs1 == FilterState1::NoState()) return FilterState::NoState();
+ if (!filter_.LookAheadArc())
+ return FilterState(fs1, FilterState2(kNoLabel));
+ return LookAheadOutput() ? PushLabelFilterArc(arc1, arc2, fs1)
+ : PushLabelFilterArc(arc2, arc1, fs1);
+ }
+
+ void FilterFinal(Weight *weight1, Weight *weight2) const {
+ filter_.FilterFinal(weight1, weight2);
+ if (!(LookAheadFlags() & kLookAheadPrefix) || *weight1 == Weight::Zero()) {
+ return;
+ }
+ const auto &fs2 = fs_.GetState2();
+ const auto &flabel = fs2.GetState();
+ if (flabel != kNoLabel) *weight1 = Weight::Zero();
+ }
+
+ // Returns matchers; ownership states with filter.
+
+ Matcher1 *GetMatcher1() { return &matcher1_; }
+
+ Matcher2 *GetMatcher2() { return &matcher2_; }
+
+ uint64 Properties(uint64 iprops) const {
+ const auto oprops = filter_.Properties(iprops);
+ if (LookAheadOutput()) {
+ return oprops & kOLabelInvariantProperties;
+ } else {
+ return oprops & kILabelInvariantProperties;
+ }
+ }
+
+ private:
+ const LookAheadSelector<typename Filter::Matcher1, typename Filter::Matcher2,
+ MT>
+ &Selector() const {
+ return filter_.Selector();
+ }
+
+ // Consumes an already pushed label.
+ FilterState PushedLabelFilterArc(Arc *arca, Arc *arcb, Label flabel) const {
+ auto &labela = LookAheadOutput() ? arca->olabel : arca->ilabel;
+ const auto &labelb = LookAheadOutput() ? arcb->ilabel : arcb->olabel;
+ if (labelb != kNoLabel) {
+ return FilterState::NoState(); // Blocks non-(multi-)epsilon label
+ } else if (labela == flabel) {
+ labela = 0; // Converts match to multi-epsilon to epsilon.
+ return Start();
+ } else if (labela == 0) {
+ if (narcsa_ == 1) return fs_; // Takes epsilon, keeping state with label.
+ Selector().GetMatcher()->SetState(arca->nextstate);
+ if (Selector().GetMatcher()->LookAheadLabel(flabel)) {
+ return fs_; // Takes epsilon, keeping state with label.
+ } else {
+ return FilterState::NoState(); // Blocks non-coaccessible path.
+ }
+ } else {
+ return FilterState::NoState(); // Blocks mismatch to multi-epsilon label.
+ }
+ }
+
+ // Pushes a label forward when possible.
+ FilterState PushLabelFilterArc(Arc *arca, Arc *arcb,
+ const FilterState1 &fs1) const {
+ auto &labela = LookAheadOutput() ? arca->olabel : arca->ilabel;
+ const auto &labelb = LookAheadOutput() ? arcb->olabel : arcb->ilabel;
+ if (labelb != 0) { // No place to push.
+ return FilterState(fs1, FilterState2(kNoLabel));
+ }
+ if (labela != 0 && // Wrong lookahead prefix type?
+ LookAheadFlags() & kLookAheadNonEpsilonPrefix) {
+ return FilterState(fs1, FilterState2(kNoLabel));
+ }
+ Arc larc(kNoLabel, kNoLabel, Weight::Zero(), kNoStateId);
+ if (Selector().GetMatcher()->LookAheadPrefix(&larc)) { // Have prefix arc?
+ labela = LookAheadOutput() ? larc.ilabel : larc.olabel;
+ arcb->ilabel = larc.ilabel; // Goes forward on that arc,
+ arcb->olabel = larc.olabel; // thus pushing the label.
+ arcb->weight = Times(arcb->weight, larc.weight);
+ arcb->nextstate = larc.nextstate;
+ return FilterState(fs1, FilterState2(labela));
+ } else {
+ return FilterState(fs1, FilterState2(kNoLabel));
+ }
+ }
+
+ uint32 LookAheadFlags() const { return filter_.LookAheadFlags(); }
+
+ bool LookAheadArc() const { return filter_.LookAheadArc(); }
+
+ bool LookAheadOutput() const { return filter_.LookAheadOutput(); }
+
+ Filter filter_; // Underlying filter.
+ FilterState fs_; // Current filter state.
+ const FST1 &fst1_;
+ const FST2 &fst2_;
+ Matcher1 matcher1_; // Multi-epsilon matcher for fst1_.
+ Matcher2 matcher2_; // Multi-epsilon matcher for fst2_.
+ ssize_t narcsa_; // Number of arcs leaving look-ahead match FST.
+
+ PushLabelsComposeFilter &operator=(const PushLabelsComposeFilter &) = delete;
+};
+
+// Convenience class for setting up composition with a default lookahead matcher
+// and filter.
+template <class Arc, MatchType type>
+class DefaultLookAhead {
+ public:
+ using M = Matcher<Fst<Arc>>;
+ using ComposeFilter = SequenceComposeFilter<M>;
+ using FstMatcher = M;
+};
+
+// Specializes for MATCH_INPUT to allow lookahead.
+template <class Arc>
+class DefaultLookAhead<Arc, MATCH_INPUT> {
+ public:
+ using M = LookAheadMatcher<Fst<Arc>>;
+ using SF = SequenceComposeFilter<M>;
+ using ComposeFilter = LookAheadComposeFilter<SF, M>;
+ using FstMatcher = M;
+};
+
+// Specializes for MATCH_OUTPUT to allow lookahead.
+template <class Arc>
+class DefaultLookAhead<Arc, MATCH_OUTPUT> {
+ public:
+ using M = LookAheadMatcher<Fst<Arc>>;
+ using SF = AltSequenceComposeFilter<M>;
+ using ComposeFilter = LookAheadComposeFilter<SF, M>;
+ using FstMatcher = M;
+};
+
+// Specializes for StdArc to allow weight and label pushing.
+template <>
+class DefaultLookAhead<StdArc, MATCH_INPUT> {
+ public:
+ using M = LookAheadMatcher<Fst<StdArc>>;
+ using SF = SequenceComposeFilter<M>;
+ using LF = LookAheadComposeFilter<SF, M>;
+ using WF = PushWeightsComposeFilter<LF, M>;
+ using ComposeFilter = PushLabelsComposeFilter<WF, M>;
+ using FstMatcher = M;
+};
+
+// Specializes for StdArc to allow weight and label pushing.
+template <>
+class DefaultLookAhead<StdArc, MATCH_OUTPUT> {
+ public:
+ using M = LookAheadMatcher<Fst<StdArc>>;
+ using SF = AltSequenceComposeFilter<M>;
+ using LF = LookAheadComposeFilter<SF, M>;
+ using WF = PushWeightsComposeFilter<LF, M>;
+ using ComposeFilter = PushLabelsComposeFilter<WF, M>;
+ using FstMatcher = M;
+};
+
+// Specializes for LogArc to allow weight and label pushing.
+template <>
+class DefaultLookAhead<LogArc, MATCH_INPUT> {
+ public:
+ using M = LookAheadMatcher<Fst<LogArc>>;
+ using SF = SequenceComposeFilter<M>;
+ using LF = LookAheadComposeFilter<SF, M>;
+ using WF = PushWeightsComposeFilter<LF, M>;
+ using ComposeFilter = PushLabelsComposeFilter<WF, M>;
+ using FstMatcher = M;
+};
+
+// Specializes for LogArc to allow weight and label pushing.
+template <>
+class DefaultLookAhead<LogArc, MATCH_OUTPUT> {
+ public:
+ using M = LookAheadMatcher<Fst<LogArc>>;
+ using SF = AltSequenceComposeFilter<M>;
+ using LF = LookAheadComposeFilter<SF, M>;
+ using WF = PushWeightsComposeFilter<LF, M>;
+ using ComposeFilter = PushLabelsComposeFilter<WF, M>;
+ using FstMatcher = M;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_LOOKAHEAD_FILTER_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Classes to add lookahead to FST matchers, useful for improving composition
+// efficiency with certain inputs.
+
+#ifndef FST_LIB_LOOKAHEAD_MATCHER_H_
+#define FST_LIB_LOOKAHEAD_MATCHER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fst/add-on.h>
+#include <fst/const-fst.h>
+#include <fst/fst.h>
+#include <fst/label-reachable.h>
+#include <fst/matcher.h>
+
+
+DECLARE_string(save_relabel_ipairs);
+DECLARE_string(save_relabel_opairs);
+
+namespace fst {
+
+// Lookahead matches extend the interface of Matcher (see matcher.h) with the
+// following additional methods:
+//
+// template <class FST>
+// class LookAheadMatcher {
+// public:
+// using Arc = typename FST::Arc;
+// using Label = typename Arc::Label;
+// using StateId = typename Arc::StateId;
+// using Weight = typename Arc::Weight;
+//
+// // Required constructors.
+// LookAheadMatcher(const FST &fst, MatchType match_type);
+// // If safe=true, the copy is thread-safe (except the lookahead FST is
+// // preserved). See Fst<>::Cop() for further doc.
+// LookAheadMatcher(const LookAheadMatcher &matcher, bool safe = false);
+//
+// // Below are methods for looking ahead for a match to a label and more
+// // generally, to a rational set. Each returns false if there is definitely
+// // not a match and returns true if there possibly is a match.
+
+// // Can the label be read from the current matcher state after possibly
+// // following epsilon transitions?
+// bool LookAheadLabel(Label label) const;
+//
+// // The following methods allow looking ahead for an arbitrary rational set
+// // of strings, specified by an FST and a state from which to begin the
+// matching. If the lookahead FST is a transducer, this looks on the side
+// // different from the matcher's match_type (cf. composition).
+//
+// // Are there paths from a state in the lookahead FST that can be read from
+// // the curent matcher state?
+// bool LookAheadFst(const Fst<Arc> &fst, StateId state);
+//
+// // Gives an estimate of the combined weight of the paths in the lookahead
+// // and matcher FSTs for the last call to LookAheadFst; a trivial
+// // implementation returns Weight::One(). Non-trivial implementations are
+// // useful for weight-pushing in composition.
+// Weight LookAheadWeight() const;
+//
+// // Is there is a single non-epsilon arc found in the lookahead FST that
+// // begins the path (after possibly following any epsilons) in the last call
+// // to LookAheadFst? If so, return true and copy it to the arc argument;
+// // otherwise, return false. A trivial implementation returns false.
+// // Non-trivial implementations are useful for label-pushing in composition.
+// bool LookAheadPrefix(Arc *arc);
+//
+// // Optionally pre-specifies the lookahead FST that will be passed to
+// // LookAheadFst() for possible precomputation. If copy is true, then the FST
+// argument is a copy of the FST used in the previous call to this method (to
+// avoid unnecessary updates).
+// void InitLookAheadFst(const Fst<Arc> &fst, bool copy = false);
+// };
+
+// LOOK-AHEAD FLAGS (see also kMatcherFlags in matcher.h):
+//
+// Matcher is a lookahead matcher when 'match_type' is MATCH_INPUT.
+constexpr uint32 kInputLookAheadMatcher = 0x00000010;
+
+// Matcher is a lookahead matcher when 'match_type' is MATCH_OUTPUT.
+constexpr uint32 kOutputLookAheadMatcher = 0x00000020;
+
+// A non-trivial implementation of LookAheadWeight() method defined and
+// should be used?
+constexpr uint32 kLookAheadWeight = 0x00000040;
+
+// A non-trivial implementation of LookAheadPrefix() method defined and
+// should be used?
+constexpr uint32 kLookAheadPrefix = 0x00000080;
+
+// Look-ahead of matcher FST non-epsilon arcs?
+constexpr uint32 kLookAheadNonEpsilons = 0x00000100;
+
+// Look-ahead of matcher FST epsilon arcs?
+constexpr uint32 kLookAheadEpsilons = 0x00000200;
+
+// Ignore epsilon paths for the lookahead prefix? Note this gives
+// correct results in composition only with an appropriate composition
+// filter since it depends on the filter blocking the ignored paths.
+constexpr uint32 kLookAheadNonEpsilonPrefix = 0x00000400;
+
+// For LabelLookAheadMatcher, save relabeling data to file
+constexpr uint32 kLookAheadKeepRelabelData = 0x00000800;
+
+// Flags used for lookahead matchers.
+constexpr uint32 kLookAheadFlags = 0x00000ff0;
+
+// LookAhead Matcher interface, templated on the Arc definition; used
+// for lookahead matcher specializations that are returned by the
+// InitMatcher() Fst method.
+template <class Arc>
+class LookAheadMatcherBase : public MatcherBase<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ LookAheadMatcherBase()
+ : weight_(Weight::One()),
+ prefix_arc_(kNoLabel, kNoLabel, Weight::One(), kNoStateId) {}
+
+ ~LookAheadMatcherBase() override {}
+
+ bool LookAheadLabel(Label label) const { return LookAheadLabel_(label); }
+
+ bool LookAheadFst(const Fst<Arc> &fst, StateId state) {
+ return LookAheadFst_(fst, state);
+ }
+
+ Weight LookAheadWeight() const { return weight_; }
+
+ bool LookAheadPrefix(Arc *arc) const {
+ if (prefix_arc_.nextstate != kNoStateId) {
+ *arc = prefix_arc_;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ virtual void InitLookAheadFst(const Fst<Arc> &fst, bool copy = false) = 0;
+
+ protected:
+ void SetLookAheadWeight(const Weight &w) { weight_ = w; }
+
+ void SetLookAheadPrefix(const Arc &arc) { prefix_arc_ = arc; }
+
+ void ClearLookAheadPrefix() { prefix_arc_.nextstate = kNoStateId; }
+
+ private:
+ virtual bool LookAheadLabel_(Label label) const = 0;
+
+ // This must set l.a. weight and prefix if non-trivial.
+ virtual bool LookAheadFst_(const Fst<Arc> &fst, StateId state) = 0;
+
+ Weight weight_; // Look-ahead weight.
+ Arc prefix_arc_; // Look-ahead prefix arc
+};
+
+// Don't really lookahead, just declare future looks good regardless.
+template <class M>
+class TrivialLookAheadMatcher
+ : public LookAheadMatcherBase<typename M::FST::Arc> {
+ 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;
+
+ TrivialLookAheadMatcher(const FST &fst, MatchType match_type)
+ : matcher_(fst, match_type) {}
+
+ TrivialLookAheadMatcher(const TrivialLookAheadMatcher<M> &lmatcher,
+ bool safe = false)
+ : matcher_(lmatcher.matcher_, safe) {}
+
+ TrivialLookAheadMatcher<M> *Copy(bool safe = false) const override {
+ return new TrivialLookAheadMatcher<M>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return matcher_.Type(test); }
+
+ void SetState(StateId state) { return matcher_.SetState(state); }
+
+ 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(); }
+
+ Weight Final(StateId state) const { return matcher_.Final(state); }
+
+ ssize_t Priority(StateId state) { return matcher_.Priority(state); }
+
+ const FST &GetFst() const override { return matcher_.GetFst(); }
+
+ uint64 Properties(uint64 props) const override {
+ return matcher_.Properties(props);
+ }
+
+ uint32 Flags() const override {
+ return matcher_.Flags() | kInputLookAheadMatcher | kOutputLookAheadMatcher;
+ }
+
+ // Look-ahead methods.
+ bool LookAheadLabel(Label label) const { return true; }
+
+ bool LookAheadFst(const Fst<Arc> &fst, StateId state) { return true; }
+
+ Weight LookAheadWeight() const { return Weight::One(); }
+
+ bool LookAheadPrefix(Arc *arc) const { return false; }
+
+ void InitLookAheadFst(const Fst<Arc> &fst, bool copy = false) override {}
+
+ private:
+ // This allows base class virtual access to non-virtual derived-class members
+ // of the same name. It makes the derived class more efficient to use but
+ // unsafe to further derive.
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId state) const override { return Final(state); }
+
+ ssize_t Priority_(StateId state) override { return Priority(state); }
+
+ bool LookAheadLabel_(Label l) const override { return LookAheadLabel(l); }
+
+ bool LookAheadFst_(const Fst<Arc> &fst, StateId state) override {
+ return LookAheadFst(fst, state);
+ }
+
+ Weight LookAheadWeight_() const { return LookAheadWeight(); }
+
+ bool LookAheadPrefix_(Arc *arc) const { return LookAheadPrefix(arc); }
+
+ M matcher_;
+};
+
+// Look-ahead of one transition. Template argument F accepts flags to
+// control behavior.
+template <class M, uint32 F = kLookAheadNonEpsilons | kLookAheadEpsilons |
+ kLookAheadWeight | kLookAheadPrefix>
+class ArcLookAheadMatcher : public LookAheadMatcherBase<typename M::FST::Arc> {
+ 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;
+ using MatcherData = NullAddOn;
+
+ using LookAheadMatcherBase<Arc>::LookAheadWeight;
+ using LookAheadMatcherBase<Arc>::SetLookAheadPrefix;
+ using LookAheadMatcherBase<Arc>::SetLookAheadWeight;
+ using LookAheadMatcherBase<Arc>::ClearLookAheadPrefix;
+
+ ArcLookAheadMatcher(
+ const FST &fst, MatchType match_type,
+ std::shared_ptr<MatcherData> data = std::shared_ptr<MatcherData>())
+ : matcher_(fst, match_type),
+ fst_(matcher_.GetFst()),
+ lfst_(nullptr),
+ state_(kNoStateId) {}
+
+ ArcLookAheadMatcher(const ArcLookAheadMatcher<M, F> &lmatcher,
+ bool safe = false)
+ : matcher_(lmatcher.matcher_, safe),
+ fst_(matcher_.GetFst()),
+ lfst_(lmatcher.lfst_),
+ state_(kNoStateId) {}
+
+ // General matcher methods.
+ ArcLookAheadMatcher<M, F> *Copy(bool safe = false) const override {
+ return new ArcLookAheadMatcher<M, F>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return matcher_.Type(test); }
+
+ void SetState(StateId state) {
+ state_ = state;
+ matcher_.SetState(state);
+ }
+
+ 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(); }
+
+ Weight Final(StateId state) const { return matcher_.Final(state); }
+
+ ssize_t Priority(StateId state) { return matcher_.Priority(state); }
+
+ const FST &GetFst() const override { return fst_; }
+
+ uint64 Properties(uint64 props) const override {
+ return matcher_.Properties(props);
+ }
+
+ uint32 Flags() const override {
+ return matcher_.Flags() | kInputLookAheadMatcher | kOutputLookAheadMatcher |
+ F;
+ }
+
+ const MatcherData *GetData() const { return nullptr; }
+
+ std::shared_ptr<MatcherData> GetSharedData() const {
+ return std::shared_ptr<MatcherData>();
+ }
+
+ // Look-ahead methods.
+ bool LookAheadLabel(Label label) const { return matcher_.Find(label); }
+
+ // Checks if there is a matching (possibly super-final) transition
+ // at (state_, state).
+ bool LookAheadFst(const Fst<Arc> &fst, StateId state);
+
+ void InitLookAheadFst(const Fst<Arc> &fst, bool copy = false) override {
+ lfst_ = &fst;
+ }
+
+ private:
+ // This allows base class virtual access to non-virtual derived-
+ // class members of the same name. It makes the derived class more
+ // efficient to use but unsafe to further derive.
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId state) const override { return Final(state); }
+
+ ssize_t Priority_(StateId state) override { return Priority(state); }
+
+ bool LookAheadLabel_(Label label) const override {
+ return LookAheadLabel(label);
+ }
+
+ bool LookAheadFst_(const Fst<Arc> &fst, StateId state) override {
+ return LookAheadFst(fst, state);
+ }
+
+ mutable M matcher_;
+ const FST &fst_; // Matcher FST.
+ const Fst<Arc> *lfst_; // Look-ahead FST.
+ StateId state_; // Matcher state.
+};
+
+template <class M, uint32 F>
+bool ArcLookAheadMatcher<M, F>::LookAheadFst(const Fst<Arc> &fst,
+ StateId state) {
+ if (&fst != lfst_) InitLookAheadFst(fst);
+ bool result = false;
+ ssize_t nprefix = 0;
+ if (F & kLookAheadWeight) SetLookAheadWeight(Weight::Zero());
+ if (F & kLookAheadPrefix) ClearLookAheadPrefix();
+ if (fst_.Final(state_) != Weight::Zero() &&
+ lfst_->Final(state) != Weight::Zero()) {
+ if (!(F & (kLookAheadWeight | kLookAheadPrefix))) return true;
+ ++nprefix;
+ if (F & kLookAheadWeight) {
+ SetLookAheadWeight(Plus(LookAheadWeight(),
+ Times(fst_.Final(state_), lfst_->Final(state))));
+ }
+ result = true;
+ }
+ if (matcher_.Find(kNoLabel)) {
+ if (!(F & (kLookAheadWeight | kLookAheadPrefix))) return true;
+ ++nprefix;
+ if (F & kLookAheadWeight) {
+ for (; !matcher_.Done(); matcher_.Next()) {
+ SetLookAheadWeight(Plus(LookAheadWeight(), matcher_.Value().weight));
+ }
+ }
+ result = true;
+ }
+ for (ArcIterator<Fst<Arc>> aiter(*lfst_, state); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ Label label = kNoLabel;
+ switch (matcher_.Type(false)) {
+ case MATCH_INPUT:
+ label = arc.olabel;
+ break;
+ case MATCH_OUTPUT:
+ label = arc.ilabel;
+ break;
+ default:
+ FSTERROR() << "ArcLookAheadMatcher::LookAheadFst: Bad match type";
+ return true;
+ }
+ if (label == 0) {
+ if (!(F & (kLookAheadWeight | kLookAheadPrefix))) return true;
+ if (!(F & kLookAheadNonEpsilonPrefix)) ++nprefix;
+ if (F & kLookAheadWeight) {
+ SetLookAheadWeight(Plus(LookAheadWeight(), arc.weight));
+ }
+ result = true;
+ } else if (matcher_.Find(label)) {
+ if (!(F & (kLookAheadWeight | kLookAheadPrefix))) return true;
+ for (; !matcher_.Done(); matcher_.Next()) {
+ ++nprefix;
+ if (F & kLookAheadWeight) {
+ SetLookAheadWeight(Plus(LookAheadWeight(),
+ Times(arc.weight, matcher_.Value().weight)));
+ }
+ if ((F & kLookAheadPrefix) && nprefix == 1) SetLookAheadPrefix(arc);
+ }
+ result = true;
+ }
+ }
+ if (F & kLookAheadPrefix) {
+ if (nprefix == 1) {
+ SetLookAheadWeight(Weight::One()); // Avoids double counting.
+ } else {
+ ClearLookAheadPrefix();
+ }
+ }
+ return result;
+}
+
+// Template argument F accepts flags to control behavior. It must include
+// precisely one of kInputLookAheadMatcher or kOutputLookAheadMatcher.
+template <class M,
+ uint32 F = kLookAheadEpsilons | kLookAheadWeight | kLookAheadPrefix |
+ kLookAheadNonEpsilonPrefix | kLookAheadKeepRelabelData,
+ class Accumulator = DefaultAccumulator<typename M::Arc>,
+ class Reachable = LabelReachable<typename M::Arc, Accumulator>>
+class LabelLookAheadMatcher
+ : public LookAheadMatcherBase<typename M::FST::Arc> {
+ 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;
+ using MatcherData = typename Reachable::Data;
+
+ using LookAheadMatcherBase<Arc>::LookAheadWeight;
+ using LookAheadMatcherBase<Arc>::SetLookAheadPrefix;
+ using LookAheadMatcherBase<Arc>::SetLookAheadWeight;
+ using LookAheadMatcherBase<Arc>::ClearLookAheadPrefix;
+
+ LabelLookAheadMatcher(
+ const FST &fst, MatchType match_type,
+ std::shared_ptr<MatcherData> data = std::shared_ptr<MatcherData>(),
+ Accumulator *accumulator = nullptr)
+ : matcher_(fst, match_type),
+ lfst_(nullptr),
+ state_(kNoStateId),
+ error_(false) {
+ if (!(F & (kInputLookAheadMatcher | kOutputLookAheadMatcher))) {
+ FSTERROR() << "LabelLookaheadMatcher: Bad matcher flags: " << F;
+ error_ = true;
+ }
+ const bool reach_input = match_type == MATCH_INPUT;
+ if (data) {
+ if (reach_input == data->ReachInput()) {
+ label_reachable_.reset(new Reachable(data, accumulator));
+ }
+ } else if ((reach_input && (F & kInputLookAheadMatcher)) ||
+ (!reach_input && (F & kOutputLookAheadMatcher))) {
+ label_reachable_.reset(new Reachable(fst, reach_input, accumulator,
+ F & kLookAheadKeepRelabelData));
+ }
+ }
+
+ LabelLookAheadMatcher(
+ const LabelLookAheadMatcher<M, F, Accumulator, Reachable> &lmatcher,
+ bool safe = false)
+ : matcher_(lmatcher.matcher_, safe),
+ lfst_(lmatcher.lfst_),
+ label_reachable_(lmatcher.label_reachable_
+ ? new Reachable(*lmatcher.label_reachable_, safe)
+ : nullptr),
+ state_(kNoStateId),
+ error_(lmatcher.error_) {}
+
+ // General matcher methods.
+
+ LabelLookAheadMatcher<M, F, Accumulator, Reachable> *Copy(
+ bool safe = false) const override {
+ return new LabelLookAheadMatcher<M, F, Accumulator, Reachable>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return matcher_.Type(test); }
+
+ void SetState(StateId state) {
+ if (state == state_) return;
+ state_ = state;
+ match_set_state_ = false;
+ reach_set_state_ = false;
+ }
+
+ bool Find(Label label) {
+ if (!match_set_state_) {
+ matcher_.SetState(state_);
+ match_set_state_ = true;
+ }
+ return matcher_.Find(label);
+ }
+
+ bool Done() const { return matcher_.Done(); }
+
+ const Arc &Value() const { return matcher_.Value(); }
+
+ void Next() { matcher_.Next(); }
+
+ ssize_t Priority(StateId state) { return matcher_.Priority(state); }
+
+ Weight Final(StateId state) const { return matcher_.Final(state); }
+
+ const FST &GetFst() const override { return matcher_.GetFst(); }
+
+ uint64 Properties(uint64 inprops) const override {
+ auto outprops = matcher_.Properties(inprops);
+ if (error_ || (label_reachable_ && label_reachable_->Error())) {
+ outprops |= kError;
+ }
+ return outprops;
+ }
+
+ uint32 Flags() const override {
+ if (label_reachable_ && label_reachable_->GetData()->ReachInput()) {
+ return matcher_.Flags() | F | kInputLookAheadMatcher;
+ } else if (label_reachable_ && !label_reachable_->GetData()->ReachInput()) {
+ return matcher_.Flags() | F | kOutputLookAheadMatcher;
+ } else {
+ return matcher_.Flags();
+ }
+ }
+
+ const MatcherData *GetData() const {
+ return label_reachable_ ? label_reachable_->GetData() : nullptr;
+ };
+
+ std::shared_ptr<MatcherData> GetSharedData() const {
+ return label_reachable_ ? label_reachable_->GetSharedData()
+ : std::shared_ptr<MatcherData>();
+ }
+
+ bool LookAheadLabel(Label label) const {
+ if (label == 0) return true;
+ if (label_reachable_) {
+ if (!reach_set_state_) {
+ label_reachable_->SetState(state_);
+ reach_set_state_ = true;
+ }
+ return label_reachable_->Reach(label);
+ } else {
+ return true;
+ }
+ }
+
+ // Checks if there is a matching (possibly super-final) transition at
+ // (state_, state).
+ template <class LFST>
+ bool LookAheadFst(const LFST &fst, StateId state);
+
+ void InitLookAheadFst(const Fst<Arc> &fst, bool copy = false) override {
+ lfst_ = &fst;
+ if (label_reachable_) {
+ const bool reach_input = Type(false) == MATCH_OUTPUT;
+ label_reachable_->ReachInit(fst, reach_input, copy);
+ }
+ }
+
+ template <class LFST>
+ void InitLookAheadFst(const LFST &fst, bool copy = false) {
+ lfst_ = static_cast<const Fst<Arc> *>(&fst);
+ if (label_reachable_) {
+ const bool reach_input = Type(false) == MATCH_OUTPUT;
+ label_reachable_->ReachInit(fst, reach_input, copy);
+ }
+ }
+
+ private:
+ // This allows base class virtual access to non-virtual derived-
+ // class members of the same name. It makes the derived class more
+ // efficient to use but unsafe to further derive.
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId state) const override { return Final(state); }
+
+ ssize_t Priority_(StateId state) override { return Priority(state); }
+
+ bool LookAheadLabel_(Label label) const override {
+ return LookAheadLabel(label);
+ }
+
+ bool LookAheadFst_(const Fst<Arc> &fst, StateId state) override {
+ return LookAheadFst(fst, state);
+ }
+
+ mutable M matcher_;
+ const Fst<Arc> *lfst_; // Look-ahead FST.
+ std::unique_ptr<Reachable> label_reachable_; // Label reachability info.
+ StateId state_; // Matcher state.
+ bool match_set_state_; // matcher_.SetState called?
+ mutable bool reach_set_state_; // reachable_.SetState called?
+ bool error_;
+};
+
+template <class M, uint32 F, class Accumulator, class Reachable>
+template <class LFST>
+inline bool LabelLookAheadMatcher<M, F, Accumulator, Reachable>::LookAheadFst(
+ const LFST &fst, StateId state) {
+ if (static_cast<const Fst<Arc> *>(&fst) != lfst_) InitLookAheadFst(fst);
+ SetLookAheadWeight(Weight::One());
+ ClearLookAheadPrefix();
+ if (!label_reachable_) return true;
+ label_reachable_->SetState(state_, state);
+ reach_set_state_ = true;
+ bool compute_weight = F & kLookAheadWeight;
+ bool compute_prefix = F & kLookAheadPrefix;
+ ArcIterator<LFST> aiter(fst, state);
+ aiter.SetFlags(kArcNoCache, kArcNoCache); // Makes caching optional.
+ const bool reach_arc = label_reachable_->Reach(
+ &aiter, 0, internal::NumArcs(*lfst_, state), compute_weight);
+ const auto lfinal = internal::Final(*lfst_, state);
+ const bool reach_final =
+ lfinal != Weight::Zero() && label_reachable_->ReachFinal();
+ if (reach_arc) {
+ const auto begin = label_reachable_->ReachBegin();
+ const auto end = label_reachable_->ReachEnd();
+ if (compute_prefix && end - begin == 1 && !reach_final) {
+ aiter.Seek(begin);
+ SetLookAheadPrefix(aiter.Value());
+ compute_weight = false;
+ } else if (compute_weight) {
+ SetLookAheadWeight(label_reachable_->ReachWeight());
+ }
+ }
+ if (reach_final && compute_weight) {
+ SetLookAheadWeight(reach_arc ? Plus(LookAheadWeight(), lfinal) : lfinal);
+ }
+ return reach_arc || reach_final;
+}
+
+// Label-lookahead relabeling class.
+template <class Arc, class Data = LabelReachableData<typename Arc::Label>>
+class LabelLookAheadRelabeler {
+ public:
+ using Label = typename Arc::Label;
+ using Reachable = LabelReachable<Arc, DefaultAccumulator<Arc>, Data>;
+
+ // Relabels matcher FST (initialization function object).
+ template <typename Impl>
+ explicit LabelLookAheadRelabeler(std::shared_ptr<Impl> *impl);
+
+ // Relabels arbitrary FST. Class LFST should be a label-lookahead FST.
+ template <class LFST>
+ static void Relabel(MutableFst<Arc> *fst, const LFST &mfst,
+ bool relabel_input) {
+ const auto *data = mfst.GetAddOn();
+ Reachable reachable(data->First() ? data->SharedFirst()
+ : data->SharedSecond());
+ reachable.Relabel(fst, relabel_input);
+ }
+
+ // Returns relabeling pairs (cf. relabel.h::Relabel()). Class LFST should be a
+ // label-lookahead FST. If avoid_collisions is true, extra pairs are added to
+ // ensure no collisions when relabeling automata that have labels unseen here.
+ template <class LFST>
+ static void RelabelPairs(const LFST &mfst,
+ std::vector<std::pair<Label, Label>> *pairs,
+ bool avoid_collisions = false) {
+ const auto *data = mfst.GetAddOn();
+ Reachable reachable(data->First() ? data->SharedFirst()
+ : data->SharedSecond());
+ reachable.RelabelPairs(pairs, avoid_collisions);
+ }
+};
+
+template <class Arc, class Data>
+template <typename Impl>
+inline LabelLookAheadRelabeler<Arc, Data>::LabelLookAheadRelabeler(
+ std::shared_ptr<Impl> *impl) {
+ Fst<Arc> &fst = (*impl)->GetFst();
+ auto data = (*impl)->GetSharedAddOn();
+ const auto name = (*impl)->Type();
+ const bool is_mutable = fst.Properties(kMutable, false);
+ std::unique_ptr<MutableFst<Arc>> mfst;
+ if (is_mutable) {
+ mfst.reset(static_cast<MutableFst<Arc> *>(&fst));
+ } else {
+ mfst.reset(new VectorFst<Arc>(fst));
+ }
+ if (data->First()) { // reach_input.
+ Reachable reachable(data->SharedFirst());
+ reachable.Relabel(mfst.get(), true);
+ if (!FLAGS_save_relabel_ipairs.empty()) {
+ std::vector<std::pair<Label, Label>> pairs;
+ reachable.RelabelPairs(&pairs, true);
+ WriteLabelPairs(FLAGS_save_relabel_ipairs, pairs);
+ }
+ } else {
+ Reachable reachable(data->SharedSecond());
+ reachable.Relabel(mfst.get(), false);
+ if (!FLAGS_save_relabel_opairs.empty()) {
+ std::vector<std::pair<Label, Label>> pairs;
+ reachable.RelabelPairs(&pairs, true);
+ WriteLabelPairs(FLAGS_save_relabel_opairs, pairs);
+ }
+ }
+ if (!is_mutable) {
+ *impl = std::make_shared<Impl>(*mfst, name);
+ (*impl)->SetAddOn(data);
+ }
+}
+
+// Generic lookahead matcher, templated on the FST definition (a wrapper around
+// a pointer to specific one).
+template <class F>
+class LookAheadMatcher {
+ 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 LBase = LookAheadMatcherBase<Arc>;
+
+ LookAheadMatcher(const FST &fst, MatchType match_type)
+ : base_(fst.InitMatcher(match_type)) {
+ if (!base_) base_.reset(new SortedMatcher<FST>(fst, match_type));
+ lookahead_ = false;
+ }
+
+ // Takes ownership of base.
+ explicit LookAheadMatcher(MatcherBase<Arc> *base)
+ : base_(base), lookahead_(false) {}
+
+ LookAheadMatcher(const LookAheadMatcher<FST> &matcher, bool safe = false)
+ : base_(matcher.base_->Copy(safe)) {
+ lookahead_ = matcher.lookahead_;
+ }
+
+ LookAheadMatcher<FST> *Copy(bool safe = false) const {
+ return new LookAheadMatcher<FST>(*this, safe);
+ }
+
+ MatchType Type(bool test) const { return base_->Type(test); }
+
+ void SetState(StateId state) { base_->SetState(state); }
+
+ 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(); }
+
+ Weight Final(StateId state) const { return base_->Final(state); }
+
+ ssize_t Priority(StateId state) { return base_->Priority(state); }
+
+ const FST &GetFst() const {
+ return static_cast<const FST &>(base_->GetFst());
+ }
+
+ uint64 Properties(uint64 props) const { return base_->Properties(props); }
+
+ uint32 Flags() const { return base_->Flags(); }
+
+ bool LookAheadLabel(Label label) const {
+ if (LookAheadCheck()) {
+ return static_cast<LBase *>(base_.get())->LookAheadLabel(label);
+ } else {
+ return true;
+ }
+ }
+
+ bool LookAheadFst(const Fst<Arc> &fst, StateId state) {
+ if (LookAheadCheck()) {
+ return static_cast<LBase *>(base_.get())->LookAheadFst(fst, state);
+ } else {
+ return true;
+ }
+ }
+
+ Weight LookAheadWeight() const {
+ if (LookAheadCheck()) {
+ return static_cast<LBase *>(base_.get())->LookAheadWeight();
+ } else {
+ return Weight::One();
+ }
+ }
+
+ bool LookAheadPrefix(Arc *arc) const {
+ if (LookAheadCheck()) {
+ return static_cast<LBase *>(base_.get())->LookAheadPrefix(arc);
+ } else {
+ return false;
+ }
+ }
+
+ void InitLookAheadFst(const Fst<Arc> &fst, bool copy = false) {
+ if (LookAheadCheck()) {
+ static_cast<LBase *>(base_.get())->InitLookAheadFst(fst, copy);
+ }
+ }
+
+ private:
+ bool LookAheadCheck() const {
+ if (!lookahead_) {
+ lookahead_ =
+ base_->Flags() & (kInputLookAheadMatcher | kOutputLookAheadMatcher);
+ if (!lookahead_) {
+ FSTERROR() << "LookAheadMatcher: No look-ahead matcher defined";
+ }
+ }
+ return lookahead_;
+ }
+
+ std::unique_ptr<MatcherBase<Arc>> base_;
+ mutable bool lookahead_;
+
+ LookAheadMatcher &operator=(const LookAheadMatcher &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_LOOKAHEAD_MATCHER_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Compatibility file for old-style Map() functions and MapFst class that have
+// been renamed to ArcMap (cf. StateMap).
+
+#ifndef FST_LIB_MAP_H_
+#define FST_LIB_MAP_H_
+
+
+#include <fst/arc-map.h>
+
+
+namespace fst {
+
+template <class A, class C>
+void Map(MutableFst<A> *fst, C *mapper) {
+ ArcMap(fst, mapper);
+}
+
+template <class A, class C>
+void Map(MutableFst<A> *fst, C mapper) {
+ ArcMap(fst, mapper);
+}
+
+template <class A, class B, class C>
+void Map(const Fst<A> &ifst, MutableFst<B> *ofst, C *mapper) {
+ ArcMap(ifst, ofst, mapper);
+}
+
+template <class A, class B, class C>
+void Map(const Fst<A> &ifst, MutableFst<B> *ofst, C mapper) {
+ ArcMap(ifst, ofst, mapper);
+}
+
+using MapFstOptions = ArcMapFstOptions;
+
+template <class A, class B, class C>
+class MapFst : public ArcMapFst<A, B, C> {
+ public:
+ using FromArc = A;
+ using ToArc = B;
+
+ using StateId = typename ToArc::StateId;
+ using Weight = typename ToArc::Weight;
+
+ using State = CacheState<B>;
+
+ MapFst(const Fst<A> &fst, const C &mapper, const MapFstOptions &opts)
+ : ArcMapFst<A, B, C>(fst, mapper, opts) {}
+
+ MapFst(const Fst<A> &fst, C *mapper, const MapFstOptions &opts)
+ : ArcMapFst<A, B, C>(fst, mapper, opts) {}
+
+ MapFst(const Fst<A> &fst, const C &mapper)
+ : ArcMapFst<A, B, C>(fst, mapper) {}
+
+ MapFst(const Fst<A> &fst, C *mapper) : ArcMapFst<A, B, C>(fst, mapper) {}
+
+ // See Fst<>::Copy() for doc.
+ MapFst(const MapFst<A, B, C> &fst, bool safe = false)
+ : ArcMapFst<A, B, C>(fst, safe) {}
+
+ // Get a copy of this MapFst. See Fst<>::Copy() for further doc.
+ MapFst<A, B, C> *Copy(bool safe = false) const override {
+ return new MapFst(*this, safe);
+ }
+};
+
+// Specialization for MapFst.
+template <class A, class B, class C>
+class StateIterator<MapFst<A, B, C>>
+ : public StateIterator<ArcMapFst<A, B, C>> {
+ public:
+ explicit StateIterator(const ArcMapFst<A, B, C> &fst)
+ : StateIterator<ArcMapFst<A, B, C>>(fst) {}
+};
+
+// Specialization for MapFst.
+template <class A, class B, class C>
+class ArcIterator<MapFst<A, B, C>> : public ArcIterator<ArcMapFst<A, B, C>> {
+ public:
+ ArcIterator(const ArcMapFst<A, B, C> &fst, typename A::StateId s)
+ : ArcIterator<ArcMapFst<A, B, C>>(fst, s) {}
+};
+
+// For backwards compatibility only; use IdentityArcMapper otherwise.
+template <class A>
+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_LIB_MAP_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_LIB_MAPPED_FILE_H_
+#define FST_LIB_MAPPED_FILE_H_
+
+#include <cstddef>
+#include <istream>
+#include <string>
+
+#include <fst/compat.h>
+
+namespace fst {
+
+// A memory region is a simple abstraction for allocated memory or data from
+// memory-mapped files. If mmap is null, then data represents an owned region
+// of size bytes. Otherwise, mmap and size refer to the mapping and data is a
+// casted pointer to a region contained within [mmap, mmap + size). If size is
+// 0, then mmap and data refer to a block of memory managed externally by some
+// other allocator. The offset is used when allocating memory to providing
+// padding for alignment.
+struct MemoryRegion {
+ void *data;
+ void *mmap;
+ size_t size;
+ int offset;
+};
+
+class MappedFile {
+ public:
+ ~MappedFile();
+
+ void *mutable_data() const { return region_.data; }
+
+ const void *data() const { return region_.data; }
+
+ // Returns a MappedFile object that contains the contents of the input strea
+ // strm starting from the current file position with size bytes. The memorymap
+ // bool is advisory, and Map will default to allocating and reading. The
+ // source argument needs to contain the filename that was used to open the
+ // input stream.
+ static MappedFile *Map(std::istream *istrm, bool memorymap,
+ const string &source, size_t size);
+
+ // Creates a MappedFile object with a new[]'ed block of memory of size. The
+ // align argument can be used to specify a desired block alignment.
+ // This is RECOMMENDED FOR INTERNAL USE ONLY as it may change in future
+ // releases.
+ static MappedFile *Allocate(size_t size, int align = kArchAlignment);
+
+ // Creates a MappedFile object pointing to a borrowed reference to data. This
+ // block of memory is not owned by the MappedFile object and will not be
+ // freed. This is RECOMMENDED FOR INTERNAL USE ONLY, may change in future
+ // releases.
+ static MappedFile *Borrow(void *data);
+
+ // Alignment required for mapping structures in bytes. Regions of memory that
+ // are not aligned upon a 128-bit boundary are read from the file instead.
+ // This is consistent with the alignment boundary set in ConstFst and
+ // CompactFst.
+ static constexpr int kArchAlignment = 16;
+
+ static constexpr size_t kMaxReadChunk = 256 * 1024 * 1024; // 256 MB.
+
+ private:
+ explicit MappedFile(const MemoryRegion ®ion);
+
+ MemoryRegion region_;
+ MappedFile(const MappedFile &) = delete;
+ MappedFile &operator=(const MappedFile &) = delete;
+};
+} // namespace fst
+
+#endif // FST_LIB_MAPPED_FILE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Class to add a matcher to an FST.
+
+#ifndef FST_LIB_MATCHER_FST_H_
+#define FST_LIB_MATCHER_FST_H_
+
+#include <memory>
+#include <string>
+
+#include <fst/add-on.h>
+#include <fst/const-fst.h>
+#include <fst/lookahead-matcher.h>
+
+
+namespace fst {
+
+// Writeable matchers have the same interface as Matchers (as defined in
+// matcher.h) along with the following additional methods:
+//
+// template <class F>
+// 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 M>
+class NullMatcherFstInit {
+ public:
+ using MatcherData = typename M::MatcherData;
+ using Data = AddOnPair<MatcherData, MatcherData>;
+ using Impl = internal::AddOnImpl<typename M::FST, Data>;
+
+ explicit NullMatcherFstInit(std::shared_ptr<Impl> *) {}
+};
+
+// 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<M>,
+ class Data = AddOnPair<typename M::MatcherData, typename M::MatcherData>>
+class MatcherFst : public ImplToExpandedFst<internal::AddOnImpl<F, Data>> {
+ 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<FST, Data>;
+ using D = Data;
+
+ friend class StateIterator<MatcherFst<FST, FstMatcher, Name, Init, Data>>;
+ friend class ArcIterator<MatcherFst<FST, FstMatcher, Name, Init, Data>>;
+
+ MatcherFst() : ImplToExpandedFst<Impl>(std::make_shared<Impl>(FST(), Name)) {}
+
+ explicit MatcherFst(const FST &fst, std::shared_ptr<Data> data = nullptr)
+ : ImplToExpandedFst<Impl>(data ? CreateImpl(fst, Name, data)
+ : CreateDataAndImpl(fst, Name)) {}
+
+ explicit MatcherFst(const Fst<Arc> &fst)
+ : ImplToExpandedFst<Impl>(CreateDataAndImpl(fst, Name)) {}
+
+ // See Fst<>::Copy() for doc.
+ MatcherFst(const MatcherFst<FST, FstMatcher, Name, Init, Data> &fst,
+ bool safe = false)
+ : ImplToExpandedFst<Impl>(fst, safe) {}
+
+ // Get a copy of this MatcherFst. See Fst<>::Copy() for further doc.
+ MatcherFst<FST, FstMatcher, Name, Init, Data> *Copy(
+ bool safe = false) const override {
+ return new MatcherFst<FST, FstMatcher, Name, Init, Data>(*this, safe);
+ }
+
+ // Read a MatcherFst from an input stream; return nullptr on error
+ static MatcherFst<FST, M, Name, Init, Data> *Read(
+ std::istream &strm, const FstReadOptions &opts) {
+ auto *impl = Impl::Read(strm, opts);
+ return impl ? new MatcherFst<FST, FstMatcher, Name, Init, Data>(
+ std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ // Read a MatcherFst from a file; return nullptr on error
+ // Empty filename reads from standard input
+ static MatcherFst<FST, FstMatcher, Name, Init, Data> *Read(
+ const string &filename) {
+ auto *impl = ImplToExpandedFst<Impl>::Read(filename);
+ return impl ? new MatcherFst<FST, FstMatcher, Name, Init, Data>(
+ std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return GetImpl()->Write(strm, opts);
+ }
+
+ bool Write(const string &filename) const override {
+ return Fst<Arc>::WriteFile(filename);
+ }
+
+ void InitStateIterator(StateIteratorData<Arc> *data) const override {
+ return GetImpl()->InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *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<Data> 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<MatcherData> GetSharedData(MatchType match_type) const {
+ const auto *data = GetAddOn();
+ return match_type == MATCH_INPUT ? data->SharedFirst()
+ : data->SharedSecond();
+ }
+
+ protected:
+ using ImplToFst<Impl, ExpandedFst<Arc>>::GetImpl;
+
+ static std::shared_ptr<Impl> CreateDataAndImpl(const FST &fst,
+ const string &name) {
+ FstMatcher imatcher(fst, MATCH_INPUT);
+ FstMatcher omatcher(fst, MATCH_OUTPUT);
+ return CreateImpl(fst, name,
+ std::make_shared<Data>(imatcher.GetSharedData(),
+ omatcher.GetSharedData()));
+ }
+
+ static std::shared_ptr<Impl> CreateDataAndImpl(const Fst<Arc> &fst,
+ const string &name) {
+ FST result(fst);
+ return CreateDataAndImpl(result, name);
+ }
+
+ static std::shared_ptr<Impl> CreateImpl(const FST &fst, const string &name,
+ std::shared_ptr<Data> data) {
+ CHECK(data);
+ auto impl = std::make_shared<Impl>(fst, name);
+ impl->SetAddOn(data);
+ Init init(&impl);
+ return impl;
+ }
+
+ explicit MatcherFst(std::shared_ptr<Impl> impl)
+ : ImplToExpandedFst<Impl>(impl) {}
+
+ private:
+ MatcherFst &operator=(const MatcherFst &) = delete;
+};
+
+// Specialization for MatcherFst.
+template <class FST, class M, const char *Name, class Init>
+class StateIterator<MatcherFst<FST, M, Name, Init>>
+ : public StateIterator<FST> {
+ public:
+ explicit StateIterator(const MatcherFst<FST, M, Name, Init> &fst)
+ : StateIterator<FST>(fst.GetImpl()->GetFst()) {}
+};
+
+// Specialization for MatcherFst.
+template <class FST, class M, const char *Name, class Init>
+class ArcIterator<MatcherFst<FST, M, Name, Init>> : public ArcIterator<FST> {
+ public:
+ using StateId = typename FST::Arc::StateId;
+
+ ArcIterator(const MatcherFst<FST, M, Name, Init> &fst,
+ typename FST::Arc::StateId s)
+ : ArcIterator<FST>(fst.GetImpl()->GetFst(), s) {}
+};
+
+// Specialization for MatcherFst.
+template <class F, class M, const char *Name, class Init>
+class Matcher<MatcherFst<F, M, Name, Init>> {
+ public:
+ using FST = MatcherFst<F, M, Name, Init>;
+ 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<FST> &matcher) : matcher_(matcher.matcher_->Copy()) {}
+
+ Matcher<FST> *Copy() const { return new Matcher<FST>(*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<M> matcher_;
+};
+
+// Specialization for MatcherFst.
+template <class F, class M, const char *Name, class Init>
+class LookAheadMatcher<MatcherFst<F, M, Name, Init>> {
+ public:
+ using FST = MatcherFst<F, M, Name, Init>;
+ 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<FST> &matcher, bool safe = false)
+ : matcher_(matcher.matcher_->Copy(safe)) {}
+
+ // General matcher methods.
+ LookAheadMatcher<FST> *Copy(bool safe = false) const {
+ return new LookAheadMatcher<FST>(*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<Arc> &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<Arc> &fst, bool copy = false) {
+ matcher_->InitLookAheadFst(fst, copy);
+ }
+
+ private:
+ std::unique_ptr<M> matcher_;
+};
+
+// Useful aliases when using StdArc.
+
+extern const char arc_lookahead_fst_type[];
+
+using StdArcLookAheadFst =
+ MatcherFst<ConstFst<StdArc>,
+ ArcLookAheadMatcher<SortedMatcher<ConstFst<StdArc>>>,
+ 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<StdArc>,
+ LabelLookAheadMatcher<SortedMatcher<ConstFst<StdArc>>,
+ ilabel_lookahead_flags, FastLogAccumulator<StdArc>>,
+ ilabel_lookahead_fst_type, LabelLookAheadRelabeler<StdArc>>;
+
+using StdOLabelLookAheadFst = MatcherFst<
+ ConstFst<StdArc>,
+ LabelLookAheadMatcher<SortedMatcher<ConstFst<StdArc>>,
+ olabel_lookahead_flags, FastLogAccumulator<StdArc>>,
+ olabel_lookahead_fst_type, LabelLookAheadRelabeler<StdArc>>;
+
+} // namespace fst
+
+#endif // FST_LIB_MATCHER_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Classes to allow matching labels leaving FST states.
+
+#ifndef FST_LIB_MATCHER_H_
+#define FST_LIB_MATCHER_H_
+
+#include <algorithm>
+#include <unordered_map>
+#include <utility>
+
+#include <fst/mutable-fst.h> // 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 F>
+// 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.
+// Matcher(const FST &fst, MatchType type);
+// // If safe = true, the copy is thread-safe. See Fst<>::Copy()
+// // for further doc.
+// Matcher(const Matcher &matcher, bool safe = false);
+//
+// // If safe=true, the copy is thread-safe. See Fst<>::Copy()
+// // for further doc.
+// Matcher<FST> *Copy(bool safe = false) const;
+//
+// // 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;
+// // Specifies the current state.
+// void SetState(StateId state);
+//
+// // This finds matches to a label at the current state.
+// // Returns 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);
+// // These iterate through any matches found:
+// bool Done() const; // No more matches.
+// const A& Value() const; // Current arc (when !Done)
+// void Next(); // Advance to next arc (when !Done)
+// // Initially and after SetState() the iterator methods
+// // have undefined behavior until Find() is called.
+//
+// // Returns finality of a state.
+// Weight Final(StateId state) const;
+//
+// // Indicates preference for being the side used for matching in
+// // composition/intersection. 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 state);
+//
+// // Return matcher FST.
+// const FST &GetFst() const;
+// // 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;
+// };
+
+//
+// MATCHER FLAGS (see also kLookAheadFlags in lookahead-matcher.h)
+//
+// 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 A>
+class MatcherBase {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ virtual ~MatcherBase() {}
+
+ virtual MatcherBase<A> *Copy(bool safe = false) const = 0;
+
+ virtual MatchType Type(bool test) const = 0;
+
+ void SetState(StateId s) { SetState_(s); }
+
+ bool Find(Label label) { return Find_(label); }
+
+ bool Done() const { return Done_(); }
+
+ const A &Value() const { return Value_(); }
+
+ void Next() { Next_(); }
+
+ Weight Final(StateId state) const { return Final_(state); }
+
+ ssize_t Priority(StateId state) { return Priority_(state); }
+
+ virtual const Fst<A> &GetFst() const = 0;
+
+ virtual uint64 Properties(uint64 props) const = 0;
+
+ virtual uint32 Flags() const { return 0; }
+
+ private:
+ virtual void SetState_(StateId state) = 0;
+
+ virtual bool Find_(Label label) = 0;
+
+ virtual bool Done_() const = 0;
+
+ virtual const A &Value_() const = 0;
+
+ virtual void Next_() = 0;
+
+ virtual Weight Final_(StateId state) const { return GetFst().Final(state); }
+
+ virtual ssize_t Priority_(StateId state) { return GetFst().NumArcs(state); }
+};
+
+// 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 F>
+class SortedMatcher : public MatcherBase<typename F::Arc> {
+ public:
+ using FST = F;
+ using Arc = typename FST::Arc;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ // Labels >= binary_label will be searched for by binary search;
+ // o.w. linear search is used.
+ SortedMatcher(const F &fst, MatchType match_type, Label binary_label = 1)
+ : fst_(fst.Copy()),
+ 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;
+ }
+ }
+
+ SortedMatcher(const SortedMatcher<FST> &matcher, bool safe = false)
+ : fst_(matcher.fst_->Copy(safe)),
+ 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<FST> *Copy(bool safe = false) const override {
+ return new SortedMatcher<FST>(*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 state) {
+ if (state == state_) return;
+ state_ = state;
+ if (match_type_ == MATCH_NONE) {
+ FSTERROR() << "SortedMatcher: Bad match type";
+ error_ = true;
+ }
+ Destroy(aiter_, &aiter_pool_);
+ aiter_ = new (&aiter_pool_) ArcIterator<FST>(*fst_, state);
+ aiter_->SetFlags(kArcNoCache, kArcNoCache);
+ narcs_ = internal::NumArcs(*fst_, state);
+ loop_.nextstate = state;
+ }
+
+ bool Find(Label match_label) {
+ 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 match_label) {
+ exact_match_ = false;
+ current_loop_ = false;
+ if (error_) {
+ match_label_ = kNoLabel;
+ return;
+ }
+ match_label_ = match_label;
+ Search();
+ }
+
+ // After Find(), returns false if no more exact matches.
+ // After LowerBound(), returns false if no more arcs.
+ bool Done() const {
+ if (current_loop_) return false;
+ if (aiter_->Done()) return true;
+ if (!exact_match_) return false;
+ aiter_->SetFlags(
+ match_type_ == MATCH_INPUT ? kArcILabelValue : kArcOLabelValue,
+ kArcValueFlags);
+ const auto label = match_type_ == MATCH_INPUT ? aiter_->Value().ilabel
+ : aiter_->Value().olabel;
+ return label != match_label_;
+ }
+
+ const Arc &Value() const {
+ if (current_loop_) return loop_;
+ aiter_->SetFlags(kArcValueFlags, kArcValueFlags);
+ return aiter_->Value();
+ }
+
+ void Next() {
+ if (current_loop_) {
+ current_loop_ = false;
+ } else {
+ aiter_->Next();
+ }
+ }
+
+ Weight Final(StateId state) const { return internal::Final(*fst_, state); }
+
+ ssize_t Priority(StateId state) { return internal::NumArcs(*fst_, state); }
+
+ 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:
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId state) const override { return Final(state); }
+
+ ssize_t Priority_(StateId state) override { return Priority(state); }
+
+ bool Search();
+
+ std::unique_ptr<const FST> fst_;
+ StateId state_; // Current state.
+ ArcIterator<FST> *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<ArcIterator<FST>> aiter_pool_; // Pool of arc iterators.
+};
+
+// Returns true iff match to match_label_. Positions arc iterator at
+// lower bound regardless.
+template <class FST>
+inline bool SortedMatcher<FST>::Search() {
+ aiter_->SetFlags(
+ match_type_ == MATCH_INPUT ? kArcILabelValue : kArcOLabelValue,
+ kArcValueFlags);
+ if (match_label_ >= binary_label_) {
+ // Binary search for match.
+ size_t low = 0;
+ size_t high = narcs_;
+ while (low < high) {
+ const auto mid = (low + high) / 2;
+ aiter_->Seek(mid);
+ auto label = match_type_ == MATCH_INPUT ? aiter_->Value().ilabel
+ : aiter_->Value().olabel;
+ if (label > match_label_) {
+ high = mid;
+ } else if (label < match_label_) {
+ low = mid + 1;
+ } else {
+ // Finds first matching label (when non-deterministic).
+ for (auto i = mid; i > low; --i) {
+ aiter_->Seek(i - 1);
+ label = match_type_ == MATCH_INPUT ? aiter_->Value().ilabel
+ : aiter_->Value().olabel;
+ if (label != match_label_) {
+ aiter_->Seek(i);
+ return true;
+ }
+ }
+ return true;
+ }
+ }
+ aiter_->Seek(low);
+ return false;
+ } else {
+ // Linear search for match.
+ for (aiter_->Reset(); !aiter_->Done(); aiter_->Next()) {
+ const auto label = match_type_ == MATCH_INPUT ? aiter_->Value().ilabel
+ : aiter_->Value().olabel;
+ if (label == match_label_) return true;
+ if (label > match_label_) break;
+ }
+ return false;
+ }
+}
+
+// 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 F>
+class HashMatcher : public MatcherBase<typename F::Arc> {
+ 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 LabelTable = std::unordered_multimap<Label, size_t>;
+ using StateTable = std::unordered_map<StateId, LabelTable>;
+
+ HashMatcher(const FST &fst, MatchType match_type)
+ : fst_(fst.Copy()),
+ state_(kNoStateId),
+ match_type_(match_type),
+ loop_(kNoLabel, 0, Weight::One(), kNoStateId) {
+ 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;
+ }
+ }
+
+ HashMatcher(const HashMatcher<FST> &matcher, bool safe = false)
+ : fst_(matcher.fst_->Copy(safe)),
+ state_(kNoStateId),
+ match_type_(matcher.match_type_),
+ loop_(matcher.loop_),
+ error_(matcher.error_) {}
+
+ HashMatcher<FST> *Copy(bool safe = false) const override {
+ return new HashMatcher<FST>(*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 state) {
+ if (state == state_) return;
+ // Resets everything for the state.
+ state_ = state;
+ loop_.nextstate = state_;
+ aiter_.reset(new ArcIterator<FST>(*fst_, state_));
+ if (match_type_ == MATCH_NONE) {
+ FSTERROR() << "HashMatcher: Bad match type";
+ error_ = false;
+ }
+ // Attempts to insert a new label table; if it already exists,
+ // no additional work is done and we simply return.
+ auto it_and_success = state_table_.emplace(state_, LabelTable());
+ if (!it_and_success.second) return;
+ // Otherwise, populate this new table.
+ // Sets instance's pointer to the label table for this state.
+ label_table_ = &(it_and_success.first->second);
+ // Populates the label table.
+ label_table_->reserve(internal::NumArcs(*fst_, state_));
+ const uint32 aiter_flags =
+ (match_type_ == MATCH_INPUT ? kArcILabelValue : kArcOLabelValue) |
+ kArcNoCache;
+ aiter_->SetFlags(aiter_flags, kArcFlags);
+ for (; !aiter_->Done(); aiter_->Next()) {
+ const auto match_label = (match_type_ == MATCH_INPUT)
+ ? aiter_->Value().ilabel
+ : aiter_->Value().olabel;
+ label_table_->emplace(match_label, aiter_->Position());
+ }
+ aiter_->SetFlags(kArcValueFlags, kArcValueFlags);
+ }
+
+ bool Find(Label match_label) {
+ current_loop_ = match_label == 0;
+ if (match_label == 0) {
+ Search(match_label);
+ return true;
+ }
+ if (match_label == kNoLabel) match_label = 0;
+ return Search(match_label);
+ }
+
+ bool Done() const {
+ if (current_loop_) return false;
+ return label_it_ == label_end_;
+ }
+
+ const Arc &Value() const {
+ if (current_loop_) return loop_;
+ aiter_->Seek(label_it_->second);
+ return aiter_->Value();
+ }
+
+ void Next() {
+ if (current_loop_) {
+ current_loop_ = false;
+ } else {
+ ++label_it_;
+ }
+ }
+
+ Weight Final(StateId state) const { return internal::Final(*fst_, state); }
+
+ ssize_t Priority(StateId state) { return internal::NumArcs(*fst_, state); }
+
+ const FST &GetFst() const override { return *fst_; }
+
+ uint64 Properties(uint64 inprops) const override {
+ return inprops | (error_ ? kError : 0);
+ }
+
+ private:
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId state) const override { return Final(state); }
+
+ ssize_t Priority_(StateId state) override { return Priority(state); }
+
+ bool Search(Label match_label);
+
+ std::unique_ptr<const FST> fst_;
+ StateId state_;
+ MatchType match_type_;
+ Arc loop_; // The implicit loop itself.
+ bool current_loop_; // Is the current arc is the implicit loop?
+ bool error_;
+ std::unique_ptr<ArcIterator<FST>> aiter_;
+ StateTable state_table_; // Table from states to label table.
+ LabelTable *label_table_; // Pointer to current state's label table.
+ typename LabelTable::iterator label_it_; // Position for label.
+ typename LabelTable::iterator label_end_; // Position for last label + 1.
+};
+
+template <class FST>
+inline bool HashMatcher<FST>::Search(typename FST::Arc::Label match_label) {
+ auto range = label_table_->equal_range(match_label);
+ if (range.first == range.second) return false;
+ label_it_ = range.first;
+ label_end_ = range.second;
+ aiter_->Seek(label_it_->second);
+ return true;
+}
+
+// Specifies whether during matching we rewrite both the input and output sides.
+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 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 M>
+class RhoMatcher : public MatcherBase<typename M::Arc> {
+ 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;
+
+ 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) {
+ 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;
+ }
+ }
+
+ RhoMatcher(const RhoMatcher<M> &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) {}
+
+ RhoMatcher<M> *Copy(bool safe = false) const override {
+ return new RhoMatcher<M>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return matcher_->Type(test); }
+
+ void SetState(StateId state) {
+ if (state == state_) return;
+ state_ = state;
+ matcher_->SetState(state);
+ has_rho_ = rho_label_ != kNoLabel;
+ }
+
+ bool Find(Label match_label) {
+ if (match_label == rho_label_ && rho_label_ != kNoLabel) {
+ FSTERROR() << "RhoMatcher::Find: bad label (rho)";
+ error_ = true;
+ return false;
+ }
+ if (matcher_->Find(match_label)) {
+ rho_match_ = kNoLabel;
+ return true;
+ } else if (has_rho_ && match_label != 0 && match_label != kNoLabel &&
+ (has_rho_ = matcher_->Find(rho_label_))) {
+ rho_match_ = match_label;
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ bool Done() const { return matcher_->Done(); }
+
+ const Arc &Value() const {
+ 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() { matcher_->Next(); }
+
+ Weight Final(StateId state) const { return matcher_->Final(state); }
+
+ ssize_t Priority(StateId state) {
+ state_ = state;
+ matcher_->SetState(state);
+ has_rho_ = matcher_->Find(rho_label_);
+ if (has_rho_) {
+ return kRequirePriority;
+ } else {
+ return matcher_->Priority(state);
+ }
+ }
+
+ 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:
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId s) const override { return Final(s); }
+
+ ssize_t Priority_(StateId s) override { return Priority(s); }
+
+ std::unique_ptr<M> 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_'.
+ bool has_rho_; // Are there possibly rhos at the current state?
+ 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_; // Current state.
+};
+
+template <class M>
+inline uint64 RhoMatcher<M>::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 M>
+class SigmaMatcher : public MatcherBase<typename M::Arc> {
+ 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;
+
+ 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;
+ }
+ }
+
+ SigmaMatcher(const SigmaMatcher<M> &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<M> *Copy(bool safe = false) const override {
+ return new SigmaMatcher<M>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return matcher_->Type(test); }
+
+ void SetState(StateId state) {
+ if (state == state_) return;
+ state_ = state;
+ matcher_->SetState(state);
+ has_sigma_ =
+ (sigma_label_ != kNoLabel) ? matcher_->Find(sigma_label_) : false;
+ }
+
+ bool Find(Label match_label) {
+ 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 { return matcher_->Done(); }
+
+ const Arc &Value() const {
+ 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() {
+ matcher_->Next();
+ if (matcher_->Done() && has_sigma_ && (sigma_match_ == kNoLabel) &&
+ (match_label_ > 0)) {
+ matcher_->Find(sigma_label_);
+ sigma_match_ = match_label_;
+ }
+ }
+
+ Weight Final(StateId state) const { return matcher_->Final(state); }
+
+ ssize_t Priority(StateId state) {
+ if (sigma_label_ != kNoLabel) {
+ SetState(state);
+ return has_sigma_ ? kRequirePriority : matcher_->Priority(state);
+ } else {
+ return matcher_->Priority(state);
+ }
+ }
+
+ 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:
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId s) const override { return Final(s); }
+
+ ssize_t Priority_(StateId s) override { return Priority(s); }
+
+ std::unique_ptr<M> 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_; // Current state.
+};
+
+template <class M>
+inline uint64 SigmaMatcher<M>::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;
+ }
+}
+
+// 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 M>
+class PhiMatcher : public MatcherBase<typename M::Arc> {
+ 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;
+
+ 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;
+ }
+ }
+
+ PhiMatcher(const PhiMatcher<M> &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<M> *Copy(bool safe = false) const override {
+ return new PhiMatcher<M>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return matcher_->Type(test); }
+
+ void SetState(StateId state) {
+ if (state == state_) return;
+ matcher_->SetState(state);
+ state_ = state;
+ has_phi_ = phi_label_ != kNoLabel;
+ }
+
+ bool Find(Label match_label);
+
+ bool Done() const { return matcher_->Done(); }
+
+ const Arc &Value() const {
+ 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() { matcher_->Next(); }
+
+ Weight Final(StateId state) const {
+ Weight final_weight = matcher_->Final(state);
+ if (phi_label_ == kNoLabel || final_weight != Weight::Zero()) {
+ return final_weight;
+ }
+ final_weight = Weight::One();
+ StateId s = state;
+ matcher_->SetState(s);
+ while (matcher_->Final(s) == Weight::Zero()) {
+ if (!matcher_->Find(phi_label_ == 0 ? -1 : phi_label_)) break;
+ final_weight = Times(final_weight, matcher_->Value().weight);
+ if (s == matcher_->Value().nextstate) {
+ return Weight::Zero(); // Do not follow phi self-loops.
+ }
+ s = matcher_->Value().nextstate;
+ matcher_->SetState(s);
+ }
+ final_weight = Times(final_weight, matcher_->Final(s));
+ return final_weight;
+ }
+
+ ssize_t Priority(StateId state) {
+ if (phi_label_ != kNoLabel) {
+ matcher_->SetState(state);
+ const bool has_phi = matcher_->Find(phi_label_ == 0 ? -1 : phi_label_);
+ return has_phi ? kRequirePriority : matcher_->Priority(state);
+ } else {
+ return matcher_->Priority(state);
+ }
+ }
+
+ 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:
+ void SetState_(StateId s) override { SetState(s); }
+ bool Find_(Label label) override { return Find(label); }
+ bool Done_() const override { return Done(); }
+ const Arc &Value_() const override { return Value(); }
+ void Next_() override { Next(); }
+ Weight Final_(StateId s) const override { return Final(s); }
+ ssize_t Priority_(StateId s) override { return Priority(s); }
+
+ mutable std::unique_ptr<M> 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_; // State where looking for matches
+ 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 <class M>
+inline bool PhiMatcher<M>::Find(Label match_label) {
+ if (match_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) { // When 'phi_label_ == 0',
+ if (match_label == kNoLabel) { // there are no more true epsilon arcs,
+ return false;
+ }
+ if (match_label == 0) { // but virtual eps loop needs to be returned
+ if (!matcher_->Find(kNoLabel)) {
+ return matcher_->Find(0);
+ } else {
+ phi_match_ = 0;
+ return true;
+ }
+ }
+ }
+ if (!has_phi_ || match_label == 0 || match_label == kNoLabel) {
+ return matcher_->Find(match_label);
+ }
+ StateId state = state_;
+ while (!matcher_->Find(match_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 == state) {
+ phi_match_ = match_label;
+ return true;
+ }
+ phi_weight_ = Times(phi_weight_, matcher_->Value().weight);
+ state = matcher_->Value().nextstate;
+ matcher_->Next();
+ if (!matcher_->Done()) {
+ FSTERROR() << "PhiMatcher: Phi non-determinism not supported";
+ error_ = true;
+ }
+ matcher_->SetState(state);
+ }
+ return true;
+}
+
+template <class M>
+inline uint64 PhiMatcher<M>::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;
+ }
+}
+
+// MULTI-EPS MATCHER FLAGS.
+
+// 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 M>
+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;
+
+ 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) {
+ 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;
+ }
+
+ MultiEpsMatcher(const MultiEpsMatcher<M> &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<M> *Copy(bool safe = false) const {
+ return new MultiEpsMatcher<M>(*this, safe);
+ }
+
+ MatchType Type(bool test) const { return matcher_->Type(test); }
+
+ void SetState(StateId state) {
+ matcher_->SetState(state);
+ loop_.nextstate = state;
+ }
+
+ bool Find(Label match_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;
+ }
+ }
+
+ Weight Final(StateId state) const { return matcher_->Final(state); }
+
+ ssize_t Priority(StateId state) { return matcher_->Priority(state); }
+
+ const FST &GetFst() const { return matcher_->GetFst(); }
+
+ const M *GetMatcher() const { return matcher_; }
+
+ uint64 Properties(uint64 props) const { return matcher_->Properties(props); }
+
+ uint32 Flags() const { return matcher_->Flags(); }
+
+ 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:
+ M *matcher_;
+ uint32 flags_;
+ bool own_matcher_; // Does this class delete the matcher?
+
+ // Multi-eps label set.
+ CompactSet<Label, kNoLabel> multi_eps_labels_;
+ typename CompactSet<Label, kNoLabel>::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 <class M>
+inline bool MultiEpsMatcher<M>::Find(Label match_label) {
+ multi_eps_iter_ = multi_eps_labels_.End();
+ current_loop_ = false;
+ bool ret;
+ if (match_label == 0) {
+ ret = matcher_->Find(0);
+ } else if (match_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(match_label) != multi_eps_labels_.End()) {
+ // Returns 'implicit' loop.
+ current_loop_ = true;
+ ret = true;
+ } else {
+ ret = matcher_->Find(match_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 M>
+class ExplicitMatcher : public MatcherBase<typename M::Arc> {
+ 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;
+
+ ExplicitMatcher(const FST &fst, MatchType match_type, M *matcher = nullptr)
+ : matcher_(matcher ? matcher : new M(fst, match_type)),
+ match_type_(match_type),
+ error_(false) {}
+
+ ExplicitMatcher(const ExplicitMatcher<M> &matcher, bool safe = false)
+ : matcher_(new M(*matcher.matcher_, safe)),
+ match_type_(matcher.match_type_),
+ error_(matcher.error_) {}
+
+ ExplicitMatcher<M> *Copy(bool safe = false) const override {
+ return new ExplicitMatcher<M>(*this, safe);
+ }
+
+ MatchType Type(bool test) const override { return matcher_->Type(test); }
+
+ void SetState(StateId state) { matcher_->SetState(state); }
+
+ bool Find(Label match_label) {
+ matcher_->Find(match_label);
+ CheckArc();
+ return !Done();
+ }
+
+ bool Done() const { return matcher_->Done(); }
+
+ const Arc &Value() const { return matcher_->Value(); }
+
+ void Next() {
+ matcher_->Next();
+ CheckArc();
+ }
+
+ Weight Final(StateId state) const { return matcher_->Final(state); }
+
+ ssize_t Priority(StateId state) { return matcher_->Priority(state); }
+
+ const FST &GetFst() const override { return matcher_->GetFst(); }
+
+ const M *GetMatcher() const { return matcher_.get(); }
+
+ uint64 Properties(uint64 inprops) const override {
+ return matcher_->Properties(inprops);
+ }
+
+ 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()) {
+ Label label = match_type_ == MATCH_INPUT ? matcher_->Value().ilabel
+ : matcher_->Value().olabel;
+ if (label != kNoLabel) return;
+ }
+ }
+
+ void SetState_(StateId state) override { SetState(state); }
+
+ bool Find_(Label label) override { return Find(label); }
+
+ bool Done_() const override { return Done(); }
+
+ const Arc &Value_() const override { return Value(); }
+
+ void Next_() override { Next(); }
+
+ Weight Final_(StateId s) const override { return Final(s); }
+
+ ssize_t Priority_(StateId s) override { return Priority(s); }
+
+ std::unique_ptr<M> matcher_;
+ MatchType match_type_; // Type of match requested.
+ bool error_; // Error encountered.
+};
+
+// Generic matcher, templated on the FST definition
+// - a wrapper around pointer to specific one.
+// Here is a typical use: \code
+// Matcher<StdFst> matcher(fst, MATCH_INPUT);
+// matcher.SetState(state);
+// if (matcher.Find(label))
+// for (; !matcher.Done(); matcher.Next()) {
+// StdArc &arc = matcher.Value();
+// ...
+// } \endcode
+template <class F>
+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;
+
+ Matcher(const FST &fst, MatchType match_type) {
+ base_.reset(fst.InitMatcher(match_type));
+ if (!base_) base_.reset(new SortedMatcher<FST>(fst, match_type));
+ }
+
+ Matcher(const Matcher<FST> &matcher, bool safe = false) {
+ base_.reset(matcher.base_->Copy(safe));
+ }
+
+ // Takes ownership of the provided matcher
+ explicit Matcher(MatcherBase<Arc> *base_matcher) {
+ base_.reset(base_matcher);
+ }
+
+ Matcher<FST> *Copy(bool safe = false) const {
+ return new Matcher<FST>(*this, safe);
+ }
+
+ MatchType Type(bool test) const { return base_->Type(test); }
+
+ void SetState(StateId state) { base_->SetState(state); }
+
+ 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(); }
+
+ Weight Final(StateId state) const { return base_->Final(state); }
+
+ ssize_t Priority(StateId state) { return base_->Priority(state); }
+
+ const FST &GetFst() const {
+ return static_cast<const FST &>(base_->GetFst());
+ }
+
+ uint64 Properties(uint64 props) const { return base_->Properties(props); }
+
+ uint32 Flags() const { return base_->Flags() & kMatcherFlags; }
+
+ private:
+ std::unique_ptr<MatcherBase<Arc>> base_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_MATCHER_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// FST memory utilities.
+
+#ifndef FST_LIB_MEMORY_H_
+#define FST_LIB_MEMORY_H_
+
+#include <list>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <fst/types.h>
+#include <fstream>
+
+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;
+};
+
+// Allocates 'size' unintialized memory chunks of size sizeof(T) from underlying
+// blocks of (at least) size 'block_size * sizeof(T)'. All blocks are freed when
+// this class is deleted. Result of allocate() will be aligned to sizeof(T).
+template <typename T>
+class MemoryArena : public MemoryArenaBase {
+ public:
+ explicit MemoryArena(size_t block_size = kAllocSize)
+ : block_size_(block_size * sizeof(T)), block_pos_(0) {
+ blocks_.emplace_front(new char[block_size_]);
+ }
+
+ void *Allocate(size_t size) {
+ const auto byte_size = size * sizeof(T);
+ 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 sizeof(T); }
+
+ private:
+ size_t block_size_; // Default block size in bytes.
+ size_t block_pos_; // Current position in block in bytes.
+ std::list<std::unique_ptr<char[]>> blocks_; // List of allocated blocks.
+};
+
+// 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;
+};
+
+// Allocates and frees initially uninitialized memory chunks of size sizeof(T).
+// 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'. 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 fucntions 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 <typename T>
+class MemoryPool : public MemoryPoolBase {
+ public:
+ struct Link {
+ char buf[sizeof(T)];
+ Link *next;
+ };
+
+ // 'pool_size' specifies the size of the initial pool and how it is extended.
+ explicit MemoryPool(size_t pool_size = kAllocSize)
+ : mem_arena_(pool_size), free_list_(nullptr) {}
+
+ void *Allocate() {
+ if (free_list_ == nullptr) {
+ auto *link = static_cast<Link *>(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<Link *>(ptr);
+ link->next = free_list_;
+ free_list_ = link;
+ }
+ }
+
+ size_t Size() const override { return sizeof(T); }
+
+ private:
+ MemoryArena<Link> mem_arena_;
+ Link *free_list_;
+
+ MemoryPool(const MemoryPool &) = delete;
+ MemoryPool &operator=(const MemoryPool &) = delete;
+};
+
+// 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 <typename T>
+ MemoryArena<T> *Arena() {
+ if (sizeof(T) >= arenas_.size()) arenas_.resize(sizeof(T) + 1);
+ MemoryArenaBase *arena = arenas_[sizeof(T)].get();
+ if (arena == nullptr) {
+ arena = new MemoryArena<T>(block_size_);
+ arenas_[sizeof(T)].reset(arena);
+ }
+ return static_cast<MemoryArena<T> *>(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<std::unique_ptr<MemoryArenaBase>> 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 <typename T>
+ MemoryPool<T> *Pool() {
+ if (sizeof(T) >= pools_.size()) pools_.resize(sizeof(T) + 1);
+ MemoryPoolBase *pool = pools_[sizeof(T)].get();
+ if (pool == nullptr) {
+ pool = new MemoryPool<T>(pool_size_);
+ pools_[sizeof(T)].reset(pool);
+ }
+ return static_cast<MemoryPool<T> *>(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<std::unique_ptr<MemoryPoolBase>> 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 <typename T>
+class BlockAllocator {
+ public:
+ using Allocator = std::allocator<T>;
+ 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 <typename U>
+ struct rebind {
+ using other = BlockAllocator<U>;
+ };
+
+ explicit BlockAllocator(size_t block_size = kAllocSize)
+ : arenas_(new MemoryArenaCollection(block_size)) {}
+
+ BlockAllocator(const BlockAllocator<T> &arena_alloc)
+ : arenas_(arena_alloc.Arenas()) {
+ Arenas()->IncrRefCount();
+ }
+
+ template <typename U>
+ explicit BlockAllocator(const BlockAllocator<U> &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 <class U, class... Args>
+ void construct(U *p, Args &&... args) {
+ Allocator().construct(p, std::forward<Args>(args)...);
+ }
+
+ void destroy(pointer p) { Allocator().destroy(p); }
+
+ pointer allocate(size_type n, const void *hint = nullptr) {
+ if (n * kAllocFit <= kAllocSize) {
+ return static_cast<pointer>(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<T> *Arena() { return arenas_->Arena<T>(); }
+
+ MemoryArenaCollection *arenas_;
+
+ BlockAllocator<T> operator=(const BlockAllocator<T> &);
+};
+
+template <typename T, typename U>
+bool operator==(const BlockAllocator<T> &alloc1,
+ const BlockAllocator<U> &alloc2) {
+ return false;
+}
+
+template <typename T, typename U>
+bool operator!=(const BlockAllocator<T> &alloc1,
+ const BlockAllocator<U> &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 <typename T>
+class PoolAllocator {
+ public:
+ using Allocator = std::allocator<T>;
+ 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 <typename U>
+ struct rebind {
+ using other = PoolAllocator<U>;
+ };
+
+ explicit PoolAllocator(size_t pool_size = kAllocSize)
+ : pools_(new MemoryPoolCollection(pool_size)) {}
+
+ PoolAllocator(const PoolAllocator<T> &pool_alloc)
+ : pools_(pool_alloc.Pools()) {
+ Pools()->IncrRefCount();
+ }
+
+ template <typename U>
+ explicit PoolAllocator(const PoolAllocator<U> &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 <class U, class... Args>
+ void construct(U *p, Args &&... args) {
+ Allocator().construct(p, std::forward<Args>(args)...);
+ }
+
+ void destroy(pointer p) { Allocator().destroy(p); }
+
+ pointer allocate(size_type n, const void *hint = nullptr) {
+ if (n == 1) {
+ return static_cast<pointer>(Pool<1>()->Allocate());
+ } else if (n == 2) {
+ return static_cast<pointer>(Pool<2>()->Allocate());
+ } else if (n <= 4) {
+ return static_cast<pointer>(Pool<4>()->Allocate());
+ } else if (n <= 8) {
+ return static_cast<pointer>(Pool<8>()->Allocate());
+ } else if (n <= 16) {
+ return static_cast<pointer>(Pool<16>()->Allocate());
+ } else if (n <= 32) {
+ return static_cast<pointer>(Pool<32>()->Allocate());
+ } else if (n <= 64) {
+ return static_cast<pointer>(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 <int n>
+ struct TN {
+ T buf[n];
+ };
+
+ template <int n>
+ MemoryPool<TN<n>> *Pool() {
+ return pools_->Pool<TN<n>>();
+ }
+
+ MemoryPoolCollection *pools_;
+
+ PoolAllocator<T> operator=(const PoolAllocator<T> &);
+};
+
+template <typename T, typename U>
+bool operator==(const PoolAllocator<T> &alloc1,
+ const PoolAllocator<U> &alloc2) {
+ return false;
+}
+
+template <typename T, typename U>
+bool operator!=(const PoolAllocator<T> &alloc1,
+ const PoolAllocator<U> &alloc2) {
+ return true;
+}
+
+} // namespace fst
+
+#endif // FST_LIB_MEMORY_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes to minimize an FST.
+
+#ifndef FST_LIB_MINIMIZE_H_
+#define FST_LIB_MINIMIZE_H_
+
+#include <cmath>
+
+#include <algorithm>
+#include <map>
+#include <queue>
+#include <utility>
+#include <vector>
+
+#include <fst/arcsort.h>
+#include <fst/connect.h>
+#include <fst/dfs-visit.h>
+#include <fst/encode.h>
+#include <fst/factor-weight.h>
+#include <fst/fst.h>
+#include <fst/mutable-fst.h>
+#include <fst/partition.h>
+#include <fst/push.h>
+#include <fst/queue.h>
+#include <fst/reverse.h>
+#include <fst/state-map.h>
+
+
+namespace fst {
+namespace internal {
+
+// Comparator for creating partition.
+template <class Arc>
+class StateComparator {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ StateComparator(const Fst<Arc> &fst, const Partition<StateId> &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<Fst<Arc>> 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<Arc> &fst_;
+ const Partition<StateId> &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 Arc, class Queue>
+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<Arc>;
+
+ explicit CyclicMinimizer(const ExpandedFst<Arc> &fst) {
+ Initialize(fst);
+ Compute(fst);
+ }
+
+ const Partition<StateId> &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<Arc> &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<Fst<Arc>> aiter(fst_, s); !aiter.Done(); aiter.Next()) {
+ Label this_ilabel = aiter.Value().ilabel;
+ if (this_ilabel != current_ilabel) { // Ignores repeats.
+ result = p1 * result + this_ilabel;
+ current_ilabel = this_ilabel;
+ }
+ }
+ return result;
+ }
+
+ private:
+ const Fst<Arc> &fst_;
+ };
+
+ class ArcIterCompare {
+ public:
+ explicit ArcIterCompare(const Partition<StateId> &partition)
+ : partition_(partition) {}
+
+ ArcIterCompare(const ArcIterCompare &comp) : partition_(comp.partition_) {}
+
+ // Compares two iterators based on their input labels.
+ bool operator()(const ArcIterator<Fst<RevArc>> *x,
+ const ArcIterator<Fst<RevArc>> *y) const {
+ const auto &xarc = x->Value();
+ const auto &yarc = y->Value();
+ return xarc.ilabel > yarc.ilabel;
+ }
+
+ private:
+ const Partition<StateId> &partition_;
+ };
+
+ using ArcIterQueue =
+ std::priority_queue<ArcIterator<Fst<RevArc>> *,
+ std::vector<ArcIterator<Fst<RevArc>> *>,
+ 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<Arc> &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<StateId> 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<size_t, StateId>;
+ HashToClassMap hash_to_class_nonfinal;
+ HashToClassMap hash_to_class_final;
+ StateILabelHasher hasher(fst);
+ for (StateId s = 0; s < num_states; ++s) {
+ size_t hash = hasher(s);
+ HashToClassMap &this_map =
+ (fst.Final(s) != Weight::Zero() ? hash_to_class_final
+ : hash_to_class_nonfinal);
+ // Avoids two map lookups by using 'insert' instead of 'find'.
+ auto p = this_map.insert(std::make_pair(hash, next_class));
+ state_to_initial_class[s] = p.second ? next_class++ : p.first->second;
+ }
+ // Lets the unordered_maps go out of scope before we allocate the classes,
+ // to reduce the maximum amount of memory used.
+ }
+ P_.AllocateClasses(next_class);
+ for (StateId s = 0; s < num_states; ++s) {
+ P_.Add(s, state_to_initial_class[s]);
+ }
+ for (StateId c = 0; c < next_class; ++c) L_.Enqueue(c);
+ VLOG(5) << "Initial Partition: " << P_.NumClasses();
+ }
+
+ // Creates inverse transition Tr_ = rev(fst), loops over states in FST and
+ // splits on final, creating two blocks in the partition corresponding to
+ // final, non-final.
+ void Initialize(const ExpandedFst<Arc> &fst) {
+ // Constructs Tr.
+ Reverse(fst, &Tr_);
+ ILabelCompare<RevArc> ilabel_comp;
+ ArcSort(&Tr_, ilabel_comp);
+ // Tells the partition how many elements to allocate. The first state in
+ // Tr_ is super-final state.
+ P_.Initialize(Tr_.NumStates() - 1);
+ // Prepares initial partition.
+ PrePartition(fst);
+ // Allocates arc iterator queue.
+ ArcIterCompare comp(P_);
+ aiter_queue_.reset(new ArcIterQueue(comp));
+ }
+ // Partitions all classes with destination C.
+ void Split(ClassId C) {
+ // Prepares priority queue: opens arc iterator for each state in C, and
+ // inserts into priority queue.
+ for (PartitionIterator<StateId> siter(P_, C); !siter.Done(); siter.Next()) {
+ StateId s = siter.Value();
+ if (Tr_.NumArcs(s + 1)) {
+ aiter_queue_->push(new ArcIterator<Fst<RevArc>>(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<ArcIterator<Fst<RevArc>>> 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<Arc> &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<StateId> P_;
+ // Set of active classes to be processed in partition P.
+ Queue L_;
+ // Reverses transition function.
+ VectorFst<RevArc> Tr_;
+ // Priority queue of open arc iterators for all states in the splitter
+ // equivalence class.
+ std::unique_ptr<ArcIterQueue> 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 Arc>
+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<Arc> &fst) {
+ Initialize(fst);
+ Refine(fst);
+ }
+
+ const Partition<StateId> &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<Arc> &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<StateId> &height() const { return height_; }
+
+ size_t num_states() const { return num_states_; }
+
+ private:
+ std::vector<StateId> height_;
+ size_t max_height_;
+ size_t num_states_;
+ };
+
+ private:
+ // Cluster states according to height (distance to final state)
+ void Initialize(const Fst<Arc> &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<Arc> &fst) {
+ using EquivalenceMap = std::map<StateId, StateId, StateComparator<Arc>>;
+ StateComparator<Arc> 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<StateId> siter(partition_, h);
+ equiv_classes[siter.Value()] = h;
+ for (siter.Next(); !siter.Done(); siter.Next()) {
+ auto insert_result =
+ equiv_classes.insert(std::make_pair(siter.Value(), kNoStateId));
+ if (insert_result.second) {
+ insert_result.first->second = partition_.AddClass();
+ }
+ }
+ // Creates refined partition.
+ for (siter.Reset(); !siter.Done();) {
+ const auto s = siter.Value();
+ const auto old_class = partition_.ClassId(s);
+ const auto new_class = equiv_classes[s];
+ // A move operation can invalidate the iterator, so we first update
+ // the iterator to the next element before we move the current element
+ // out of the list.
+ siter.Next();
+ if (old_class != new_class) partition_.Move(s, new_class);
+ }
+ }
+ }
+
+ private:
+ Partition<StateId> 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 <class Arc>
+void MergeStates(const Partition<typename Arc::StateId> &partition,
+ MutableFst<Arc> *fst) {
+ using StateId = typename Arc::StateId;
+ std::vector<StateId> state_map(partition.NumClasses());
+ for (StateId i = 0; i < partition.NumClasses(); ++i) {
+ PartitionIterator<StateId> 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<StateId> siter(partition, c); !siter.Done();
+ siter.Next()) {
+ const auto s = siter.Value();
+ for (MutableArcIterator<MutableFst<Arc>> aiter(fst, s); !aiter.Done();
+ aiter.Next()) {
+ auto arc = aiter.Value();
+ arc.nextstate = state_map[partition.ClassId(arc.nextstate)];
+ if (s == state_map[c]) { // For the first state, just sets destination.
+ aiter.SetValue(arc);
+ } else {
+ fst->AddArc(state_map[c], arc);
+ }
+ }
+ }
+ }
+ fst->SetStart(state_map[partition.ClassId(fst->Start())]);
+ Connect(fst);
+}
+
+template <class Arc>
+void AcceptorMinimize(MutableFst<Arc> *fst,
+ bool allow_acyclic_minimization = true) {
+ if (!(fst->Properties(kAcceptor | kUnweighted, true) ==
+ (kAcceptor | kUnweighted))) {
+ FSTERROR() << "FST is not an unweighted acceptor";
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ // Connects FST before minimization, handles disconnected states.
+ Connect(fst);
+ if (fst->NumStates() == 0) return;
+ if (allow_acyclic_minimization && fst->Properties(kAcyclic, true)) {
+ // Acyclic minimization (Revuz).
+ VLOG(2) << "Acyclic minimization";
+ ArcSort(fst, ILabelCompare<Arc>());
+ AcyclicMinimizer<Arc> 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<Arc, LifoQueue<typename Arc::StateId>> minimizer(*fst);
+ MergeStates(minimizer.GetPartition(), fst);
+ }
+ // Merges in appropriate semiring
+ ArcUniqueMapper<Arc> mapper(*fst);
+ StateMap(fst, mapper);
+}
+
+} // namespace internal
+
+// In place minimization of deterministic weighted automata and transducers,
+// and also non-deterministic ones if they use an idempotent semiring.
+// For transducers, if the 'sfst' argument is not null, the algorithm
+// produces a compact factorization of the minimal transducer.
+//
+// In the acyclic deterministic case, we use an algorithm from Revuz that is
+// linear in the number of arcs (edges) in the machine.
+//
+// In the cyclic or non-deterministic case, we use the classical Hopcroft
+// minimization (which was presented for the deterministic case but which
+// also works for non-deterministic FSTs); this has complexity O(e log v).
+//
+template <class Arc>
+void Minimize(MutableFst<Arc> *fst, MutableFst<Arc> *sfst = nullptr,
+ float delta = kDelta, bool allow_nondet = false) {
+ using Weight = typename Arc::Weight;
+ const auto props = fst->Properties(
+ kAcceptor | kIDeterministic | kWeighted | kUnweighted, true);
+ bool allow_acyclic_minimization;
+ if (props & kIDeterministic) {
+ allow_acyclic_minimization = true;
+ } else {
+ // Our approach to minimization of non-deterministic FSTs will only work in
+ // idempotent semirings---for non-deterministic inputs, a state could have
+ // multiple transitions to states that will get merged, and we'd have to
+ // sum their weights. The algorithm doesn't handle that.
+ if (!(Weight::Properties() & kIdempotent)) {
+ fst->SetProperties(kError, kError);
+ FSTERROR() << "Cannot minimize a non-deterministic FST over a "
+ "non-idempotent semiring";
+ return;
+ } else if (!allow_nondet) {
+ fst->SetProperties(kError, kError);
+ FSTERROR() << "Refusing to minimize a non-deterministic FST with "
+ << "allow_nondet = false";
+ return;
+ }
+ // The Revuz algorithm won't work for nondeterministic inputs, so if the
+ // input is nondeterministic, we'll have to pass a bool saying not to use
+ // that algorithm. We check at this level rather than in AcceptorMinimize(),
+ // because it's possible that the FST at this level could be deterministic,
+ // but a harmless type of non-determinism could be introduced by Encode()
+ // (thanks to kEncodeWeights, if the FST has epsilons and has a final
+ // weight with weights equal to some epsilon arc.)
+ allow_acyclic_minimization = false;
+ }
+ if (!(props & kAcceptor)) { // Weighted transducer.
+ VectorFst<GallicArc<Arc, GALLIC_LEFT>> gfst;
+ ArcMap(*fst, &gfst, ToGallicMapper<Arc, GALLIC_LEFT>());
+ fst->DeleteStates();
+ gfst.SetProperties(kAcceptor, kAcceptor);
+ Push(&gfst, REWEIGHT_TO_INITIAL, delta);
+ ArcMap(&gfst, QuantizeMapper<GallicArc<Arc, GALLIC_LEFT>>(delta));
+ EncodeMapper<GallicArc<Arc, GALLIC_LEFT>> encoder(
+ kEncodeLabels | kEncodeWeights, ENCODE);
+ Encode(&gfst, &encoder);
+ internal::AcceptorMinimize(&gfst, allow_acyclic_minimization);
+ Decode(&gfst, encoder);
+ if (!sfst) {
+ FactorWeightFst<GallicArc<Arc, GALLIC_LEFT>,
+ GallicFactor<typename Arc::Label, Weight, GALLIC_LEFT>>
+ fwfst(gfst);
+ std::unique_ptr<SymbolTable> osyms(
+ fst->OutputSymbols() ? fst->OutputSymbols()->Copy() : nullptr);
+ ArcMap(fwfst, fst, FromGallicMapper<Arc, GALLIC_LEFT>());
+ fst->SetOutputSymbols(osyms.get());
+ } else {
+ sfst->SetOutputSymbols(fst->OutputSymbols());
+ GallicToNewSymbolsMapper<Arc, GALLIC_LEFT> mapper(sfst);
+ ArcMap(gfst, fst, &mapper);
+ fst->SetOutputSymbols(sfst->InputSymbols());
+ }
+ } else if (props & kWeighted) { // Weighted acceptor.
+ Push(fst, REWEIGHT_TO_INITIAL, delta);
+ ArcMap(fst, QuantizeMapper<Arc>(delta));
+ EncodeMapper<Arc> encoder(kEncodeLabels | kEncodeWeights, ENCODE);
+ Encode(fst, &encoder);
+ internal::AcceptorMinimize(fst, allow_acyclic_minimization);
+ Decode(fst, encoder);
+ } else { // Unweighted acceptor.
+ internal::AcceptorMinimize(fst, allow_acyclic_minimization);
+ }
+}
+
+} // namespace fst
+
+#endif // FST_LIB_MINIMIZE_H_
--- /dev/null
+// 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_LIB_MUTABLE_FST_H_
+#define FST_LIB_MUTABLE_FST_H_
+
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <istream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <fstream>
+
+#include <fst/expanded-fst.h>
+
+
+namespace fst {
+
+template <class Arc>
+struct MutableArcIteratorData;
+
+// Abstract interface for an expanded FST which also supports mutation
+// operations. To modify arcs, use MutableArcIterator.
+template <class A>
+class MutableFst : public ExpandedFst<A> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ virtual MutableFst<Arc> &operator=(const Fst<Arc> &fst) = 0;
+
+ MutableFst<Arc> &operator=(const MutableFst<Arc> &fst) {
+ return operator=(static_cast<const Fst<Arc> &>(fst));
+ }
+
+ // Sets the initial state.
+ virtual void SetStart(StateId) = 0;
+
+ // Sets a state's final weight.
+ virtual void SetFinal(StateId, Weight) = 0;
+
+ // Sets property bits w.r.t. mask.
+ virtual void SetProperties(uint64 props, uint64 mask) = 0;
+
+ // Adds a state and returns its ID.
+ virtual StateId AddState() = 0;
+
+ // Adds an arc to state.
+ virtual void AddArc(StateId, const Arc &arc) = 0;
+
+ // Deletes some states, preserving original StateId ordering.
+ virtual void DeleteStates(const std::vector<StateId> &) = 0;
+
+ // Delete all states.
+ virtual void DeleteStates() = 0;
+
+ // Delete some arcs at a given state.
+ virtual void DeleteArcs(StateId, size_t n) = 0;
+
+ // Delete all arcs at a given state.
+ virtual void DeleteArcs(StateId) = 0;
+
+ // Optional, best effort only.
+ virtual void ReserveStates(StateId n) {}
+
+ // Optional, best effort only.
+ virtual void ReserveArcs(StateId s, size_t n) {}
+
+ // Returns input label symbol table or nullptr if not specified.
+ const SymbolTable *InputSymbols() const override = 0;
+
+ // Returns output label symbol table or nullptr if not specified.
+ const SymbolTable *OutputSymbols() const override = 0;
+
+ // Returns input label symbol table or nullptr if not specified.
+ virtual SymbolTable *MutableInputSymbols() = 0;
+
+ // Returns output label symbol table or nullptr if not specified.
+ virtual SymbolTable *MutableOutputSymbols() = 0;
+
+ // Sets input label symbol table; pass nullptr to delete table.
+ virtual void SetInputSymbols(const SymbolTable *isyms) = 0;
+
+ // Sets output label symbol table; pass nullptr to delete table.
+ virtual void SetOutputSymbols(const SymbolTable *osyms) = 0;
+
+ // Gets a copy of this MutableFst. See Fst<>::Copy() for further doc.
+ MutableFst<A> *Copy(bool safe = false) const override = 0;
+
+ // Reads an MutableFst from an input stream, returning nullptr on error.
+ static MutableFst<Arc> *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<Arc>::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<MutableFst<Arc> *>(fst);
+ }
+
+ // Reads a MutableFst from a file; returns nullptr on error. An empty
+ // filename results in reading from standard input. If convert is true,
+ // convert to a mutable FST subclass (given by convert_type) in the case
+ // that the input FST is non-mutable.
+ static MutableFst<Arc> *Read(const string &filename, bool convert = false,
+ const string &convert_type = "vector") {
+ if (convert == false) {
+ if (!filename.empty()) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm) {
+ LOG(ERROR) << "MutableFst::Read: Can't open file: " << filename;
+ return nullptr;
+ }
+ return Read(strm, FstReadOptions(filename));
+ } else {
+ return Read(std::cin, FstReadOptions("standard input"));
+ }
+ } else { // Converts to 'convert_type' if not mutable.
+ std::unique_ptr<Fst<Arc>> ifst(Fst<Arc>::Read(filename));
+ if (!ifst) return nullptr;
+ if (ifst->Properties(kMutable, false)) {
+ return static_cast<MutableFst<Arc> *>(ifst.release());
+ } else {
+ std::unique_ptr<Fst<Arc>> 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<MutableFst<Arc> *>(ofst.release());
+ }
+ }
+ }
+
+ // For generic mutuble arc iterator construction; not normally called
+ // directly by users.
+ virtual void InitMutableArcIterator(StateId s,
+ MutableArcIteratorData<Arc> *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 Arc>
+class MutableArcIteratorBase : public ArcIteratorBase<Arc> {
+ public:
+ // Sets current arc.
+ virtual void SetValue(const Arc &) = 0;
+};
+
+template <class Arc>
+struct MutableArcIteratorData {
+ MutableArcIteratorBase<Arc> *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<StdFst> aiter(&fst, s);
+// !aiter.Done();
+// aiter.Next()) {
+// StdArc arc = aiter.Value();
+// arc.ilabel = 7;
+// aiter.SetValue(arc);
+// ...
+// }
+//
+// This version requires function calls.
+template <class FST>
+class MutableArcIterator {
+ public:
+ using Arc = typename FST::Arc;
+ using StateId = typename Arc::StateId;
+
+ MutableArcIterator(FST *fst, StateId s) {
+ fst->InitMutableArcIterator(s, &data_);
+ }
+
+ ~MutableArcIterator() { delete data_.base; }
+
+ bool Done() const { return data_.base->Done(); }
+
+ const Arc &Value() const { return data_.base->Value(); }
+
+ void Next() { data_.base->Next(); }
+
+ size_t Position() const { return data_.base->Position(); }
+
+ void Reset() { data_.base->Reset(); }
+
+ void Seek(size_t a) { data_.base->Seek(a); }
+
+ void SetValue(const Arc &arc) { data_.base->SetValue(arc); }
+
+ uint32 Flags() const { return data_.base->Flags(); }
+
+ void SetFlags(uint32 flags, uint32 mask) {
+ return data_.base->SetFlags(flags, mask);
+ }
+
+ private:
+ MutableArcIteratorData<Arc> data_;
+
+ MutableArcIterator(const MutableArcIterator &) = delete;
+ MutableArcIterator &operator=(const MutableArcIterator &) = delete;
+};
+
+namespace internal {
+
+// MutableFst<A> case: abstract methods.
+template <class Arc>
+inline typename Arc::Weight Final(const MutableFst<Arc> &fst,
+ typename Arc::StateId s) {
+ return fst.Final(s);
+}
+
+template <class Arc>
+inline ssize_t NumArcs(const MutableFst<Arc> &fst, typename Arc::StateId s) {
+ return fst.NumArcs(s);
+}
+
+template <class Arc>
+inline ssize_t NumInputEpsilons(const MutableFst<Arc> &fst,
+ typename Arc::StateId s) {
+ return fst.NumInputEpsilons(s);
+}
+
+template <class Arc>
+inline ssize_t NumOutputEpsilons(const MutableFst<Arc> &fst,
+ typename Arc::StateId s) {
+ return fst.NumOutputEpsilons(s);
+}
+
+} // namespace internal
+
+// A useful alias when using StdArc.
+using StdMutableFst = MutableFst<StdArc>;
+
+// This is a helper class template useful for attaching a MutableFst interface
+// to its implementation, handling reference counting and COW semantics.
+template <class Impl, class FST = MutableFst<typename Impl::Arc>>
+class ImplToMutableFst : public ImplToExpandedFst<Impl, FST> {
+ public:
+ using Arc = typename Impl::Arc;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using ImplToExpandedFst<Impl, FST>::operator=;
+
+ void SetStart(StateId s) override {
+ MutateCheck();
+ GetMutableImpl()->SetStart(s);
+ }
+
+ void SetFinal(StateId s, Weight weight) override {
+ MutateCheck();
+ GetMutableImpl()->SetFinal(s, std::move(weight));
+ }
+
+ void SetProperties(uint64 props, uint64 mask) override {
+ // Can skip mutate check if extrinsic properties don't change,
+ // since it is then safe to update all (shallow) copies
+ const auto exprops = kExtrinsicProperties & mask;
+ if (GetImpl()->Properties(exprops) != (props & exprops)) MutateCheck();
+ GetMutableImpl()->SetProperties(props, mask);
+ }
+
+ StateId AddState() override {
+ MutateCheck();
+ return GetMutableImpl()->AddState();
+ }
+
+ void AddArc(StateId s, const Arc &arc) override {
+ MutateCheck();
+ GetMutableImpl()->AddArc(s, arc);
+ }
+
+ void DeleteStates(const std::vector<StateId> &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<Impl>());
+ GetMutableImpl()->SetInputSymbols(isymbols);
+ GetMutableImpl()->SetOutputSymbols(osymbols);
+ } else {
+ GetMutableImpl()->DeleteStates();
+ }
+ }
+
+ void DeleteArcs(StateId s, size_t n) override {
+ MutateCheck();
+ GetMutableImpl()->DeleteArcs(s, n);
+ }
+
+ void DeleteArcs(StateId s) override {
+ MutateCheck();
+ GetMutableImpl()->DeleteArcs(s);
+ }
+
+ void ReserveStates(StateId s) override {
+ MutateCheck();
+ GetMutableImpl()->ReserveStates(s);
+ }
+
+ void ReserveArcs(StateId s, size_t n) override {
+ MutateCheck();
+ GetMutableImpl()->ReserveArcs(s, n);
+ }
+
+ const SymbolTable *InputSymbols() const override {
+ return GetImpl()->InputSymbols();
+ }
+
+ const SymbolTable *OutputSymbols() const override {
+ return GetImpl()->OutputSymbols();
+ }
+
+ SymbolTable *MutableInputSymbols() override {
+ MutateCheck();
+ return GetMutableImpl()->InputSymbols();
+ }
+
+ SymbolTable *MutableOutputSymbols() override {
+ MutateCheck();
+ return GetMutableImpl()->OutputSymbols();
+ }
+
+ void SetInputSymbols(const SymbolTable *isyms) override {
+ MutateCheck();
+ GetMutableImpl()->SetInputSymbols(isyms);
+ }
+
+ void SetOutputSymbols(const SymbolTable *osyms) override {
+ MutateCheck();
+ GetMutableImpl()->SetOutputSymbols(osyms);
+ }
+
+ protected:
+ using ImplToExpandedFst<Impl, FST>::GetImpl;
+ using ImplToExpandedFst<Impl, FST>::GetMutableImpl;
+ using ImplToExpandedFst<Impl, FST>::Unique;
+ using ImplToExpandedFst<Impl, FST>::SetImpl;
+ using ImplToExpandedFst<Impl, FST>::InputSymbols;
+
+ explicit ImplToMutableFst(std::shared_ptr<Impl> impl)
+ : ImplToExpandedFst<Impl, FST>(impl) {}
+
+ ImplToMutableFst(const ImplToMutableFst<Impl, FST> &fst, bool safe)
+ : ImplToExpandedFst<Impl, FST>(fst, safe) {}
+
+ void MutateCheck() {
+ if (!Unique()) SetImpl(std::make_shared<Impl>(*this));
+ }
+};
+
+} // namespace fst
+
+#endif // FST_LIB_MUTABLE_FST_H_
--- /dev/null
+// 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_LIB_PAIR_WEIGHT_H_
+#define FST_LIB_PAIR_WEIGHT_H_
+
+#include <climits>
+#include <stack>
+#include <string>
+#include <utility>
+
+#include <fst/weight.h>
+
+
+namespace fst {
+
+template <class W1, class W2>
+class PairWeight {
+ public:
+ using ReverseWeight =
+ PairWeight<typename W1::ReverseWeight, typename W2::ReverseWeight>;
+
+ PairWeight() {}
+
+ PairWeight(const PairWeight &weight)
+ : value1_(weight.value1_), value2_(weight.value2_) {}
+
+ PairWeight(W1 w1, W2 w2) : value1_(std::move(w1)), value2_(std::move(w2)) {}
+
+ static const PairWeight<W1, W2> &Zero() {
+ static const PairWeight zero(W1::Zero(), W2::Zero());
+ return zero;
+ }
+
+ static const PairWeight<W1, W2> &One() {
+ static const PairWeight one(W1::One(), W2::One());
+ return one;
+ }
+
+ static const PairWeight<W1, W2> &NoWeight() {
+ static const PairWeight no_weight(W1::NoWeight(), W2::NoWeight());
+ return no_weight;
+ }
+
+ std::istream &Read(std::istream &strm) {
+ value1_.Read(strm);
+ return value2_.Read(strm);
+ }
+
+ std::ostream &Write(std::ostream &strm) const {
+ value1_.Write(strm);
+ return value2_.Write(strm);
+ }
+
+ PairWeight<W1, W2> &operator=(const PairWeight<W1, W2> &weight) {
+ value1_ = weight.Value1();
+ value2_ = weight.Value2();
+ return *this;
+ }
+
+ bool Member() const { return value1_.Member() && value2_.Member(); }
+
+ size_t Hash() const {
+ const auto h1 = value1_.Hash();
+ const auto h2 = value2_.Hash();
+ static constexpr int lshift = 5;
+ static constexpr int rshift = CHAR_BIT * sizeof(size_t) - 5;
+ return h1 << lshift ^ h1 >> rshift ^ h2;
+ }
+
+ PairWeight<W1, W2> Quantize(float delta = kDelta) const {
+ return PairWeight<W1, W2>(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 <class W1, class W2>
+inline bool operator==(const PairWeight<W1, W2> &w1,
+ const PairWeight<W1, W2> &w2) {
+ return w1.Value1() == w2.Value1() && w1.Value2() == w2.Value2();
+}
+
+template <class W1, class W2>
+inline bool operator!=(const PairWeight<W1, W2> &w1,
+ const PairWeight<W1, W2> &w2) {
+ return w1.Value1() != w2.Value1() || w1.Value2() != w2.Value2();
+}
+
+template <class W1, class W2>
+inline bool ApproxEqual(const PairWeight<W1, W2> &w1,
+ const PairWeight<W1, W2> &w2, float delta = kDelta) {
+ return ApproxEqual(w1.Value1(), w2.Value1(), delta) &&
+ ApproxEqual(w1.Value2(), w2.Value2(), delta);
+}
+
+template <class W1, class W2>
+inline std::ostream &operator<<(std::ostream &strm,
+ const PairWeight<W1, W2> &weight) {
+ CompositeWeightWriter writer(strm);
+ writer.WriteBegin();
+ writer.WriteElement(weight.Value1());
+ writer.WriteElement(weight.Value2());
+ writer.WriteEnd();
+ return strm;
+}
+
+template <class W1, class W2>
+inline std::istream &operator>>(std::istream &strm,
+ PairWeight<W1, W2> &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 W1, class W2>
+class WeightGenerate<PairWeight<W1, W2>> {
+ public:
+ using Weight = PairWeight<W1, W2>;
+ using Generate1 = WeightGenerate<W1>;
+ using Generate2 = WeightGenerate<W2>;
+
+ explicit WeightGenerate(bool allow_zero = true)
+ : generate1_(allow_zero), generate2_(allow_zero) {}
+
+ Weight operator()() const { return Weight(generate1_(), generate2_()); }
+
+ private:
+ Generate1 generate1_;
+ Generate2 generate2_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_PAIR_WEIGHT_H_
--- /dev/null
+// 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_LIB_PARTITION_H_
+#define FST_LIB_PARTITION_H_
+
+#include <algorithm>
+#include <vector>
+
+
+#include <fst/queue.h>
+
+
+namespace fst {
+namespace internal {
+
+template <typename T>
+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 <typename T>
+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;
+ CHECK(old_class.size >= 0 && old_class.yes_size == 0);
+ // 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 {
+ CHECK(old_class.no_head == element_id);
+ 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 {
+ CHECK(this_class.no_head == element_id);
+ 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++;
+ CHECK(this_class.yes_size <= this_class.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 <class Queue>
+ 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<T>;
+
+ // 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.
+ CHECK(classes_[class_id].no_head < 0); // NOLINT
+ 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<Element> elements_;
+ // classes_[i] contains all info about the i'th class.
+ std::vector<Class> classes_;
+ // Set of visited classes to be used in split refine.
+ std::vector<T> 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 <typename T>
+class PartitionIterator {
+ public:
+ using Element = typename Partition<T>::Element;
+
+ PartitionIterator(const Partition<T> &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<T> &partition_;
+ T element_id_;
+ T class_id_;
+};
+
+} // namespace internal
+} // namespace fst
+
+#endif // FST_LIB_PARTITION_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Cartesian power weight semiring operation definitions.
+
+#ifndef FST_LIB_POWER_WEIGHT_H_
+#define FST_LIB_POWER_WEIGHT_H_
+
+#include <string>
+
+#include <fst/tuple-weight.h>
+#include <fst/weight.h>
+
+
+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 W, size_t n>
+class PowerWeight : public TupleWeight<W, n> {
+ public:
+ using ReverseWeight = PowerWeight<typename W::ReverseWeight, n>;
+
+ PowerWeight() {}
+
+ explicit PowerWeight(const TupleWeight<W, n> &weight)
+ : TupleWeight<W, n>(weight) {}
+
+ template <class Iterator>
+ PowerWeight(Iterator begin, Iterator end) : TupleWeight<W, n>(begin, end) {}
+
+ static const PowerWeight &Zero() {
+ static const PowerWeight zero(TupleWeight<W, n>::Zero());
+ return zero;
+ }
+
+ static const PowerWeight &One() {
+ static const PowerWeight one(TupleWeight<W, n>::One());
+ return one;
+ }
+
+ static const PowerWeight &NoWeight() {
+ static const PowerWeight no_weight(TupleWeight<W, n>::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static string type;
+ if (type.empty()) {
+ string power;
+ Int64ToStr(n, &power);
+ type = W::Type() + "_^" + power;
+ }
+ return type;
+ }
+
+ static constexpr uint64 Properties() {
+ return W::Properties() &
+ (kLeftSemiring | kRightSemiring | kCommutative | kIdempotent);
+ }
+
+ PowerWeight Quantize(float delta = kDelta) const {
+ return PowerWeight(TupleWeight<W, n>::Quantize(delta));
+ }
+
+ ReverseWeight Reverse() const {
+ return ReverseWeight(TupleWeight<W, n>::Reverse());
+ }
+};
+
+// Semiring plus operation.
+template <class W, size_t n>
+inline PowerWeight<W, n> Plus(const PowerWeight<W, n> &w1,
+ const PowerWeight<W, n> &w2) {
+ PowerWeight<W, n> result;
+ for (auto i = 0; i < n; ++i)
+ result.SetValue(i, Plus(w1.Value(i), w2.Value(i)));
+ return result;
+}
+
+// Semiring times operation.
+template <class W, size_t n>
+inline PowerWeight<W, n> Times(const PowerWeight<W, n> &w1,
+ const PowerWeight<W, n> &w2) {
+ PowerWeight<W, n> result;
+ for (auto i = 0; i < n; ++i)
+ result.SetValue(i, Times(w1.Value(i), w2.Value(i)));
+ return result;
+}
+
+// Semiring divide operation.
+template <class W, size_t n>
+inline PowerWeight<W, n> Divide(const PowerWeight<W, n> &w1,
+ const PowerWeight<W, n> &w2,
+ DivideType type = DIVIDE_ANY) {
+ PowerWeight<W, n> result;
+ for (auto i = 0; i < n; ++i) {
+ result.SetValue(i, Divide(w1.Value(i), w2.Value(i), type));
+ }
+ return result;
+}
+
+// Semimodule left scalar product.
+template <class W, size_t n>
+inline PowerWeight<W, n> Times(const W &scalar,
+ const PowerWeight<W, n> &weight) {
+ PowerWeight<W, n> result;
+ for (auto i = 0; i < n; ++i)
+ result.SetValue(i, Times(scalar, weight.Value(i)));
+ return result;
+}
+
+// Semimodule right scalar product.
+template <class W, size_t n>
+inline PowerWeight<W, n> Times(const PowerWeight<W, n> &weight,
+ const W &scalar) {
+ PowerWeight<W, n> result;
+ for (auto i = 0; i < n; ++i)
+ result.SetValue(i, Times(weight.Value(i), scalar));
+ return result;
+}
+
+// Semimodule dot product.
+template <class W, size_t n>
+inline W DotProduct(const PowerWeight<W, n> &w1, const PowerWeight<W, n> &w2) {
+ W result(W::Zero());
+ for (auto 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 W, size_t n>
+class WeightGenerate<PowerWeight<W, n>> {
+ public:
+ using Weight = PowerWeight<W, n>;
+ using Generate = WeightGenerate<W>;
+
+ explicit WeightGenerate(bool allow_zero = true) : generate_(allow_zero) {}
+
+ Weight operator()() const {
+ Weight result;
+ for (auto i = 0; i < n; ++i) result.SetValue(i, generate_());
+ return result;
+ }
+
+ private:
+ Generate generate_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_POWER_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Product weight set and associated semiring operation definitions.
+
+#ifndef FST_LIB_PRODUCT_WEIGHT_H_
+#define FST_LIB_PRODUCT_WEIGHT_H_
+
+#include <string>
+#include <utility>
+
+#include <fst/pair-weight.h>
+#include <fst/weight.h>
+
+
+namespace fst {
+
+// Product semiring: W1 * W2.
+template <class W1, class W2>
+class ProductWeight : public PairWeight<W1, W2> {
+ public:
+ using ReverseWeight =
+ ProductWeight<typename W1::ReverseWeight, typename W2::ReverseWeight>;
+
+ ProductWeight() {}
+
+ explicit ProductWeight(const PairWeight<W1, W2> &weight)
+ : PairWeight<W1, W2>(weight) {}
+
+ ProductWeight(W1 w1, W2 w2)
+ : PairWeight<W1, W2>(std::move(w1), std::move(w2)) {}
+
+ static const ProductWeight &Zero() {
+ static const ProductWeight zero(PairWeight<W1, W2>::Zero());
+ return zero;
+ }
+
+ static const ProductWeight &One() {
+ static const ProductWeight one(PairWeight<W1, W2>::One());
+ return one;
+ }
+
+ static const ProductWeight &NoWeight() {
+ static const ProductWeight no_weight(PairWeight<W1, W2>::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type = 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<W1, W2>::Quantize(delta));
+ }
+
+ ReverseWeight Reverse() const {
+ return ReverseWeight(PairWeight<W1, W2>::Reverse());
+ }
+};
+
+template <class W1, class W2>
+inline ProductWeight<W1, W2> Plus(const ProductWeight<W1, W2> &w1,
+ const ProductWeight<W1, W2> &w2) {
+ return ProductWeight<W1, W2>(Plus(w1.Value1(), w2.Value1()),
+ Plus(w1.Value2(), w2.Value2()));
+}
+
+template <class W1, class W2>
+inline ProductWeight<W1, W2> Times(const ProductWeight<W1, W2> &w1,
+ const ProductWeight<W1, W2> &w2) {
+ return ProductWeight<W1, W2>(Times(w1.Value1(), w2.Value1()),
+ Times(w1.Value2(), w2.Value2()));
+}
+
+template <class W1, class W2>
+inline ProductWeight<W1, W2> Divide(const ProductWeight<W1, W2> &w1,
+ const ProductWeight<W1, W2> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ return ProductWeight<W1, W2>(Divide(w1.Value1(), w2.Value1(), typ),
+ Divide(w1.Value2(), w2.Value2(), typ));
+}
+
+// This function object generates weights by calling the underlying generators
+// for the template weight types, like all other pair weight types. This is
+// intended primarily for testing.
+template <class W1, class W2>
+class WeightGenerate<ProductWeight<W1, W2>> :
+ public WeightGenerate<PairWeight<W1, W2>> {
+ public:
+ using Weight = ProductWeight<W1, W2>;
+ using Generate = WeightGenerate<PairWeight<W1, W2>>;
+
+ explicit WeightGenerate(bool allow_zero = true) : Generate(allow_zero) {}
+
+ Weight operator()() const { return Weight(Generate::operator()()); }
+};
+
+} // namespace fst
+
+#endif // FST_LIB_PRODUCT_WEIGHT_H_
--- /dev/null
+// 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_LIB_PROJECT_H_
+#define FST_LIB_PROJECT_H_
+
+#include <fst/arc-map.h>
+#include <fst/mutable-fst.h>
+
+
+namespace fst {
+
+// This specifies whether to project on input or output.
+enum ProjectType { PROJECT_INPUT = 1, PROJECT_OUTPUT = 2 };
+
+// Mapper to implement projection per arc.
+template <class A>
+class ProjectMapper {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+
+ explicit ProjectMapper(ProjectType project_type)
+ : project_type_(project_type) {}
+
+ ToArc operator()(const FromArc &arc) {
+ const auto label = project_type_ == PROJECT_INPUT ? arc.ilabel : arc.olabel;
+ return ToArc(label, label, arc.weight, arc.nextstate);
+ }
+
+ MapFinalAction FinalAction() const { return MAP_NO_SUPERFINAL; }
+
+ MapSymbolsAction InputSymbolsAction() const {
+ return project_type_ == PROJECT_INPUT ? MAP_COPY_SYMBOLS
+ : MAP_CLEAR_SYMBOLS;
+ }
+
+ MapSymbolsAction OutputSymbolsAction() const {
+ return project_type_ == PROJECT_OUTPUT ? MAP_COPY_SYMBOLS
+ : MAP_CLEAR_SYMBOLS;
+ }
+
+ uint64 Properties(uint64 props) {
+ return ProjectProperties(props, project_type_ == PROJECT_INPUT);
+ }
+
+ private:
+ 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. This version modifies its input.
+//
+// Complexity:
+//
+// Time: O(V + E)
+// Space: O(1)
+//
+// where V is the number of states and E is the number of arcs.
+template <class Arc>
+inline void Project(MutableFst<Arc> *fst, ProjectType project_type) {
+ ArcMap(fst, ProjectMapper<Arc>(project_type));
+ if (project_type == PROJECT_INPUT) fst->SetOutputSymbols(fst->InputSymbols());
+ if (project_type == PROJECT_OUTPUT) {
+ fst->SetInputSymbols(fst->OutputSymbols());
+ }
+}
+
+// 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 A>
+class ProjectFst : public ArcMapFst<A, A, ProjectMapper<A>> {
+ public:
+ using FromArc = A;
+ using ToArc = A;
+
+ using Impl = internal::ArcMapFstImpl<A, A, ProjectMapper<A>>;
+
+ ProjectFst(const Fst<A> &fst, ProjectType project_type)
+ : ArcMapFst<A, A, ProjectMapper<A>>(fst, ProjectMapper<A>(project_type)) {
+ if (project_type == PROJECT_INPUT) {
+ GetMutableImpl()->SetOutputSymbols(fst.InputSymbols());
+ }
+ if (project_type == PROJECT_OUTPUT) {
+ GetMutableImpl()->SetInputSymbols(fst.OutputSymbols());
+ }
+ }
+
+ // See Fst<>::Copy() for doc.
+ ProjectFst(const ProjectFst<A> &fst, bool safe = false)
+ : ArcMapFst<A, A, ProjectMapper<A>>(fst, safe) {}
+
+ // Gets a copy of this ProjectFst. See Fst<>::Copy() for further doc.
+ ProjectFst<A> *Copy(bool safe = false) const override {
+ return new ProjectFst(*this, safe);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetMutableImpl;
+};
+
+// Specialization for ProjectFst.
+template <class A>
+class StateIterator<ProjectFst<A>>
+ : public StateIterator<ArcMapFst<A, A, ProjectMapper<A>>> {
+ public:
+ explicit StateIterator(const ProjectFst<A> &fst)
+ : StateIterator<ArcMapFst<A, A, ProjectMapper<A>>>(fst) {}
+};
+
+// Specialization for ProjectFst.
+template <class A>
+class ArcIterator<ProjectFst<A>>
+ : public ArcIterator<ArcMapFst<A, A, ProjectMapper<A>>> {
+ public:
+ using StateId = typename A::StateId;
+
+ ArcIterator(const ProjectFst<A> &fst, StateId s)
+ : ArcIterator<ArcMapFst<A, A, ProjectMapper<A>>>(fst, s) {}
+};
+
+// Useful alias when using StdArc.
+using StdProjectFst = ProjectFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_PROJECT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// FST property bits.
+
+#ifndef FST_LIB_PROPERTIES_H_
+#define FST_LIB_PROPERTIES_H_
+
+#include <sys/types.h>
+#include <vector>
+
+#include <fst/compat.h>
+
+namespace fst {
+
+// The property bits here assert facts about an FST. If individual bits are
+// added, then the composite properties below, the property functions and
+// property names in properties.cc, and TestProperties() in test-properties.h
+// should be updated.
+
+// BINARY PROPERTIES
+//
+// For each property below, there is a single bit. If it is set, the property is
+// true. If it is not set, the property is false.
+
+// The Fst is an ExpandedFst.
+constexpr uint64 kExpanded = 0x0000000000000001ULL;
+
+// The Fst is a MutableFst.
+constexpr uint64 kMutable = 0x0000000000000002ULL;
+
+// An error was detected while constructing/using the FST.
+constexpr uint64 kError = 0x0000000000000004ULL;
+
+// TRINARY PROPERTIES
+//
+// For each of these properties below there is a pair of property bits, one
+// positive and one negative. If the positive bit is set, the property is true.
+// If the negative bit is set, the property is false. If neither is set, the
+// property has unknown value. Both should never be simultaneously set. The
+// individual positive and negative bit pairs should be adjacent with the
+// positive bit at an odd and lower position.
+
+// ilabel == olabel for each arc.
+constexpr uint64 kAcceptor = 0x0000000000010000ULL;
+// ilabel != olabel for some arc.
+constexpr uint64 kNotAcceptor = 0x0000000000020000ULL;
+
+// ilabels unique leaving each state.
+constexpr uint64 kIDeterministic = 0x0000000000040000ULL;
+// ilabels not unique leaving some state.
+constexpr uint64 kNonIDeterministic = 0x0000000000080000ULL;
+
+// olabels unique leaving each state.
+constexpr uint64 kODeterministic = 0x0000000000100000ULL;
+// olabels not unique leaving some state.
+constexpr uint64 kNonODeterministic = 0x0000000000200000ULL;
+
+// FST has input/output epsilons.
+constexpr uint64 kEpsilons = 0x0000000000400000ULL;
+// FST has no input/output epsilons.
+constexpr uint64 kNoEpsilons = 0x0000000000800000ULL;
+
+// FST has input epsilons.
+constexpr uint64 kIEpsilons = 0x0000000001000000ULL;
+// FST has no input epsilons.
+constexpr uint64 kNoIEpsilons = 0x0000000002000000ULL;
+
+// FST has output epsilons.
+constexpr uint64 kOEpsilons = 0x0000000004000000ULL;
+// FST has no output epsilons.
+constexpr uint64 kNoOEpsilons = 0x0000000008000000ULL;
+
+// ilabels sorted wrt < for each state.
+constexpr uint64 kILabelSorted = 0x0000000010000000ULL;
+// ilabels not sorted wrt < for some state.
+constexpr uint64 kNotILabelSorted = 0x0000000020000000ULL;
+
+// olabels sorted wrt < for each state.
+constexpr uint64 kOLabelSorted = 0x0000000040000000ULL;
+// olabels not sorted wrt < for some state.
+constexpr uint64 kNotOLabelSorted = 0x0000000080000000ULL;
+
+// Non-trivial arc or final weights.
+constexpr uint64 kWeighted = 0x0000000100000000ULL;
+// Only trivial arc and final weights.
+constexpr uint64 kUnweighted = 0x0000000200000000ULL;
+
+// FST has cycles.
+constexpr uint64 kCyclic = 0x0000000400000000ULL;
+// FST has no cycles.
+constexpr uint64 kAcyclic = 0x0000000800000000ULL;
+
+// FST has cycles containing the initial state.
+constexpr uint64 kInitialCyclic = 0x0000001000000000ULL;
+// FST has no cycles containing the initial state.
+constexpr uint64 kInitialAcyclic = 0x0000002000000000ULL;
+
+// FST is topologically sorted.
+constexpr uint64 kTopSorted = 0x0000004000000000ULL;
+// FST is not topologically sorted.
+constexpr uint64 kNotTopSorted = 0x0000008000000000ULL;
+
+// All states reachable from the initial state.
+constexpr uint64 kAccessible = 0x0000010000000000ULL;
+// Not all states reachable from the initial state.
+constexpr uint64 kNotAccessible = 0x0000020000000000ULL;
+
+// All states can reach a final state.
+constexpr uint64 kCoAccessible = 0x0000040000000000ULL;
+// Not all states can reach a final state.
+constexpr uint64 kNotCoAccessible = 0x0000080000000000ULL;
+
+// If NumStates() > 0, then state 0 is initial, state NumStates() - 1 is final,
+// there is a transition from each non-final state i to state i + 1, and there
+// are no other transitions.
+constexpr uint64 kString = 0x0000100000000000ULL;
+
+// Not a string FST.
+constexpr uint64 kNotString = 0x0000200000000000ULL;
+
+// FST has least one weighted cycle.
+constexpr uint64 kWeightedCycles = 0x0000400000000000ULL;
+
+// Only unweighted cycles.
+constexpr uint64 kUnweightedCycles = 0x0000800000000000ULL;
+
+// COMPOSITE PROPERTIES
+
+// Properties of an empty machine.
+constexpr uint64 kNullProperties =
+ kAcceptor | kIDeterministic | kODeterministic | kNoEpsilons | kNoIEpsilons |
+ kNoOEpsilons | kILabelSorted | kOLabelSorted | kUnweighted | kAcyclic |
+ kInitialAcyclic | kTopSorted | kAccessible | kCoAccessible | kString |
+ kUnweightedCycles;
+
+// Properties that are preserved when an FST is copied.
+constexpr uint64 kCopyProperties =
+ kError | kAcceptor | kNotAcceptor | kIDeterministic | kNonIDeterministic |
+ kODeterministic | kNonODeterministic | kEpsilons | kNoEpsilons |
+ kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons | kILabelSorted |
+ kNotILabelSorted | kOLabelSorted | kNotOLabelSorted | kWeighted |
+ kUnweighted | kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic |
+ kTopSorted | kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible |
+ kNotCoAccessible | kString | kNotString | kWeightedCycles |
+ kUnweightedCycles;
+
+// Properties that are intrinsic to the FST.
+constexpr uint64 kIntrinsicProperties =
+ kExpanded | kMutable | kAcceptor | kNotAcceptor | kIDeterministic |
+ kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons |
+ kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted |
+ kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic |
+ kInitialAcyclic | kTopSorted | kNotTopSorted | kAccessible |
+ kNotAccessible | kCoAccessible | kNotCoAccessible | kString | kNotString |
+ kWeightedCycles | kUnweightedCycles;
+
+// Properties that are (potentially) extrinsic to the FST.
+constexpr uint64 kExtrinsicProperties = kError;
+
+// Properties that are preserved when an FST start state is set.
+constexpr uint64 kSetStartProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic |
+ kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons |
+ kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted |
+ kWeighted | kUnweighted | kCyclic | kAcyclic | kTopSorted | kNotTopSorted |
+ kCoAccessible | kNotCoAccessible | kWeightedCycles | kUnweightedCycles;
+
+// Properties that are preserved when an FST final weight is set.
+constexpr uint64 kSetFinalProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic |
+ kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons |
+ kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted |
+ kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | kTopSorted |
+ kNotTopSorted | kAccessible | kNotAccessible | kWeightedCycles |
+ kUnweightedCycles;
+
+// Properties that are preserved when an FST state is added.
+constexpr uint64 kAddStateProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic |
+ kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons |
+ kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted |
+ kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic |
+ kInitialAcyclic | kTopSorted | kNotTopSorted | kNotAccessible |
+ kNotCoAccessible | kNotString | kWeightedCycles | kUnweightedCycles;
+
+// Properties that are preserved when an FST arc is added.
+constexpr uint64 kAddArcProperties =
+ kExpanded | kMutable | kError | kNotAcceptor | kNonIDeterministic |
+ kNonODeterministic | kEpsilons | kIEpsilons | kOEpsilons |
+ kNotILabelSorted | kNotOLabelSorted | kWeighted | kCyclic | kInitialCyclic |
+ kNotTopSorted | kAccessible | kCoAccessible | kWeightedCycles;
+
+// Properties that are preserved when an FST arc is set.
+constexpr uint64 kSetArcProperties = kExpanded | kMutable | kError;
+
+// Properties that are preserved when FST states are deleted.
+constexpr uint64 kDeleteStatesProperties =
+ kExpanded | kMutable | kError | kAcceptor | kIDeterministic |
+ kODeterministic | kNoEpsilons | kNoIEpsilons | kNoOEpsilons |
+ kILabelSorted | kOLabelSorted | kUnweighted | kAcyclic | kInitialAcyclic |
+ kTopSorted | kUnweightedCycles;
+
+// Properties that are preserved when FST arcs are deleted.
+constexpr uint64 kDeleteArcsProperties =
+ kExpanded | kMutable | kError | kAcceptor | kIDeterministic |
+ kODeterministic | kNoEpsilons | kNoIEpsilons | kNoOEpsilons |
+ kILabelSorted | kOLabelSorted | kUnweighted | kAcyclic | kInitialAcyclic |
+ kTopSorted | kNotAccessible | kNotCoAccessible | kUnweightedCycles;
+
+// Properties that are preserved when an FST's states are reordered.
+constexpr uint64 kStateSortProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic |
+ kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons |
+ kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted |
+ kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic |
+ kInitialAcyclic | kAccessible | kNotAccessible | kCoAccessible |
+ kNotCoAccessible | kWeightedCycles | kUnweightedCycles;
+
+// Properties that are preserved when an FST's arcs are reordered.
+constexpr uint64 kArcSortProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic |
+ kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons |
+ kWeighted | kUnweighted | kCyclic | kAcyclic | kInitialCyclic |
+ kInitialAcyclic | kTopSorted | kNotTopSorted | kAccessible |
+ kNotAccessible | kCoAccessible | kNotCoAccessible | kString | kNotString |
+ kWeightedCycles | kUnweightedCycles;
+
+// Properties that are preserved when an FST's input labels are changed.
+constexpr uint64 kILabelInvariantProperties =
+ kExpanded | kMutable | kError | kODeterministic | kNonODeterministic |
+ kOEpsilons | kNoOEpsilons | kOLabelSorted | kNotOLabelSorted | kWeighted |
+ kUnweighted | kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic |
+ kTopSorted | kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible |
+ kNotCoAccessible | kString | kNotString | kWeightedCycles |
+ kUnweightedCycles;
+
+// Properties that are preserved when an FST's output labels are changed.
+constexpr uint64 kOLabelInvariantProperties =
+ kExpanded | kMutable | kError | kIDeterministic | kNonIDeterministic |
+ kIEpsilons | kNoIEpsilons | kILabelSorted | kNotILabelSorted | kWeighted |
+ kUnweighted | kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic |
+ kTopSorted | kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible |
+ kNotCoAccessible | kString | kNotString | kWeightedCycles |
+ kUnweightedCycles;
+
+// Properties that are preserved when an FST's weights are changed. This
+// assumes that the set of states that are non-final is not changed.
+constexpr uint64 kWeightInvariantProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic |
+ kNonIDeterministic | kODeterministic | kNonODeterministic | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons | kNoOEpsilons |
+ kILabelSorted | kNotILabelSorted | kOLabelSorted | kNotOLabelSorted |
+ kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | kTopSorted |
+ kNotTopSorted | kAccessible | kNotAccessible | kCoAccessible |
+ kNotCoAccessible | kString | kNotString;
+
+// Properties that are preserved when a superfinal state is added and an FST's
+// final weights are directed to it via new transitions.
+constexpr uint64 kAddSuperFinalProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor |
+ kNonIDeterministic | kNonODeterministic | kEpsilons | kIEpsilons |
+ kOEpsilons | kNotILabelSorted | kNotOLabelSorted | kWeighted | kUnweighted |
+ kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic | kNotTopSorted |
+ kNotAccessible | kCoAccessible | kNotCoAccessible | kNotString |
+ kWeightedCycles | kUnweightedCycles;
+
+// Properties that are preserved when a superfinal state is removed and the
+// epsilon transitions directed to it are made final weights.
+constexpr uint64 kRmSuperFinalProperties =
+ kExpanded | kMutable | kError | kAcceptor | kNotAcceptor | kIDeterministic |
+ kODeterministic | kNoEpsilons | kNoIEpsilons | kNoOEpsilons |
+ kILabelSorted | kOLabelSorted | kWeighted | kUnweighted | kCyclic |
+ kAcyclic | kInitialCyclic | kInitialAcyclic | kTopSorted | kAccessible |
+ kCoAccessible | kNotCoAccessible | kString | kWeightedCycles |
+ kUnweightedCycles;
+
+// All binary properties.
+constexpr uint64 kBinaryProperties = 0x0000000000000007ULL;
+
+// All trinary properties.
+constexpr uint64 kTrinaryProperties = 0x0000ffffffff0000ULL;
+
+// COMPUTED PROPERTIES
+
+// 1st bit of trinary properties.
+constexpr uint64 kPosTrinaryProperties = kTrinaryProperties &
+ 0x5555555555555555ULL;
+
+// 2nd bit of trinary properties.
+constexpr uint64 kNegTrinaryProperties = kTrinaryProperties &
+ 0xaaaaaaaaaaaaaaaaULL;
+
+// All properties.
+constexpr uint64 kFstProperties = kBinaryProperties | kTrinaryProperties;
+
+// PROPERTY FUNCTIONS and STRING NAMES (defined in properties.cc).
+
+// Below are functions for getting property bit vectors when executing
+// mutation operations.
+inline uint64 SetStartProperties(uint64 inprops);
+
+template <typename Weight>
+uint64 SetFinalProperties(uint64 inprops, Weight old_weight, Weight new_weight);
+
+inline uint64 AddStateProperties(uint64 inprops);
+
+template <typename A>
+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<uint64> &inprops, ssize_t root,
+ bool epsilon_on_call, bool epsilon_on_return,
+ bool out_epsilon_on_call, bool out_epsilon_on_return,
+ bool replace_transducer, bool no_empty_fst,
+ bool all_ilabel_sorted, bool all_olabel_sorted,
+ bool all_negative_or_dense);
+
+uint64 ReverseProperties(uint64 inprops, bool has_superinitial);
+
+uint64 ReweightProperties(uint64 inprops);
+
+uint64 RmEpsilonProperties(uint64 inprops, bool delayed = false);
+
+uint64 ShortestPathProperties(uint64 props, bool tree = false);
+
+uint64 SynchronizeProperties(uint64 inprops);
+
+uint64 UnionProperties(uint64 inprops1, uint64 inprops2, bool delayed = false);
+
+// Definitions of inlined functions.
+
+uint64 SetStartProperties(uint64 inprops) {
+ auto outprops = inprops & kSetStartProperties;
+ if (inprops & kAcyclic) {
+ outprops |= kInitialAcyclic;
+ }
+ return outprops;
+}
+
+uint64 AddStateProperties(uint64 inprops) {
+ return inprops & kAddStateProperties;
+}
+
+uint64 DeleteStatesProperties(uint64 inprops) {
+ return inprops & kDeleteStatesProperties;
+}
+
+uint64 DeleteAllStatesProperties(uint64 inprops, uint64 staticprops) {
+ const auto outprops = inprops & kError;
+ return outprops | kNullProperties | staticprops;
+}
+
+uint64 DeleteArcsProperties(uint64 inprops) {
+ return inprops & kDeleteArcsProperties;
+}
+
+// Definitions of template functions.
+
+template <typename Weight>
+uint64 SetFinalProperties(uint64 inprops, Weight old_weight,
+ 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 <typename Arc>
+uint64 AddArcProperties(uint64 inprops, typename Arc::StateId s,
+ const Arc &arc, const Arc *prev_arc) {
+ using Weight = typename Arc::Weight;
+ auto outprops = inprops;
+ if (arc.ilabel != arc.olabel) {
+ outprops |= kNotAcceptor;
+ outprops &= ~kAcceptor;
+ }
+ if (arc.ilabel == 0) {
+ outprops |= kIEpsilons;
+ outprops &= ~kNoIEpsilons;
+ if (arc.olabel == 0) {
+ outprops |= kEpsilons;
+ outprops &= ~kNoEpsilons;
+ }
+ }
+ if (arc.olabel == 0) {
+ outprops |= kOEpsilons;
+ outprops &= ~kNoOEpsilons;
+ }
+ if (prev_arc) {
+ if (prev_arc->ilabel > arc.ilabel) {
+ outprops |= kNotILabelSorted;
+ outprops &= ~kILabelSorted;
+ }
+ if (prev_arc->olabel > arc.olabel) {
+ outprops |= kNotOLabelSorted;
+ outprops &= ~kOLabelSorted;
+ }
+ }
+ if (arc.weight != Weight::Zero() && arc.weight != Weight::One()) {
+ outprops |= kWeighted;
+ outprops &= ~kUnweighted;
+ }
+ if (arc.nextstate <= s) {
+ outprops |= kNotTopSorted;
+ outprops &= ~kTopSorted;
+ }
+ outprops &= kAddArcProperties | kAcceptor | kNoEpsilons | kNoIEpsilons |
+ kNoOEpsilons | kILabelSorted | kOLabelSorted | kUnweighted |
+ kTopSorted;
+ if (outprops & kTopSorted) {
+ outprops |= kAcyclic | kInitialAcyclic;
+ }
+ return outprops;
+}
+
+extern const char *PropertyNames[];
+
+} // namespace fst
+
+#endif // FST_LIB_PROPERTIES_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions implementing pruning.
+
+#ifndef FST_LIB_PRUNE_H_
+#define FST_LIB_PRUNE_H_
+
+#include <utility>
+#include <vector>
+
+#include <fst/arcfilter.h>
+#include <fst/heap.h>
+#include <fst/shortest-distance.h>
+
+
+namespace fst {
+namespace internal {
+
+template <class StateId, class Weight>
+class PruneCompare {
+ public:
+ PruneCompare(const std::vector<Weight> &idistance,
+ const std::vector<Weight> &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<Weight> &idistance_;
+ const std::vector<Weight> &fdistance_;
+ NaturalLess<Weight> less_;
+};
+
+} // namespace internal
+
+template <class Arc, class ArcFilter>
+struct PruneOptions {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ PruneOptions(const Weight &weight_threshold, StateId state_threshold,
+ ArcFilter filter, std::vector<Weight> *distance = nullptr,
+ float delta = kDelta)
+ : weight_threshold(std::move(weight_threshold)),
+ state_threshold(state_threshold),
+ filter(std::move(filter)),
+ distance(distance),
+ delta(delta) {}
+
+ // 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<Weight> *distance;
+ // Determines the degree of convergence required when computing shortest
+ // distances.
+ float delta;
+};
+
+// 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
+// be commutative and have the path property. The weight of any cycle needs to
+// be bounded; i.e.,
+//
+// Plus(weight, Weight::One()) == Weight::One()
+template <class Arc, class ArcFilter>
+void Prune(MutableFst<Arc> *fst, const PruneOptions<Arc, ArcFilter> &opts) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using StateHeap = Heap<StateId, internal::PruneCompare<StateId, Weight>>;
+ // TODO(kbg): Make this a compile-time static_assert once:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this operation for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ if ((Weight::Properties() & (kPath | kCommutative)) !=
+ (kPath | kCommutative)) {
+ FSTERROR() << "Prune: Weight needs to have the path property and"
+ << " be commutative: " << Weight::Type();
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ auto ns = fst->NumStates();
+ if (ns < 1) return;
+ std::vector<Weight> idistance(ns, Weight::Zero());
+ std::vector<Weight> 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<StateId, Weight> compare(idistance, *fdistance);
+ StateHeap heap(compare);
+ std::vector<bool> visited(ns, false);
+ std::vector<size_t> enqueued(ns, StateHeap::kNoKey);
+ std::vector<StateId> dead;
+ dead.push_back(fst->AddState());
+ NaturalLess<Weight> less;
+ const auto limit = Times((*fdistance)[fst->Start()], opts.weight_threshold);
+ StateId num_visited = 0;
+ auto s = fst->Start();
+ 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<MutableFst<Arc>> 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);
+}
+
+// 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 be commutative and
+// have the path property. The weight of any cycle needs to be bounded; i.e.,
+//
+// Plus(weight, Weight::One()) == Weight::One()
+template <class Arc>
+void Prune(MutableFst<Arc> *fst, typename Arc::Weight weight_threshold,
+ typename Arc::StateId state_threshold = kNoStateId,
+ double delta = kDelta) {
+ const PruneOptions<Arc, AnyArcFilter<Arc>> opts(
+ weight_threshold, state_threshold, AnyArcFilter<Arc>(), 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 must be commutative and have the path property.
+// The weight of any cycle needs to be bounded; i.e.,
+//
+// Plus(weight, Weight::One()) == Weight::One()
+template <class Arc, class ArcFilter>
+void Prune(const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ const PruneOptions<Arc, ArcFilter> &opts) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using StateHeap = Heap<StateId, internal::PruneCompare<StateId, Weight>>;
+ // TODO(kbg): Make this a compile-time static_assert once:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this operation for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ if ((Weight::Properties() & (kPath | kCommutative)) !=
+ (kPath | kCommutative)) {
+ FSTERROR() << "Prune: Weight needs to have the path property and"
+ << " be commutative: " << Weight::Type();
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ofst->DeleteStates();
+ ofst->SetInputSymbols(ifst.InputSymbols());
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ if (ifst.Start() == kNoStateId) return;
+ NaturalLess<Weight> less;
+ if (less(opts.weight_threshold, Weight::One()) ||
+ (opts.state_threshold == 0)) {
+ return;
+ }
+ std::vector<Weight> idistance;
+ std::vector<Weight> 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<StateId, Weight> compare(idistance, *fdistance);
+ StateHeap heap(compare);
+ std::vector<StateId> copy;
+ std::vector<size_t> enqueued;
+ std::vector<bool> visited;
+ auto s = ifst.Start();
+ const auto limit = Times(s < fdistance->size() ?
+ (*fdistance)[s] : Weight::Zero(),
+ 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<Fst<Arc>> 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);
+ }
+ }
+ }
+}
+
+// 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 be commutative and have the
+// path property. The weight of any cycle needs to be bounded; i.e.,
+//
+// Plus(weight, Weight::One()) = Weight::One();
+template <class Arc>
+void Prune(const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ typename Arc::Weight weight_threshold,
+ typename Arc::StateId state_threshold = kNoStateId,
+ float delta = kDelta) {
+ const PruneOptions<Arc, AnyArcFilter<Arc>> opts(
+ weight_threshold, state_threshold, AnyArcFilter<Arc>(), nullptr, delta);
+ Prune(ifst, ofst, opts);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_PRUNE_H_
--- /dev/null
+// 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_LIB_PUSH_H_
+#define FST_LIB_PUSH_H_
+
+#include <vector>
+
+#include <fst/arc-map.h>
+#include <fst/factor-weight.h>
+#include <fst/fst.h>
+#include <fst/reweight.h>
+#include <fst/shortest-distance.h>
+
+
+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 <class Arc>
+typename Arc::Weight ComputeTotalWeight(
+ const Fst<Arc> &fst, const std::vector<typename Arc::Weight> &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 <class Arc>
+void RemoveWeight(MutableFst<Arc> *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<MutableFst<Arc>> 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<MutableFst<Arc>> aiter(fst, start); !aiter.Done();
+ aiter.Next()) {
+ auto arc = aiter.Value();
+ arc.weight = Divide(arc.weight, weight, DIVIDE_LEFT);
+ aiter.SetValue(arc);
+ }
+ fst->SetFinal(start, Divide(fst->Final(start), weight, DIVIDE_LEFT));
+ }
+}
+
+// Pushes the weights in FST in the direction defined by TYPE. If
+// pushing towards the initial state, the sum of the weight of the
+// outgoing transitions and final weight at a non-initial state is
+// equal to One() in the resulting machine. If pushing towards the
+// final state, the same property holds on the reverse machine.
+//
+// Weight needs to be left distributive when pushing towards the
+// initial state and right distributive when pushing towards the final
+// states.
+template <class Arc>
+void Push(MutableFst<Arc> *fst, ReweightType type, float delta = kDelta,
+ bool remove_total_weight = false) {
+ using Weight = typename Arc::Weight;
+ std::vector<Weight> distance;
+ ShortestDistance(*fst, &distance, type == REWEIGHT_TO_INITIAL, delta);
+ auto total_weight = Weight::One();
+ if (remove_total_weight) {
+ total_weight =
+ ComputeTotalWeight(*fst, distance, type == REWEIGHT_TO_INITIAL);
+ }
+ Reweight(fst, distance, type);
+ if (remove_total_weight) {
+ RemoveWeight(fst, total_weight, type == REWEIGHT_TO_FINAL);
+ }
+}
+
+constexpr uint32 kPushWeights = 0x0001;
+constexpr uint32 kPushLabels = 0x0002;
+constexpr uint32 kPushRemoveTotalWeight = 0x0004;
+constexpr uint32 kPushRemoveCommonAffix = 0x0008;
+
+// Pushes the weights and/or labels of the input FST into the output
+// mutable FST by pushing weights and/or labels (as determined by the
+// ptype argument) towards the initial state or final states (as
+// determined by the rtype template parameter). The weight type must
+// be left distributive when pushing weights towards the initial state, and
+// right distribution when pushing weights towards the final states.
+template <class Arc, ReweightType rtype>
+void Push(const Fst<Arc> &ifst, MutableFst<Arc> *ofst, uint32 ptype,
+ float delta = kDelta) {
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+ if ((ptype & (kPushWeights | kPushLabels)) == kPushWeights) {
+ *ofst = ifst;
+ Push(ofst, rtype, delta, ptype & kPushRemoveTotalWeight);
+ } else if (ptype & kPushLabels) {
+ const auto gtype =
+ rtype == REWEIGHT_TO_INITIAL ? GALLIC_LEFT : GALLIC_RIGHT;
+ using GallicWeight = typename GallicArc<Arc, gtype>::Weight;
+ std::vector<GallicWeight> gdistance;
+ VectorFst<GallicArc<Arc, gtype>> gfst;
+ ArcMap(ifst, &gfst, ToGallicMapper<Arc, gtype>());
+ if (ptype & kPushWeights) {
+ ShortestDistance(gfst, &gdistance, rtype == REWEIGHT_TO_INITIAL, delta);
+ } else {
+ ArcMapFst<Arc, Arc, RmWeightMapper<Arc>> uwfst(ifst,
+ RmWeightMapper<Arc>());
+ ArcMapFst<Arc, GallicArc<Arc, gtype>, ToGallicMapper<Arc, gtype>> guwfst(
+ uwfst, ToGallicMapper<Arc, gtype>());
+ 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<Label, GALLIC_STRING_TYPE(gtype)>::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<GallicArc<Arc, gtype>, GallicFactor<Label, Weight, gtype>>
+ fwfst(gfst);
+ ArcMap(fwfst, ofst, FromGallicMapper<Arc, gtype>());
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ } else {
+ LOG(WARNING) << "Push: pushing type is set to 0, so not pushing";
+ *ofst = ifst;
+ }
+}
+
+} // namespace fst
+
+#endif // FST_LIB_PUSH_H_
--- /dev/null
+// 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_LIB_QUEUE_H_
+#define FST_LIB_QUEUE_H_
+
+#include <deque>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include <fst/arcfilter.h>
+#include <fst/connect.h>
+#include <fst/heap.h>
+#include <fst/topsort.h>
+
+
+namespace fst {
+
+// The Queue interface is:
+//
+// template <class S>
+// 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 S>
+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 S>
+class TrivialQueue final : public QueueBase<S> {
+ public:
+ using StateId = S;
+
+ TrivialQueue() : QueueBase<StateId>(TRIVIAL_QUEUE), front_(kNoStateId) {}
+
+ StateId Head() const override { return front_; }
+
+ void Enqueue(StateId s) override { front_ = s; }
+
+ void Dequeue() override { front_ = kNoStateId; }
+
+ void Update(StateId) override {}
+
+ bool Empty() const override { return front_ == kNoStateId; }
+
+ void Clear() override { front_ = kNoStateId; }
+
+ private:
+ StateId front_;
+};
+
+// First-in, first-out queue discipline.
+//
+// This is not a final class.
+template <class S>
+class FifoQueue : public QueueBase<S>, public std::deque<S> {
+ public:
+ using StateId = S;
+
+ using std::deque<S>::back;
+ using std::deque<S>::push_front;
+ using std::deque<S>::pop_back;
+ using std::deque<S>::empty;
+ using std::deque<S>::clear;
+
+ FifoQueue() : QueueBase<StateId>(FIFO_QUEUE) {}
+
+ StateId Head() const override { return back(); }
+
+ void Enqueue(StateId s) override { push_front(s); }
+
+ void Dequeue() override { pop_back(); }
+
+ void Update(StateId) override {}
+
+ bool Empty() const override { return empty(); }
+
+ void Clear() override { clear(); }
+};
+
+// Last-in, first-out queue discipline.
+template <class S>
+class LifoQueue final : public QueueBase<S>, public std::deque<S> {
+ public:
+ using StateId = S;
+
+ using std::deque<S>::front;
+ using std::deque<S>::push_front;
+ using std::deque<S>::pop_front;
+ using std::deque<S>::empty;
+ using std::deque<S>::clear;
+
+ LifoQueue() : QueueBase<StateId>(LIFO_QUEUE) {}
+
+ StateId Head() const override { return front(); }
+
+ void Enqueue(StateId s) override { push_front(s); }
+
+ void Dequeue() override { pop_front(); }
+
+ void Update(StateId) override {}
+
+ bool Empty() const override { return empty(); }
+
+ void Clear() override { clear(); }
+};
+
+// 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 <typename S, typename Compare, bool update = true>
+class ShortestFirstQueue : public QueueBase<S> {
+ public:
+ using StateId = S;
+
+ static constexpr StateId kNoKey = -1;
+
+ explicit ShortestFirstQueue(Compare comp)
+ : QueueBase<StateId>(SHORTEST_FIRST_QUEUE), heap_(comp) {}
+
+ 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(kNoKey);
+ key_[s] = heap_.Insert(s);
+ } else {
+ heap_.Insert(s);
+ }
+ }
+
+ void Dequeue() override {
+ if (update) {
+ key_[heap_.Pop()] = kNoKey;
+ } else {
+ heap_.Pop();
+ }
+ }
+
+ void Update(StateId s) override {
+ if (!update) return;
+ if (s >= key_.size() || key_[s] == kNoKey) {
+ Enqueue(s);
+ } else {
+ heap_.Update(key_[s], s);
+ }
+ }
+
+ bool Empty() const override { return heap_.Empty(); }
+
+ void Clear() override {
+ heap_.Clear();
+ if (update) key_.clear();
+ }
+
+ private:
+ Heap<StateId, Compare> heap_;
+ std::vector<ssize_t> key_;
+};
+
+template <typename StateId, typename Compare, bool update>
+constexpr StateId ShortestFirstQueue<StateId, Compare, update>::kNoKey;
+
+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 <typename StateId, typename Less>
+class StateWeightCompare {
+ public:
+ using Weight = typename Less::Weight;
+
+ StateWeightCompare(const std::vector<Weight> &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<Weight> &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 <typename S, typename Weight>
+class NaturalShortestFirstQueue final
+ : public ShortestFirstQueue<
+ S, internal::StateWeightCompare<S, NaturalLess<Weight>>> {
+ public:
+ using StateId = S;
+ using Compare = internal::StateWeightCompare<StateId, NaturalLess<Weight>>;
+
+ explicit NaturalShortestFirstQueue(const std::vector<Weight> &distance)
+ : ShortestFirstQueue<StateId, Compare>(Compare(distance, less_)) {}
+
+ private:
+ // This is non-static because the constructor for non-idempotent weights will
+ // result in a an error.
+ const NaturalLess<Weight> less_{};
+};
+
+// Topological-order queue discipline, templated on the StateId. States are
+// ordered in the queue topologically. The FST must be acyclic.
+template <class S>
+class TopOrderQueue final : public QueueBase<S> {
+ 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 <class Arc, class ArcFilter>
+ TopOrderQueue(const Fst<Arc> &fst, ArcFilter filter)
+ : QueueBase<StateId>(TOP_ORDER_QUEUE),
+ front_(0),
+ back_(kNoStateId),
+ order_(0),
+ state_(0) {
+ bool acyclic;
+ TopOrderVisitor<Arc> top_order_visitor(&order_, &acyclic);
+ DfsVisit(fst, &top_order_visitor, filter);
+ if (!acyclic) {
+ FSTERROR() << "TopOrderQueue: FST is not acyclic";
+ QueueBase<S>::SetError(true);
+ }
+ state_.resize(order_.size(), kNoStateId);
+ }
+
+ // This constructor is passed the pre-computed topological order.
+ explicit TopOrderQueue(const std::vector<StateId> &order)
+ : QueueBase<StateId>(TOP_ORDER_QUEUE),
+ front_(0),
+ back_(kNoStateId),
+ order_(order),
+ state_(order.size(), kNoStateId) {}
+
+ StateId Head() const override { return state_[front_]; }
+
+ void Enqueue(StateId s) override {
+ 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() override {
+ state_[front_] = kNoStateId;
+ while ((front_ <= back_) && (state_[front_] == kNoStateId)) ++front_;
+ }
+
+ void Update(StateId) override {}
+
+ bool Empty() const override { return front_ > back_; }
+
+ void Clear() override {
+ for (StateId s = front_; s <= back_; ++s) state_[s] = kNoStateId;
+ back_ = kNoStateId;
+ front_ = 0;
+ }
+
+ private:
+ StateId front_;
+ StateId back_;
+ std::vector<StateId> order_;
+ std::vector<StateId> state_;
+};
+
+// State order queue discipline, templated on the StateId. States are ordered in
+// the queue by state ID.
+template <class S>
+class StateOrderQueue final : public QueueBase<S> {
+ public:
+ using StateId = S;
+
+ StateOrderQueue()
+ : QueueBase<StateId>(STATE_ORDER_QUEUE), front_(0), back_(kNoStateId) {}
+
+ StateId Head() const override { return front_; }
+
+ void Enqueue(StateId s) override {
+ 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() override {
+ enqueued_[front_] = false;
+ while ((front_ <= back_) && (enqueued_[front_] == false)) ++front_;
+ }
+
+ void Update(StateId) override {}
+
+ bool Empty() const override { return front_ > back_; }
+
+ void Clear() override {
+ for (StateId i = front_; i <= back_; ++i) enqueued_[i] = false;
+ front_ = 0;
+ back_ = kNoStateId;
+ }
+
+ private:
+ StateId front_;
+ StateId back_;
+ std::vector<bool> 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 S, class Queue>
+class SccQueue final : public QueueBase<S> {
+ 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<StateId> &scc,
+ std::vector<std::unique_ptr<Queue>> *queue)
+ : QueueBase<StateId>(SCC_QUEUE),
+ queue_(queue),
+ scc_(scc),
+ front_(0),
+ back_(kNoStateId) {}
+
+ StateId Head() const override {
+ 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) override {
+ 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() override {
+ if ((*queue_)[front_]) {
+ (*queue_)[front_]->Dequeue();
+ } else if (front_ < trivial_queue_.size()) {
+ trivial_queue_[front_] = kNoStateId;
+ }
+ }
+
+ void Update(StateId s) override {
+ if ((*queue_)[scc_[s]]) (*queue_)[scc_[s]]->Update(s);
+ }
+
+ bool Empty() const override {
+ // Queue 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() override {
+ 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<std::unique_ptr<Queue>> *queue_;
+ const std::vector<StateId> &scc_;
+ mutable StateId front_;
+ StateId back_;
+ std::vector<StateId> trivial_queue_;
+};
+
+// Automatic queue discipline. It selects a queue discipline for a given FST
+// based on its properties.
+template <class S>
+class AutoQueue final : public QueueBase<S> {
+ 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 <class Arc, class ArcFilter>
+ AutoQueue(const Fst<Arc> &fst,
+ const std::vector<typename Arc::Weight> *distance, ArcFilter filter)
+ : QueueBase<StateId>(AUTO_QUEUE) {
+ using Weight = typename Arc::Weight;
+ using Compare = internal::StateWeightCompare<StateId, NaturalLess<Weight>>;
+ // First checks if the FST is known to have these properties.
+ const auto props =
+ fst.Properties(kAcyclic | kCyclic | kTopSorted | kUnweighted, false);
+ if ((props & kTopSorted) || fst.Start() == kNoStateId) {
+ queue_.reset(new StateOrderQueue<StateId>());
+ VLOG(2) << "AutoQueue: using state-order discipline";
+ } else if (props & kAcyclic) {
+ queue_.reset(new TopOrderQueue<StateId>(fst, filter));
+ VLOG(2) << "AutoQueue: using top-order discipline";
+ } else if ((props & kUnweighted) && (Weight::Properties() & kIdempotent)) {
+ queue_.reset(new LifoQueue<StateId>());
+ VLOG(2) << "AutoQueue: using LIFO discipline";
+ } else {
+ uint64 properties;
+ // Decomposes into strongly-connected components.
+ SccVisitor<Arc> scc_visitor(&scc_, nullptr, nullptr, &properties);
+ DfsVisit(fst, &scc_visitor, filter);
+ auto nscc = *std::max_element(scc_.begin(), scc_.end()) + 1;
+ std::vector<QueueType> queue_types(nscc);
+ std::unique_ptr<NaturalLess<Weight>> less;
+ std::unique_ptr<Compare> comp;
+ if (distance && (Weight::Properties() & kPath)) {
+ less.reset(new NaturalLess<Weight>());
+ comp.reset(new Compare(*distance, *less));
+ }
+ // Finds the queue type to use per SCC.
+ bool unweighted;
+ bool all_trivial;
+ SccQueueType(fst, scc_, &queue_types, filter, less.get(), &all_trivial,
+ &unweighted);
+ // If unweighted and semiring is idempotent, uses LIFO queue.
+ if (unweighted) {
+ queue_.reset(new LifoQueue<StateId>());
+ VLOG(2) << "AutoQueue: using LIFO discipline";
+ return;
+ }
+ // If all the SCC are trivial, the FST is acyclic and the scc number gives
+ // the topological order.
+ if (all_trivial) {
+ queue_.reset(new TopOrderQueue<StateId>(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<StateId, Compare, false>(*comp));
+ VLOG(3) << "AutoQueue: SCC #" << i
+ << ": using shortest-first discipline";
+ break;
+ case LIFO_QUEUE:
+ queues_[i].reset(new LifoQueue<StateId>());
+ VLOG(3) << "AutoQueue: SCC #" << i << ": using LIFO discipline";
+ break;
+ case FIFO_QUEUE:
+ default:
+ queues_[i].reset(new FifoQueue<StateId>());
+ VLOG(3) << "AutoQueue: SCC #" << i << ": using FIFO discipine";
+ break;
+ }
+ }
+ queue_.reset(new SccQueue<StateId, QueueBase<StateId>>(scc_, &queues_));
+ }
+ }
+
+ StateId Head() const override { return queue_->Head(); }
+
+ void Enqueue(StateId s) override { queue_->Enqueue(s); }
+
+ void Dequeue() override { queue_->Dequeue(); }
+
+ void Update(StateId s) override { queue_->Update(s); }
+
+ bool Empty() const override { return queue_->Empty(); }
+
+ void Clear() override { queue_->Clear(); }
+
+ private:
+ template <class Arc, class ArcFilter, class Less>
+ static void SccQueueType(const Fst<Arc> &fst, const std::vector<StateId> &scc,
+ std::vector<QueueType> *queue_types,
+ ArcFilter filter, Less *less, bool *all_trivial,
+ bool *unweighted);
+
+ std::unique_ptr<QueueBase<StateId>> queue_;
+ std::vector<std::unique_ptr<QueueBase<StateId>>> queues_;
+ std::vector<StateId> 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 <class StateId>
+template <class Arc, class ArcFilter, class Less>
+void AutoQueue<StateId>::SccQueueType(const Fst<Arc> &fst,
+ const std::vector<StateId> &scc,
+ std::vector<QueueType> *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<Fst<Arc>> sit(fst); !sit.Done(); sit.Next()) {
+ const auto state = sit.Value();
+ for (ArcIterator<Fst<Arc>> ait(fst, state); !ait.Done(); ait.Next()) {
+ const auto &arc = ait.Value();
+ if (!filter(arc)) continue;
+ if (scc[state] == scc[arc.nextstate]) {
+ auto &type = (*queue_type)[scc[state]];
+ if (!less || ((*less)(arc.weight, Weight::One()))) {
+ type = FIFO_QUEUE;
+ } else if ((type == TRIVIAL_QUEUE) || (type == LIFO_QUEUE)) {
+ if (!(Weight::Properties() & kIdempotent) ||
+ (arc.weight != Weight::Zero() && arc.weight != Weight::One())) {
+ type = SHORTEST_FIRST_QUEUE;
+ } else {
+ type = LIFO_QUEUE;
+ }
+ }
+ if (type != TRIVIAL_QUEUE) *all_trivial = false;
+ }
+ if (!(Weight::Properties() & kIdempotent) ||
+ (arc.weight != Weight::Zero() && arc.weight != Weight::One())) {
+ *unweighted = false;
+ }
+ }
+ }
+}
+
+// An A* estimate is a function object that maps from a state ID to a an
+// estimate of the shortest distance to the final states.
+
+// The trivial A* estimate is always One().
+template <typename StateId, typename Weight>
+struct TrivialAStarEstimate {
+ Weight operator()(StateId) const { return Weight::One(); }
+};
+
+// 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 <typename S, typename Less, typename Estimate>
+class AStarWeightCompare {
+ public:
+ using StateId = S;
+ using Weight = typename Less::Weight;
+
+ AStarWeightCompare(const std::vector<Weight> &weights, const Less &less,
+ const Estimate &estimate)
+ : weights_(weights), less_(less), estimate_(estimate) {}
+
+ bool operator()(const StateId s1, const StateId s2) const {
+ const auto w1 = Times(weights_[s1], estimate_(s1));
+ const auto w2 = Times(weights_[s2], estimate_(s2));
+ return less_(w1, w2);
+ }
+
+ private:
+ // Borrowed references.
+ const std::vector<Weight> &weights_;
+ const Less &less_;
+ const Estimate &estimate_;
+};
+
+// A* queue discipline templated on StateId, Weight, and Estimate.
+template <typename S, typename Weight, typename Estimate>
+class NaturalAStarQueue final
+ : public ShortestFirstQueue<
+ S, AStarWeightCompare<S, NaturalLess<Weight>, Estimate>> {
+ public:
+ using StateId = S;
+ using Compare = AStarWeightCompare<StateId, NaturalLess<Weight>, Estimate>;
+
+ NaturalAStarQueue(const std::vector<Weight> &distance,
+ const Estimate &estimate)
+ : ShortestFirstQueue<StateId, Compare>(
+ Compare(distance, less_, estimate)) {}
+
+ private:
+ // This is non-static because the constructor for non-idempotent weights will
+ // result in a an error.
+ const NaturalLess<Weight> 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 <typename StateId>
+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 <typename Queue, typename Less, typename ClassFnc>
+class PruneQueue : public QueueBase<typename Queue::StateId> {
+ public:
+ using StateId = typename Queue::StateId;
+ using Weight = typename Less::Weight;
+
+ PruneQueue(const std::vector<Weight> &distance, Queue *queue,
+ const Less &less, const ClassFnc &class_fnc, Weight threshold)
+ : QueueBase<StateId>(OTHER_QUEUE),
+ distance_(distance),
+ queue_(queue),
+ less_(less),
+ class_fnc_(class_fnc),
+ threshold_(std::move(threshold)) {}
+
+ 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<Weight> &distance_; // Shortest distance to state.
+ std::unique_ptr<Queue> queue_;
+ const Less &less_; // Borrowed reference.
+ const ClassFnc &class_fnc_; // Equivalence class functor.
+ Weight threshold_; // Pruning weight threshold.
+ std::vector<Weight> 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 <typename Queue, typename Weight, typename ClassFnc>
+class NaturalPruneQueue final
+ : public PruneQueue<Queue, NaturalLess<Weight>, ClassFnc> {
+ public:
+ using StateId = typename Queue::StateId;
+
+ NaturalPruneQueue(const std::vector<Weight> &distance, Queue *queue,
+ const ClassFnc &class_fnc, Weight threshold)
+ : PruneQueue<Queue, NaturalLess<Weight>, ClassFnc>(
+ distance, queue, NaturalLess<Weight>(), class_fnc, threshold) {}
+};
+
+// 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 <typename Queue, typename Filter>
+class FilterQueue final : public QueueBase<typename Queue::StateId> {
+ public:
+ using StateId = typename Queue::StateId;
+
+ FilterQueue(Queue *queue, const Filter &filter)
+ : QueueBase<StateId>(OTHER_QUEUE), queue_(queue), filter_(filter) {}
+
+ StateId Head() const override { return queue_->Head(); }
+
+ // Enqueues only if allowed by state filter.
+ void Enqueue(StateId s) override {
+ if (filter_(s)) queue_->Enqueue(s);
+ }
+
+ void Dequeue() override { queue_->Dequeue(); }
+
+ void Update(StateId s) override {}
+
+ bool Empty() const override { return queue_->Empty(); }
+
+ void Clear() override { queue_->Clear(); }
+
+ private:
+ std::unique_ptr<Queue> queue_;
+ const Filter &filter_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_QUEUE_H_
--- /dev/null
+// 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_LIB_RANDEQUIVALENT_H_
+#define FST_LIB_RANDEQUIVALENT_H_
+
+#include <fst/arcsort.h>
+#include <fst/compose.h>
+#include <fst/project.h>
+#include <fst/randgen.h>
+#include <fst/shortest-distance.h>
+#include <fst/vector-fst.h>
+
+
+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 <class Arc, class ArcSelector>
+bool RandEquivalent(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ int32 num_paths, float delta,
+ const RandGenOptions<ArcSelector> &opts,
+ bool *error = nullptr) {
+ using Weight = typename Arc::Weight;
+ if (error) *error = false;
+ // Checks that the symbol table are compatible.
+ if (!CompatSymbols(fst1.InputSymbols(), fst2.InputSymbols()) ||
+ !CompatSymbols(fst1.OutputSymbols(), fst2.OutputSymbols())) {
+ FSTERROR() << "RandEquivalent: Input/output symbol tables of 1st "
+ << "argument do not match input/output symbol tables of 2nd "
+ << "argument";
+ if (error) *error = true;
+ return false;
+ }
+ static const ILabelCompare<Arc> icomp;
+ static const OLabelCompare<Arc> ocomp;
+ VectorFst<Arc> sfst1(fst1);
+ VectorFst<Arc> sfst2(fst2);
+ Connect(&sfst1);
+ Connect(&sfst2);
+ ArcSort(&sfst1, icomp);
+ ArcSort(&sfst2, icomp);
+ bool result = true;
+ for (auto n = 0; n < num_paths; ++n) {
+ VectorFst<Arc> path;
+ const auto &fst = rand() % 2 ? sfst1 : sfst2; // NOLINT
+ RandGen(fst, &path, opts);
+ VectorFst<Arc> ipath(path);
+ VectorFst<Arc> opath(path);
+ Project(&ipath, PROJECT_INPUT);
+ Project(&opath, PROJECT_OUTPUT);
+ VectorFst<Arc> 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<Arc> cfst2;
+ Compose(ipath, sfst2, &cfst2);
+ ArcSort(&cfst2, ocomp);
+ VectorFst<Arc> pfst2;
+ Compose(cfst2, opath, &pfst2);
+ // Gives up if there are epsilon cycles in a non-idempotent semiring.
+ if (!(Weight::Properties() & kIdempotent) &&
+ pfst2.Properties(kCyclic, true)) {
+ continue;
+ }
+ const auto sum2 = ShortestDistance(pfst2);
+ if (!ApproxEqual(sum1, sum2, delta)) {
+ VLOG(1) << "Sum1 = " << sum1;
+ VLOG(1) << "Sum2 = " << sum2;
+ result = false;
+ break;
+ }
+ }
+ if (fst1.Properties(kError, false) || fst2.Properties(kError, false)) {
+ if (error) *error = true;
+ return false;
+ }
+ return result;
+}
+
+// Tests if two FSTs are equivalent by randomly generating a nnum_paths paths
+// (no longer than the path_length) using a user-specified seed, optionally
+// indicating an error setting an optional error argument to true.
+template <class Arc>
+bool RandEquivalent(const Fst<Arc> &fst1, const Fst<Arc> &fst2, int32 num_paths,
+ float delta = kDelta, time_t seed = time(nullptr),
+ int32 max_length = std::numeric_limits<int32>::max(),
+ bool *error = nullptr) {
+ const UniformArcSelector<Arc> uniform_selector(seed);
+ const RandGenOptions<UniformArcSelector<Arc>> opts(uniform_selector,
+ max_length);
+ return RandEquivalent(fst1, fst2, num_paths, delta, opts, error);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_RANDEQUIVALENT_H_
--- /dev/null
+// 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_LIB_RANDGEN_H_
+#define FST_LIB_RANDGEN_H_
+
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <limits>
+#include <map>
+#include <random>
+
+#include <fst/accumulator.h>
+#include <fst/cache.h>
+#include <fst/dfs-visit.h>
+#include <fst/mutable-fst.h>
+
+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.
+template <class Arc>
+struct UniformArcSelector {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ explicit UniformArcSelector(time_t seed = time(nullptr)) { srand(seed); }
+
+ size_t operator()(const Fst<Arc> &fst, StateId s) const {
+ const double r = rand() / (RAND_MAX + 1.0); // NOLINT
+ const auto n = fst.NumArcs(s) + (fst.Final(s) != Weight::Zero());
+ return static_cast<size_t>(r * n);
+ }
+};
+
+// 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.
+template <class Arc>
+class LogProbArcSelector {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ explicit LogProbArcSelector(time_t seed = time(nullptr)) { srand(seed); }
+
+ size_t operator()(const Fst<Arc> &fst, StateId s) const {
+ // Finds total weight leaving state.
+ auto sum = Log64Weight::Zero();
+ ArcIterator<Fst<Arc>> 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 =
+ (exp(-sum.Value()) * (rand() / (RAND_MAX + 1.0))); // NOLINT
+ auto p = Log64Weight::Zero();
+ size_t n = 0;
+ for (aiter.Reset(); !aiter.Done(); aiter.Next(), ++n) {
+ p = Plus(p, to_log_weight_(aiter.Value().weight));
+ if (exp(-p.Value()) > threshold) return n;
+ }
+ return n;
+ }
+
+ private:
+ WeightConvert<Weight, Log64Weight> to_log_weight_;
+};
+
+// Useful alias when using StdArc.
+using StdArcSelector = LogProbArcSelector<StdArc>;
+
+// Same as LogProbArcSelector but use CacheLogAccumulator to cache the
+// weight accumulation computations.
+template <class Arc>
+class FastLogProbArcSelector : public LogProbArcSelector<Arc> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using LogProbArcSelector<Arc>::operator();
+
+ explicit FastLogProbArcSelector(time_t seed = time(nullptr))
+ : LogProbArcSelector<Arc>(seed), seed_(seed) {}
+
+ size_t operator()(const Fst<Arc> &fst, StateId s,
+ CacheLogAccumulator<Arc> *accumulator) const {
+ accumulator->SetState(s);
+ ArcIterator<Fst<Arc>> aiter(fst, s);
+ // Finds total weight leaving state.
+ const double sum = to_log_weight_(accumulator->Sum(fst.Final(s), &aiter, 0,
+ fst.NumArcs(s)))
+ .Value();
+ const double r = -log(rand() / (RAND_MAX + 1.0)); // NOLINT
+ return accumulator->LowerBound(r + sum, &aiter);
+ }
+
+ time_t Seed() const { return seed_; }
+
+ private:
+ const time_t seed_;
+ WeightConvert<Weight, Log64Weight> to_log_weight_;
+};
+
+// Random path state info maintained by RandGenFst and passed to samplers.
+template <typename Arc>
+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<Arc> *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<Arc> *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 Arc, class Selector>
+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<Arc> &fst, const Selector &selector,
+ int32 max_length = std::numeric_limits<int32>::max())
+ : fst_(fst), selector_(selector), max_length_(max_length) {}
+
+ // Allow updating FST argument; pass only if changed.
+ ArcSampler(const ArcSampler<Arc, Selector> &sampler,
+ const Fst<Arc> *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<Arc> &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 (auto 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<size_t, size_t> Value() const { return *sample_iter_; }
+
+ void Reset() { sample_iter_ = sample_map_.begin(); }
+
+ bool Error() const { return false; }
+
+ private:
+ const Fst<Arc> &fst_;
+ const Selector &selector_;
+ const int32 max_length_;
+
+ // Stores (N, K) as described for Value().
+ std::map<size_t, size_t> sample_map_;
+ std::map<size_t, size_t>::const_iterator sample_iter_;
+
+ ArcSampler<Arc, Selector> &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 <class Result, class RNG>
+void OneMultinomialSample(const std::vector<double> &probs,
+ size_t num_to_sample, Result *result, RNG *rng) {
+ // Left-over probability mass.
+ double norm = 0;
+ for (double p : probs) norm += p;
+ // Left-over number of samples needed.
+ for (size_t i = 0; i < probs.size(); ++i) {
+ size_t num_sampled = 0;
+ if (probs[i] > 0) {
+ std::binomial_distribution<> d(num_to_sample, probs[i] / norm);
+ num_sampled = d(*rng);
+ }
+ if (num_sampled != 0) (*result)[i] = num_sampled;
+ norm -= probs[i];
+ num_to_sample -= num_sampled;
+ }
+}
+
+// Specialization for FastLogProbArcSelector.
+template <class Arc>
+class ArcSampler<Arc, FastLogProbArcSelector<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Accumulator = CacheLogAccumulator<Arc>;
+ using Selector = FastLogProbArcSelector<Arc>;
+
+ ArcSampler(const Fst<Arc> &fst, const Selector &selector,
+ int32 max_length = std::numeric_limits<int32>::max())
+ : fst_(fst),
+ selector_(selector),
+ max_length_(max_length),
+ accumulator_(new Accumulator()) {
+ accumulator_->Init(fst);
+ rng_.seed(selector_.Seed());
+ }
+
+ ArcSampler(const ArcSampler<Arc, Selector> &sampler,
+ const Fst<Arc> *fst = nullptr)
+ : fst_(fst ? *fst : sampler.fst_),
+ selector_(sampler.selector_),
+ max_length_(sampler.max_length_) {
+ if (fst) {
+ accumulator_.reset(new Accumulator());
+ accumulator_->Init(*fst);
+ } else { // Shallow copy.
+ accumulator_.reset(new Accumulator(*sampler.accumulator_));
+ }
+ }
+
+ bool Sample(const RandState<Arc> &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<size_t, size_t> 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<Arc> &rstate) {
+ p_.clear();
+ for (ArcIterator<Fst<Arc>> 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<RNG::result_type>::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<Arc> &fst_;
+ const Selector &selector_;
+ const int32 max_length_;
+
+ // Stores (N, K) for Value().
+ std::map<size_t, size_t> sample_map_;
+ std::map<size_t, size_t>::const_iterator sample_iter_;
+
+ std::unique_ptr<Accumulator> accumulator_;
+ RNG rng_; // Random number generator.
+ std::vector<double> p_; // Multinomial parameters.
+ WeightConvert<Weight, Log64Weight> 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 <class Sampler>
+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 FromArc, class ToArc, class Sampler>
+class RandGenFstImpl : public CacheImpl<ToArc> {
+ public:
+ using FstImpl<ToArc>::SetType;
+ using FstImpl<ToArc>::SetProperties;
+ using FstImpl<ToArc>::SetInputSymbols;
+ using FstImpl<ToArc>::SetOutputSymbols;
+
+ using CacheBaseImpl<CacheState<ToArc>>::PushArc;
+ using CacheBaseImpl<CacheState<ToArc>>::HasArcs;
+ using CacheBaseImpl<CacheState<ToArc>>::HasFinal;
+ using CacheBaseImpl<CacheState<ToArc>>::HasStart;
+ using CacheBaseImpl<CacheState<ToArc>>::SetArcs;
+ using CacheBaseImpl<CacheState<ToArc>>::SetFinal;
+ using CacheBaseImpl<CacheState<ToArc>>::SetStart;
+
+ using Label = typename FromArc::Label;
+ using StateId = typename FromArc::StateId;
+ using FromWeight = typename FromArc::Weight;
+
+ using ToWeight = typename ToArc::Weight;
+
+ RandGenFstImpl(const Fst<FromArc> &fst,
+ const RandGenFstOptions<Sampler> &opts)
+ : CacheImpl<ToArc>(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<ToArc>(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<FromArc>(s, npath_, 0, 0, nullptr));
+ }
+ return CacheImpl<ToArc>::Start();
+ }
+
+ ToWeight Final(StateId s) {
+ if (!HasFinal(s)) Expand(s);
+ return CacheImpl<ToArc>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<ToArc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<ToArc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<ToArc>::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<ToArc>::Properties(mask);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<ToArc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<ToArc>::InitArcIterator(s, data);
+ }
+
+ // Computes the outgoing transitions from a state, creating new destination
+ // states as needed.
+ void Expand(StateId s) {
+ if (s == superfinal_) {
+ SetFinal(s, ToWeight::One());
+ SetArcs(s);
+ return;
+ }
+ SetFinal(s, ToWeight::Zero());
+ const auto &rstate = *state_table_[s];
+ sampler_->Sample(rstate);
+ ArcIterator<Fst<FromArc>> 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<double>(count) / rstate.nsamples;
+ if (pos < narcs) { // Regular transition.
+ aiter.Seek(sample_pair.first);
+ const auto &aarc = aiter.Value();
+ const auto weight =
+ weighted_ ? to_weight_(Log64Weight(-log(prob))) : ToWeight::One();
+ const ToArc barc(aarc.ilabel, aarc.olabel, weight, state_table_.size());
+ PushArc(s, barc);
+ auto *nrstate = new RandState<FromArc>(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<FromArc>(kNoStateId, 0, 0, 0, nullptr));
+ }
+ for (size_t n = 0; n < count; ++n) {
+ const ToArc barc(0, 0, ToWeight::One(), superfinal_);
+ PushArc(s, barc);
+ }
+ }
+ }
+ }
+ SetArcs(s);
+ }
+
+ private:
+ const std::unique_ptr<Fst<FromArc>> fst_;
+ std::unique_ptr<Sampler> sampler_;
+ const int32 npath_;
+ std::vector<std::unique_ptr<RandState<FromArc>>> state_table_;
+ const bool weighted_;
+ bool remove_total_weight_;
+ StateId superfinal_;
+ WeightConvert<Log64Weight, ToWeight> 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 FromArc, class ToArc, class Sampler>
+class RandGenFst
+ : public ImplToFst<internal::RandGenFstImpl<FromArc, ToArc, Sampler>> {
+ public:
+ using Label = typename FromArc::Label;
+ using StateId = typename FromArc::StateId;
+ using Weight = typename FromArc::Weight;
+
+ using Store = DefaultCacheStore<FromArc>;
+ using State = typename Store::State;
+
+ using Impl = internal::RandGenFstImpl<FromArc, ToArc, Sampler>;
+
+ friend class ArcIterator<RandGenFst<FromArc, ToArc, Sampler>>;
+ friend class StateIterator<RandGenFst<FromArc, ToArc, Sampler>>;
+
+ RandGenFst(const Fst<FromArc> &fst, const RandGenFstOptions<Sampler> &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ RandGenFst(const RandGenFst<FromArc, ToArc, Sampler> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this RandGenFst. See Fst<>::Copy() for further doc.
+ RandGenFst<FromArc, ToArc, Sampler> *Copy(bool safe = false) const override {
+ return new RandGenFst<FromArc, ToArc, Sampler>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<ToArc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<ToArc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ RandGenFst &operator=(const RandGenFst &) = delete;
+};
+
+// Specialization for RandGenFst.
+template <class FromArc, class ToArc, class Sampler>
+class StateIterator<RandGenFst<FromArc, ToArc, Sampler>>
+ : public CacheStateIterator<RandGenFst<FromArc, ToArc, Sampler>> {
+ public:
+ explicit StateIterator(const RandGenFst<FromArc, ToArc, Sampler> &fst)
+ : CacheStateIterator<RandGenFst<FromArc, ToArc, Sampler>>(
+ fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for RandGenFst.
+template <class FromArc, class ToArc, class Sampler>
+class ArcIterator<RandGenFst<FromArc, ToArc, Sampler>>
+ : public CacheArcIterator<RandGenFst<FromArc, ToArc, Sampler>> {
+ public:
+ using StateId = typename FromArc::StateId;
+
+ ArcIterator(const RandGenFst<FromArc, ToArc, Sampler> &fst, StateId s)
+ : CacheArcIterator<RandGenFst<FromArc, ToArc, Sampler>>(
+ fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class FromArc, class ToArc, class Sampler>
+inline void RandGenFst<FromArc, ToArc, Sampler>::InitStateIterator(
+ StateIteratorData<ToArc> *data) const {
+ data->base = new StateIterator<RandGenFst<FromArc, ToArc, Sampler>>(*this);
+}
+
+// Options for random path generation.
+template <class Selector>
+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<int32>::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 FromArc, class ToArc>
+class RandGenVisitor {
+ public:
+ using StateId = typename FromArc::StateId;
+ using Weight = typename FromArc::Weight;
+
+ explicit RandGenVisitor(MutableFst<ToArc> *ofst) : ofst_(ofst) {}
+
+ void InitVisit(const Fst<FromArc> &ifst) {
+ ifst_ = &ifst;
+ ofst_->DeleteStates();
+ ofst_->SetInputSymbols(ifst.InputSymbols());
+ ofst_->SetOutputSymbols(ifst.OutputSymbols());
+ if (ifst.Properties(kError, false)) ofst_->SetProperties(kError, kError);
+ path_.clear();
+ }
+
+ constexpr bool InitState(StateId, StateId) const { return true; }
+
+ bool TreeArc(StateId, const ToArc &arc) {
+ if (ifst_->Final(arc.nextstate) == Weight::Zero()) {
+ path_.push_back(arc);
+ } else {
+ OutputPath();
+ }
+ return true;
+ }
+
+ bool BackArc(StateId, const FromArc &) {
+ FSTERROR() << "RandGenVisitor: cyclic input";
+ ofst_->SetProperties(kError, kError);
+ return false;
+ }
+
+ bool ForwardOrCrossArc(StateId, const FromArc &) {
+ OutputPath();
+ return true;
+ }
+
+ void FinishState(StateId s, StateId p, const FromArc *) {
+ if (p != kNoStateId && ifst_->Final(s) == Weight::Zero()) path_.pop_back();
+ }
+
+ void FinishVisit() {}
+
+ private:
+ void OutputPath() {
+ if (ofst_->Start() == kNoStateId) {
+ const auto start = ofst_->AddState();
+ ofst_->SetStart(start);
+ }
+ auto src = ofst_->Start();
+ for (size_t i = 0; i < path_.size(); ++i) {
+ const auto dest = ofst_->AddState();
+ const ToArc arc(path_[i].ilabel, path_[i].olabel, Weight::One(), dest);
+ ofst_->AddArc(src, arc);
+ src = dest;
+ }
+ ofst_->SetFinal(src, Weight::One());
+ }
+
+ const Fst<FromArc> *ifst_;
+ MutableFst<ToArc> *ofst_;
+ std::vector<ToArc> path_;
+
+ RandGenVisitor(const RandGenVisitor &) = delete;
+ RandGenVisitor &operator=(const RandGenVisitor &) = delete;
+};
+
+} // namespace internal
+
+// Randomly generate paths through an FST; details controlled by
+// RandGenOptions.
+template <class FromArc, class ToArc, class Selector>
+void RandGen(const Fst<FromArc> &ifst, MutableFst<ToArc> *ofst,
+ const RandGenOptions<Selector> &opts) {
+ using State = typename ToArc::StateId;
+ using Weight = typename ToArc::Weight;
+ using Sampler = ArcSampler<FromArc, Selector>;
+ auto *sampler = new Sampler(ifst, opts.selector, opts.max_length);
+ RandGenFstOptions<Sampler> fopts(CacheOptions(true, 0), sampler, opts.npath,
+ opts.weighted, opts.remove_total_weight);
+ RandGenFst<FromArc, ToArc, Sampler> rfst(ifst, fopts);
+ if (opts.weighted) {
+ *ofst = rfst;
+ } else {
+ internal::RandGenVisitor<FromArc, ToArc> rand_visitor(ofst);
+ DfsVisit(rfst, &rand_visitor);
+ }
+}
+
+// Randomly generate a path through an FST with the uniform distribution
+// over the transitions.
+template <class FromArc, class ToArc>
+void RandGen(const Fst<FromArc> &ifst, MutableFst<ToArc> *ofst) {
+ const UniformArcSelector<FromArc> uniform_selector;
+ RandGenOptions<UniformArcSelector<ToArc>> opts(uniform_selector);
+ RandGen(ifst, ofst, opts);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_RANDGEN_H_
--- /dev/null
+// 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_LIB_RATIONAL_H_
+#define FST_LIB_RATIONAL_H_
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include <fst/mutable-fst.h>
+#include <fst/replace.h>
+#include <fst/test-properties.h>
+
+
+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 Arc>
+class RationalFst;
+
+template <class Arc>
+void Union(RationalFst<Arc> *fst1, const Fst<Arc> &fst2);
+
+template <class Arc>
+void Concat(RationalFst<Arc> *fst1, const Fst<Arc> &fst2);
+
+template <class Arc>
+void Concat(const Fst<Arc> &fst1, RationalFst<Arc> *fst2);
+
+template <class Arc>
+void Closure(RationalFst<Arc> *fst, ClosureType closure_type);
+
+namespace internal {
+
+// Implementation class for delayed unions, concatenations and closures.
+template <class A>
+class RationalFstImpl : public FstImpl<A> {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::WriteHeader;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ explicit RationalFstImpl(const RationalFstOptions &opts)
+ : nonterminals_(0), replace_options_(opts, 0) {
+ SetType("rational");
+ fst_tuples_.push_back(std::make_pair(0, nullptr));
+ }
+
+ RationalFstImpl(const RationalFstImpl<Arc> &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<Arc>::Properties(mask);
+ }
+
+ // Implementation of UnionFst(fst1, fst2).
+ void InitUnion(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {
+ replace_.reset();
+ const auto props1 = fst1.Properties(kFstProperties, false);
+ const auto props2 = fst2.Properties(kFstProperties, false);
+ SetInputSymbols(fst1.InputSymbols());
+ SetOutputSymbols(fst1.OutputSymbols());
+ rfst_.AddState();
+ rfst_.AddState();
+ rfst_.SetStart(0);
+ rfst_.SetFinal(1, Weight::One());
+ rfst_.SetInputSymbols(fst1.InputSymbols());
+ rfst_.SetOutputSymbols(fst1.OutputSymbols());
+ nonterminals_ = 2;
+ rfst_.AddArc(0, Arc(0, -1, Weight::One(), 1));
+ rfst_.AddArc(0, Arc(0, -2, Weight::One(), 1));
+ fst_tuples_.push_back(std::make_pair(-1, fst1.Copy()));
+ fst_tuples_.push_back(std::make_pair(-2, fst2.Copy()));
+ SetProperties(UnionProperties(props1, props2, true), kCopyProperties);
+ }
+
+ // Implementation of ConcatFst(fst1, fst2).
+ void InitConcat(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {
+ replace_.reset();
+ const auto props1 = fst1.Properties(kFstProperties, false);
+ const auto props2 = fst2.Properties(kFstProperties, false);
+ SetInputSymbols(fst1.InputSymbols());
+ SetOutputSymbols(fst1.OutputSymbols());
+ rfst_.AddState();
+ rfst_.AddState();
+ rfst_.AddState();
+ rfst_.SetStart(0);
+ rfst_.SetFinal(2, Weight::One());
+ rfst_.SetInputSymbols(fst1.InputSymbols());
+ rfst_.SetOutputSymbols(fst1.OutputSymbols());
+ nonterminals_ = 2;
+ rfst_.AddArc(0, Arc(0, -1, Weight::One(), 1));
+ rfst_.AddArc(1, Arc(0, -2, Weight::One(), 2));
+ fst_tuples_.push_back(std::make_pair(-1, fst1.Copy()));
+ fst_tuples_.push_back(std::make_pair(-2, fst2.Copy()));
+ SetProperties(ConcatProperties(props1, props2, true), kCopyProperties);
+ }
+
+ // Implementation of ClosureFst(fst, closure_type).
+ void InitClosure(const Fst<Arc> &fst, ClosureType closure_type) {
+ replace_.reset();
+ const auto props = fst.Properties(kFstProperties, false);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ if (closure_type == CLOSURE_STAR) {
+ rfst_.AddState();
+ rfst_.SetStart(0);
+ rfst_.SetFinal(0, Weight::One());
+ rfst_.AddArc(0, Arc(0, -1, Weight::One(), 0));
+ } else {
+ rfst_.AddState();
+ rfst_.AddState();
+ rfst_.SetStart(0);
+ rfst_.SetFinal(1, Weight::One());
+ rfst_.AddArc(0, Arc(0, -1, Weight::One(), 1));
+ rfst_.AddArc(1, Arc(0, 0, Weight::One(), 0));
+ }
+ rfst_.SetInputSymbols(fst.InputSymbols());
+ rfst_.SetOutputSymbols(fst.OutputSymbols());
+ fst_tuples_.push_back(std::make_pair(-1, fst.Copy()));
+ nonterminals_ = 1;
+ SetProperties(ClosureProperties(props, closure_type == CLOSURE_STAR, true),
+ kCopyProperties);
+ }
+
+ // Implementation of Union(Fst &, RationalFst *).
+ void AddUnion(const Fst<Arc> &fst) {
+ replace_.reset();
+ const auto props1 = FstImpl<A>::Properties();
+ const auto props2 = fst.Properties(kFstProperties, false);
+ VectorFst<Arc> afst;
+ afst.AddState();
+ afst.AddState();
+ afst.SetStart(0);
+ afst.SetFinal(1, Weight::One());
+ ++nonterminals_;
+ afst.AddArc(0, Arc(0, -nonterminals_, Weight::One(), 1));
+ Union(&rfst_, afst);
+ fst_tuples_.push_back(std::make_pair(-nonterminals_, fst.Copy()));
+ SetProperties(UnionProperties(props1, props2, true), kCopyProperties);
+ }
+
+ // Implementation of Concat(Fst &, RationalFst *).
+ void AddConcat(const Fst<Arc> &fst, bool append) {
+ replace_.reset();
+ const auto props1 = FstImpl<A>::Properties();
+ const auto props2 = fst.Properties(kFstProperties, false);
+ VectorFst<Arc> afst;
+ afst.AddState();
+ afst.AddState();
+ afst.SetStart(0);
+ afst.SetFinal(1, Weight::One());
+ ++nonterminals_;
+ afst.AddArc(0, Arc(0, -nonterminals_, Weight::One(), 1));
+ if (append) {
+ Concat(&rfst_, afst);
+ } else {
+ Concat(afst, &rfst_);
+ }
+ fst_tuples_.push_back(std::make_pair(-nonterminals_, fst.Copy()));
+ SetProperties(ConcatProperties(props1, props2, true), kCopyProperties);
+ }
+
+ // Implementation of Closure(RationalFst *, closure_type).
+ void AddClosure(ClosureType closure_type) {
+ replace_.reset();
+ const auto props = FstImpl<A>::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<Arc> *Replace() const {
+ if (!replace_) {
+ fst_tuples_[0].second = rfst_.Copy();
+ replace_.reset(new ReplaceFst<Arc>(fst_tuples_, replace_options_));
+ }
+ return replace_.get();
+ }
+
+ private:
+ // Rational topology machine, using negative non-terminals.
+ VectorFst<Arc> rfst_;
+ // Number of nonterminals used.
+ Label nonterminals_;
+ // Contains the nonterminals and their corresponding FSTs.
+ mutable std::vector<std::pair<Label, const Fst<Arc> *>> fst_tuples_;
+ // Underlying ReplaceFst.
+ mutable std::unique_ptr<ReplaceFst<Arc>> replace_;
+ const ReplaceFstOptions<Arc> 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 A>
+class RationalFst : public ImplToFst<internal::RationalFstImpl<A>> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ using Impl = internal::RationalFstImpl<Arc>;
+
+ friend class StateIterator<RationalFst<Arc>>;
+ friend class ArcIterator<RationalFst<Arc>>;
+ friend void Union<>(RationalFst<Arc> *fst1, const Fst<Arc> &fst2);
+ friend void Concat<>(RationalFst<Arc> *fst1, const Fst<Arc> &fst2);
+ friend void Concat<>(const Fst<Arc> &fst1, RationalFst<Arc> *fst2);
+ friend void Closure<>(RationalFst<Arc> *fst, ClosureType closure_type);
+
+ void InitStateIterator(StateIteratorData<Arc> *data) const override {
+ GetImpl()->Replace()->InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetImpl()->Replace()->InitArcIterator(s, data);
+ }
+
+ protected:
+ using ImplToFst<Impl>::GetImpl;
+
+ explicit RationalFst(const RationalFstOptions &opts = RationalFstOptions())
+ : ImplToFst<Impl>(std::make_shared<Impl>(opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ RationalFst(const RationalFst<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ private:
+ RationalFst &operator=(const RationalFst &) = delete;
+};
+
+// Specialization for RationalFst.
+template <class Arc>
+class StateIterator<RationalFst<Arc>> : public StateIterator<ReplaceFst<Arc>> {
+ public:
+ explicit StateIterator(const RationalFst<Arc> &fst)
+ : StateIterator<ReplaceFst<Arc>>(*(fst.GetImpl()->Replace())) {}
+};
+
+// Specialization for RationalFst.
+template <class Arc>
+class ArcIterator<RationalFst<Arc>> : public CacheArcIterator<ReplaceFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const RationalFst<Arc> &fst, StateId s)
+ : ArcIterator<ReplaceFst<Arc>>(*(fst.GetImpl()->Replace()), s) {}
+};
+
+} // namespace fst
+
+#endif // FST_LIB_RATIONAL_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Classes for registering derived FST for generic reading.
+
+#ifndef FST_LIB_REGISTER_H_
+#define FST_LIB_REGISTER_H_
+
+#include <string>
+
+
+#include <fst/compat.h>
+#include <fst/generic-register.h>
+#include <fst/util.h>
+
+
+#include <fst/types.h>
+
+namespace fst {
+
+template <class Arc>
+class Fst;
+
+struct FstReadOptions;
+
+// This class represents a single entry in a FstRegister
+template <class Arc>
+struct FstRegisterEntry {
+ using Reader = Fst<Arc> *(*)(std::istream &istrm, const FstReadOptions &opts);
+ using Converter = Fst<Arc> *(*)(const Fst<Arc> &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 Arc>
+class FstRegister
+ : public GenericRegister<string, FstRegisterEntry<Arc>, FstRegister<Arc>> {
+ public:
+ using Reader = typename FstRegisterEntry<Arc>::Reader;
+ using Converter = typename FstRegisterEntry<Arc>::Converter;
+
+ const Reader GetReader(const string &type) const {
+ return this->GetEntry(type).reader;
+ }
+
+ const Converter GetConverter(const string &type) const {
+ return this->GetEntry(type).converter;
+ }
+
+ protected:
+ string ConvertKeyToSoFilename(const string &key) const override {
+ string legal_type(key);
+ ConvertToLegalCSymbol(&legal_type);
+ return legal_type + "-fst.so";
+ }
+};
+
+// This class registers an FST type for generic reading and creating.
+// The type must have a default constructor and a copy constructor from
+// Fst<Arc>.
+template <class FST>
+class FstRegisterer : public GenericRegisterer<FstRegister<typename FST::Arc>> {
+ public:
+ using Arc = typename FST::Arc;
+ using Entry = typename FstRegister<Arc>::Entry;
+ using Reader = typename FstRegister<Arc>::Reader;
+
+ FstRegisterer()
+ : GenericRegisterer<FstRegister<typename FST::Arc>>(FST().Type(),
+ BuildEntry()) {}
+
+ private:
+ static Entry BuildEntry() {
+ FST *(*reader)(std::istream & strm, const FstReadOptions &opts) =
+ &FST::Read;
+ return Entry(reinterpret_cast<Reader>(reader),
+ &FstRegisterer<FST>::Convert);
+ }
+
+ static Fst<Arc> *Convert(const Fst<Arc> &fst) { return new FST(fst); }
+};
+
+// Convenience macro to generate static FstRegisterer instance.
+#define REGISTER_FST(FST, Arc) \
+ static fst::FstRegisterer<FST<Arc>> FST##_##Arc##_registerer
+
+// Converts an FST to the specified type.
+template <class Arc>
+Fst<Arc> *Convert(const Fst<Arc> &fst, const string &fst_type) {
+ auto *reg = FstRegister<Arc>::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_LIB_REGISTER_H_
--- /dev/null
+// 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_LIB_RELABEL_H_
+#define FST_LIB_RELABEL_H_
+
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/test-properties.h>
+
+
+#include <unordered_map>
+
+namespace fst {
+
+// Relabels either the input labels or output labels. The old to
+// new labels are specified using a vector of std::pair<Label, Label>.
+// Any label associations not specified are assumed to be identity
+// mapping. The destination labels must be valid labels (e.g., not kNoLabel).
+template <class Arc>
+void Relabel(
+ MutableFst<Arc> *fst,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &ipairs,
+ const std::vector<std::pair<typename Arc::Label, typename Arc::Label>>
+ &opairs) {
+ using Label = typename Arc::Label;
+ const auto props = fst->Properties(kFstProperties, false);
+ // Constructs label-to-label maps.
+ std::unordered_map<Label, Label> input_map;
+ for (auto &ipair : ipairs) input_map[ipair.first] = ipair.second;
+ std::unordered_map<Label, Label> output_map;
+ for (auto &opair : opairs) output_map[opair.first] = opair.second;
+ for (StateIterator<MutableFst<Arc>> siter(*fst); !siter.Done();
+ siter.Next()) {
+ for (MutableArcIterator<MutableFst<Arc>> 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.
+template <class Arc>
+void Relabel(MutableFst<Arc> *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) {
+ using Label = typename Arc::Label;
+ // Constructs vectors of input-side label pairs.
+ std::vector<std::pair<Label, Label>> ipairs;
+ if (old_isymbols && new_isymbols) {
+ size_t num_missing_syms = 0;
+ for (SymbolTableIterator siter(*old_isymbols); !siter.Done();
+ siter.Next()) {
+ const auto old_index = siter.Value();
+ const auto symbol = siter.Symbol();
+ const auto new_index = new_isymbols->Find(siter.Symbol());
+ if (new_index == kNoLabel) {
+ VLOG(1) << "Input symbol ID " << new_index << " symbol '" << symbol
+ << "' missing from target symbol table";
+ ++num_missing_syms;
+ }
+ ipairs.push_back(std::make_pair(old_index, new_index));
+ }
+ if (num_missing_syms > 0) {
+ LOG(WARNING) << "Target symbol table missing: " << num_missing_syms
+ << " input symbols";
+ }
+ if (attach_new_isymbols) fst->SetInputSymbols(new_isymbols);
+ }
+ // Constructs vectors of output-side label pairs.
+ std::vector<std::pair<Label, Label>> opairs;
+ if (old_osymbols && new_osymbols) {
+ size_t num_missing_syms = 0;
+ for (SymbolTableIterator siter(*old_osymbols); !siter.Done();
+ siter.Next()) {
+ const auto old_index = siter.Value();
+ const auto symbol = siter.Symbol();
+ const auto new_index = new_osymbols->Find(siter.Symbol());
+ if (new_index == kNoLabel) {
+ VLOG(1) << "Output symbol ID " << new_index << " symbol '" << symbol
+ << "' missing from target symbol table";
+ ++num_missing_syms;
+ }
+ opairs.push_back(std::make_pair(old_index, new_index));
+ }
+ if (num_missing_syms > 0) {
+ LOG(WARNING) << "Target symbol table missing: " << num_missing_syms
+ << " output symbols";
+ }
+ if (attach_new_osymbols) fst->SetOutputSymbols(new_osymbols);
+ }
+ // Calls relabel using vector of relabel pairs.
+ Relabel(fst, ipairs, opairs);
+}
+
+// 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 <class Arc>
+void Relabel(MutableFst<Arc> *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 Arc>
+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 Arc>
+class RelabelFstImpl : public CacheImpl<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::WriteHeader;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheImpl<Arc>::PushArc;
+ using CacheImpl<Arc>::HasArcs;
+ using CacheImpl<Arc>::HasFinal;
+ using CacheImpl<Arc>::HasStart;
+ using CacheImpl<Arc>::SetArcs;
+ using CacheImpl<Arc>::SetFinal;
+ using CacheImpl<Arc>::SetStart;
+
+ friend class StateIterator<RelabelFst<Arc>>;
+
+ RelabelFstImpl(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &ipairs,
+ const std::vector<std::pair<Label, Label>> &opairs,
+ const RelabelFstOptions &opts)
+ : CacheImpl<Arc>(opts),
+ fst_(fst.Copy()),
+ relabel_input_(false),
+ relabel_output_(false) {
+ SetProperties(RelabelProperties(fst.Properties(kCopyProperties, false)));
+ SetType("relabel");
+ // Creates input label map.
+ if (!ipairs.empty()) {
+ for (auto &ipair : ipairs) input_map_[ipair.first] = ipair.second;
+ relabel_input_ = true;
+ }
+ // Creates output label map.
+ if (!opairs.empty()) {
+ for (auto &opair : opairs) output_map_[opair.first] = opair.second;
+ relabel_output_ = true;
+ }
+ }
+
+ RelabelFstImpl(const Fst<Arc> &fst, const SymbolTable *old_isymbols,
+ const SymbolTable *new_isymbols,
+ const SymbolTable *old_osymbols,
+ const SymbolTable *new_osymbols, const RelabelFstOptions &opts)
+ : CacheImpl<Arc>(opts),
+ fst_(fst.Copy()),
+ relabel_input_(false),
+ relabel_output_(false) {
+ SetType("relabel");
+ SetProperties(RelabelProperties(fst.Properties(kCopyProperties, false)));
+ SetInputSymbols(old_isymbols);
+ SetOutputSymbols(old_osymbols);
+ if (old_isymbols && new_isymbols &&
+ old_isymbols->LabeledCheckSum() != new_isymbols->LabeledCheckSum()) {
+ for (SymbolTableIterator siter(*old_isymbols); !siter.Done();
+ siter.Next()) {
+ input_map_[siter.Value()] = new_isymbols->Find(siter.Symbol());
+ }
+ SetInputSymbols(new_isymbols);
+ relabel_input_ = true;
+ }
+ if (old_osymbols && new_osymbols &&
+ old_osymbols->LabeledCheckSum() != new_osymbols->LabeledCheckSum()) {
+ for (SymbolTableIterator siter(*old_osymbols); !siter.Done();
+ siter.Next()) {
+ output_map_[siter.Value()] = new_osymbols->Find(siter.Symbol());
+ }
+ SetOutputSymbols(new_osymbols);
+ relabel_output_ = true;
+ }
+ }
+
+ RelabelFstImpl(const RelabelFstImpl<Arc> &impl)
+ : CacheImpl<Arc>(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<Arc>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) SetFinal(s, fst_->Final(s));
+ return CacheImpl<Arc>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::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<Arc>::Properties(mask);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<Arc>::InitArcIterator(s, data);
+ }
+
+ void Expand(StateId s) {
+ for (ArcIterator<Fst<Arc>> aiter(*fst_, s); !aiter.Done(); aiter.Next()) {
+ auto arc = aiter.Value();
+ if (relabel_input_) {
+ auto it = input_map_.find(arc.ilabel);
+ if (it != input_map_.end()) arc.ilabel = it->second;
+ }
+ if (relabel_output_) {
+ auto it = output_map_.find(arc.olabel);
+ if (it != output_map_.end()) {
+ arc.olabel = it->second;
+ }
+ }
+ PushArc(s, arc);
+ }
+ SetArcs(s);
+ }
+
+ private:
+ std::unique_ptr<const Fst<Arc>> fst_;
+
+ std::unordered_map<Label, Label> input_map_;
+ std::unordered_map<Label, Label> 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 A>
+class RelabelFst : public ImplToFst<internal::RelabelFstImpl<A>> {
+ public:
+ using Arc = A;
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::RelabelFstImpl<Arc>;
+
+ friend class ArcIterator<RelabelFst<A>>;
+ friend class StateIterator<RelabelFst<A>>;
+
+ RelabelFst(const Fst<Arc> &fst,
+ const std::vector<std::pair<Label, Label>> &ipairs,
+ const std::vector<std::pair<Label, Label>> &opairs,
+ const RelabelFstOptions &opts = RelabelFstOptions())
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, ipairs, opairs, opts)) {}
+
+ RelabelFst(const Fst<Arc> &fst, const SymbolTable *new_isymbols,
+ const SymbolTable *new_osymbols,
+ const RelabelFstOptions &opts = RelabelFstOptions())
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, fst.InputSymbols(), new_isymbols,
+ fst.OutputSymbols(), new_osymbols, opts)) {}
+
+ RelabelFst(const Fst<Arc> &fst, const SymbolTable *old_isymbols,
+ const SymbolTable *new_isymbols, const SymbolTable *old_osymbols,
+ const SymbolTable *new_osymbols,
+ const RelabelFstOptions &opts = RelabelFstOptions())
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, old_isymbols, new_isymbols,
+ old_osymbols, new_osymbols,
+ opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ RelabelFst(const RelabelFst<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Gets a copy of this RelabelFst. See Fst<>::Copy() for further doc.
+ RelabelFst<Arc> *Copy(bool safe = false) const override {
+ return new RelabelFst<Arc>(*this, safe);
+ }
+
+ void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ return GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ RelabelFst &operator=(const RelabelFst &) = delete;
+};
+
+// Specialization for RelabelFst.
+template <class Arc>
+class StateIterator<RelabelFst<Arc>> final : public StateIteratorBase<Arc> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ explicit StateIterator(const RelabelFst<Arc> &fst)
+ : impl_(fst.GetImpl()), siter_(*impl_->fst_), s_(0) {}
+
+ bool Done() const override { return siter_.Done(); }
+
+ StateId Value() const override { return s_; }
+
+ void Next() override {
+ if (!siter_.Done()) {
+ ++s_;
+ siter_.Next();
+ }
+ }
+
+ void Reset() override {
+ s_ = 0;
+ siter_.Reset();
+ }
+
+ private:
+ const internal::RelabelFstImpl<Arc>* impl_;
+ StateIterator<Fst<Arc>> siter_;
+ StateId s_;
+
+ StateIterator(const StateIterator &) = delete;
+ StateIterator &operator=(const StateIterator &) = delete;
+};
+
+// Specialization for RelabelFst.
+template <class Arc>
+class ArcIterator<RelabelFst<Arc>> : public CacheArcIterator<RelabelFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const RelabelFst<Arc> &fst, StateId s)
+ : CacheArcIterator<RelabelFst<Arc>>(fst.GetImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetImpl()->Expand(s);
+ }
+};
+
+template <class Arc>
+inline void RelabelFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<RelabelFst<Arc>>(*this);
+}
+
+// Useful alias when using StdArc.
+using StdRelabelFst = RelabelFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_RELABEL_H_
--- /dev/null
+// 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_LIB_REPLACE_UTIL_H_
+#define FST_LIB_REPLACE_UTIL_H_
+
+#include <map>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include <fst/connect.h>
+#include <fst/mutable-fst.h>
+#include <fst/topsort.h>
+#include <fst/vector-fst.h>
+
+
+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 <class Arc>
+void Replace(
+ const std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>> &,
+ MutableFst<Arc> *, 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 Arc>
+class ReplaceUtil {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstPair = std::pair<Label, const Fst<Arc> *>;
+ using MutableFstPair = std::pair<Label, MutableFst<Arc> *>;
+ using NonTerminalHash = std::unordered_map<Label, Label>;
+
+ // Constructs from mutable FSTs; FST ownership is given to ReplaceUtil.
+ ReplaceUtil(const std::vector<MutableFstPair> &fst_pairs,
+ const ReplaceUtilOptions &opts);
+
+ // Constructs from FSTs; FST ownership is retained by caller.
+ ReplaceUtil(const std::vector<FstPair> &fst_pairs,
+ const ReplaceUtilOptions &opts);
+
+ // Constructs from ReplaceFst internals; FST ownership is retained by caller.
+ ReplaceUtil(const std::vector<std::unique_ptr<const Fst<Arc>>> &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<Label> &labels);
+
+ // Replaces FSTs that have at most nstates states, narcs arcs and nnonterm
+ // non-terminals (updating in reverse dependency order), unless there are
+ // cyclic dependencies.
+ void ReplaceBySize(size_t nstates, size_t narcs, size_t nnonterms);
+
+ // Replaces singleton FSTS, unless there are cyclic dependencies.
+ void ReplaceTrivial() { ReplaceBySize(2, 1, 1); }
+
+ // Replaces non-terminals that have at most ninstances instances (updating in
+ // dependency order), unless there are cyclic dependencies.
+ void ReplaceByInstances(size_t ninstances);
+
+ // Replaces non-terminals that have only one instance, unless there are cyclic
+ // dependencies.
+ void ReplaceUnique() { ReplaceByInstances(1); }
+
+ // Returns label/FST pairs, retaining FST ownership.
+ void GetFstPairs(std::vector<FstPair> *fst_pairs);
+
+ // Returns label/mutable FST pairs, giving FST ownership over to the caller.
+ void GetMutableFstPairs(std::vector<MutableFstPair> *mutable_fst_pairs);
+
+ private:
+ // FST statistics.
+ struct ReplaceStats {
+ StateId nstates; // Number of states.
+ StateId nfinal; // Number of final states.
+ size_t narcs; // Number of arcs.
+ Label nnonterms; // Number of non-terminals in FST.
+ size_t nref; // Number of non-terminal instances referring to this FST.
+ // Number of times that ith FST references this FST
+ std::map<Label, size_t> inref;
+ // Number of times that this FST references the ith FST
+ std::map<Label, size_t> outref;
+
+ ReplaceStats() : nstates(0), nfinal(0), narcs(0), nnonterms(0), nref(0) {}
+ };
+
+ // Checks that Mutable FSTs exists, creating them if necessary.
+ void CheckMutableFsts();
+
+ // Computes the dependency graph for the RTN, computing dependency statistics
+ // if stats is true.
+ void GetDependencies(bool stats) const;
+
+ void ClearDependencies() const {
+ depfst_.DeleteStates();
+ stats_.clear();
+ depprops_ = 0;
+ depsccprops_.clear();
+ have_stats_ = false;
+ }
+
+ // Gets topological order of dependencies, returning false with cyclic input.
+ bool GetTopOrder(const Fst<Arc> &fst, std::vector<Label> *toporder) const;
+
+ // Updates statistics to reflect the replacement of the jth FST.
+ void UpdateStats(Label j);
+
+ // Computes the properties for the strongly-connected component in the
+ // dependency graph of the replace FSTs.
+ void GetSCCProperties() const;
+
+ Label root_label_; // Root non-terminal.
+ Label root_fst_; // Root FST ID.
+ ReplaceLabelType call_label_type_; // See Replace().
+ ReplaceLabelType return_label_type_; // See Replace().
+ int64 return_label_; // See Replace().
+ std::vector<const Fst<Arc> *> fst_array_; // FST per ID.
+ std::vector<MutableFst<Arc> *> mutable_fst_array_; // Mutable FST per ID.
+ std::vector<Label> nonterminal_array_; // FST ID to non-terminal.
+ NonTerminalHash nonterminal_hash_; // Non-terminal to FST ID.
+ mutable VectorFst<Arc> depfst_; // FST ID dependencies.
+ mutable std::vector<StateId> depscc_; // FST SCC ID.
+ mutable std::vector<bool> depaccess_; // FST ID accessibility.
+ mutable uint64 depprops_; // Dependency FST props.
+ mutable bool have_stats_; // Have dependency statistics?
+ mutable std::vector<ReplaceStats> stats_; // Per-FST statistics.
+ mutable std::vector<uint8> depsccprops_; // SCC properties.
+ ReplaceUtil(const ReplaceUtil &) = delete;
+ ReplaceUtil &operator=(const ReplaceUtil &) = delete;
+};
+
+template <class Arc>
+ReplaceUtil<Arc>::ReplaceUtil(const std::vector<MutableFstPair> &fst_pairs,
+ const ReplaceUtilOptions &opts)
+ : root_label_(opts.root),
+ call_label_type_(opts.call_label_type),
+ return_label_type_(opts.return_label_type),
+ return_label_(opts.return_label),
+ depprops_(0),
+ have_stats_(false) {
+ fst_array_.push_back(nullptr);
+ mutable_fst_array_.push_back(nullptr);
+ nonterminal_array_.push_back(kNoLabel);
+ for (const auto &fst_pair : fst_pairs) {
+ const auto label = fst_pair.first;
+ auto *fst = fst_pair.second;
+ nonterminal_hash_[label] = fst_array_.size();
+ nonterminal_array_.push_back(label);
+ fst_array_.push_back(fst);
+ mutable_fst_array_.push_back(fst);
+ }
+ root_fst_ = nonterminal_hash_[root_label_];
+ if (!root_fst_) {
+ FSTERROR() << "ReplaceUtil: No root FST for label: " << root_label_;
+ }
+}
+
+template <class Arc>
+ReplaceUtil<Arc>::ReplaceUtil(const std::vector<FstPair> &fst_pairs,
+ const ReplaceUtilOptions &opts)
+ : root_label_(opts.root),
+ call_label_type_(opts.call_label_type),
+ return_label_type_(opts.return_label_type),
+ return_label_(opts.return_label),
+ depprops_(0),
+ have_stats_(false) {
+ fst_array_.push_back(nullptr);
+ nonterminal_array_.push_back(kNoLabel);
+ for (const auto &fst_pair : fst_pairs) {
+ const auto label = fst_pair.first;
+ const auto *fst = fst_pair.second;
+ nonterminal_hash_[label] = fst_array_.size();
+ nonterminal_array_.push_back(label);
+ fst_array_.push_back(fst->Copy());
+ }
+ root_fst_ = nonterminal_hash_[root_label_];
+ if (!root_fst_) {
+ FSTERROR() << "ReplaceUtil: No root FST for label: " << root_label_;
+ }
+}
+
+template <class Arc>
+ReplaceUtil<Arc>::ReplaceUtil(
+ const std::vector<std::unique_ptr<const Fst<Arc>>> &fst_array,
+ const NonTerminalHash &nonterminal_hash, const ReplaceUtilOptions &opts)
+ : root_fst_(opts.root),
+ call_label_type_(opts.call_label_type),
+ return_label_type_(opts.return_label_type),
+ return_label_(opts.return_label),
+ nonterminal_array_(fst_array.size()),
+ nonterminal_hash_(nonterminal_hash),
+ depprops_(0),
+ have_stats_(false) {
+ fst_array_.push_back(nullptr);
+ for (size_t i = 1; i < fst_array.size(); ++i) {
+ fst_array_.push_back(fst_array[i]->Copy());
+ }
+ for (auto it = nonterminal_hash.begin(); it != nonterminal_hash.end(); ++it) {
+ nonterminal_array_[it->second] = it->first;
+ }
+ root_label_ = nonterminal_array_[root_fst_];
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::GetDependencies(bool stats) const {
+ if (depfst_.NumStates() > 0) {
+ if (stats && !have_stats_) {
+ ClearDependencies();
+ } else {
+ return;
+ }
+ }
+ have_stats_ = stats;
+ if (have_stats_) stats_.reserve(fst_array_.size());
+ for (Label i = 0; i < fst_array_.size(); ++i) {
+ depfst_.AddState();
+ depfst_.SetFinal(i, Weight::One());
+ if (have_stats_) stats_.push_back(ReplaceStats());
+ }
+ depfst_.SetStart(root_fst_);
+ // An arc from each state (representing the FST) to the state representing the
+ // FST being replaced
+ for (Label i = 0; i < fst_array_.size(); ++i) {
+ const auto *ifst = fst_array_[i];
+ if (!ifst) continue;
+ for (StateIterator<Fst<Arc>> siter(*ifst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ if (have_stats_) {
+ ++stats_[i].nstates;
+ if (ifst->Final(s) != Weight::Zero()) ++stats_[i].nfinal;
+ }
+ for (ArcIterator<Fst<Arc>> aiter(*ifst, s); !aiter.Done();
+ aiter.Next()) {
+ if (have_stats_) ++stats_[i].narcs;
+ const auto &arc = aiter.Value();
+ auto it = nonterminal_hash_.find(arc.olabel);
+ if (it != nonterminal_hash_.end()) {
+ const auto j = it->second;
+ depfst_.AddArc(i, Arc(arc.olabel, arc.olabel, Weight::One(), j));
+ if (have_stats_) {
+ ++stats_[i].nnonterms;
+ ++stats_[j].nref;
+ ++stats_[j].inref[i];
+ ++stats_[i].outref[j];
+ }
+ }
+ }
+ }
+ }
+ // Computes accessibility info.
+ SccVisitor<Arc> scc_visitor(&depscc_, &depaccess_, nullptr, &depprops_);
+ DfsVisit(depfst_, &scc_visitor);
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::UpdateStats(Label j) {
+ if (!have_stats_) {
+ FSTERROR() << "ReplaceUtil::UpdateStats: Stats not available";
+ return;
+ }
+ if (j == root_fst_) return; // Can't replace root.
+ for (auto in = stats_[j].inref.begin(); in != stats_[j].inref.end(); ++in) {
+ const auto i = in->first;
+ const auto ni = in->second;
+ stats_[i].nstates += stats_[j].nstates * ni;
+ stats_[i].narcs += (stats_[j].narcs + 1) * ni;
+ stats_[i].nnonterms += (stats_[j].nnonterms - 1) * ni;
+ stats_[i].outref.erase(j);
+ for (auto out = stats_[j].outref.begin(); out != stats_[j].outref.end();
+ ++out) {
+ const auto k = out->first;
+ const auto nk = out->second;
+ stats_[i].outref[k] += ni * nk;
+ }
+ }
+ for (auto out = stats_[j].outref.begin(); out != stats_[j].outref.end();
+ ++out) {
+ const auto k = out->first;
+ const auto nk = out->second;
+ stats_[k].nref -= nk;
+ stats_[k].inref.erase(j);
+ for (auto in = stats_[j].inref.begin(); in != stats_[j].inref.end(); ++in) {
+ const auto i = in->first;
+ const auto ni = in->second;
+ stats_[k].inref[i] += ni * nk;
+ stats_[k].nref += ni * nk;
+ }
+ }
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::CheckMutableFsts() {
+ if (mutable_fst_array_.empty()) {
+ for (Label i = 0; i < fst_array_.size(); ++i) {
+ if (!fst_array_[i]) {
+ mutable_fst_array_.push_back(nullptr);
+ } else {
+ mutable_fst_array_.push_back(new VectorFst<Arc>(*fst_array_[i]));
+ delete fst_array_[i];
+ fst_array_[i] = mutable_fst_array_[i];
+ }
+ }
+ }
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::Connect() {
+ CheckMutableFsts();
+ static constexpr auto props = kAccessible | kCoAccessible;
+ for (auto *mutable_fst : mutable_fst_array_) {
+ if (!mutable_fst) continue;
+ if (mutable_fst->Properties(props, false) != props) {
+ fst::Connect(mutable_fst);
+ }
+ }
+ GetDependencies(false);
+ for (Label i = 0; i < mutable_fst_array_.size(); ++i) {
+ auto *fst = mutable_fst_array_[i];
+ if (fst && !depaccess_[i]) {
+ delete fst;
+ fst_array_[i] = nullptr;
+ mutable_fst_array_[i] = nullptr;
+ }
+ }
+ ClearDependencies();
+}
+
+template <class Arc>
+bool ReplaceUtil<Arc>::GetTopOrder(const Fst<Arc> &fst,
+ std::vector<Label> *toporder) const {
+ // Finds topological order of dependencies.
+ std::vector<StateId> order;
+ bool acyclic = false;
+ TopOrderVisitor<Arc> top_order_visitor(&order, &acyclic);
+ DfsVisit(fst, &top_order_visitor);
+ if (!acyclic) {
+ LOG(WARNING) << "ReplaceUtil::GetTopOrder: Cyclical label dependencies";
+ return false;
+ }
+ toporder->resize(order.size());
+ for (Label i = 0; i < order.size(); ++i) (*toporder)[order[i]] = i;
+ return true;
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::ReplaceLabels(const std::vector<Label> &labels) {
+ CheckMutableFsts();
+ std::unordered_set<Label> label_set;
+ for (const auto label : labels) {
+ // Can't replace root.
+ if (label != root_label_) label_set.insert(label);
+ }
+ // Finds FST dependencies restricted to the labels requested.
+ GetDependencies(false);
+ VectorFst<Arc> pfst(depfst_);
+ for (StateId i = 0; i < pfst.NumStates(); ++i) {
+ std::vector<Arc> arcs;
+ for (ArcIterator<VectorFst<Arc>> aiter(pfst, i); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto label = nonterminal_array_[arc.nextstate];
+ if (label_set.count(label) > 0) arcs.push_back(arc);
+ }
+ pfst.DeleteArcs(i);
+ for (const auto &arc : arcs) pfst.AddArc(i, arc);
+ }
+ std::vector<Label> toporder;
+ if (!GetTopOrder(pfst, &toporder)) {
+ ClearDependencies();
+ return;
+ }
+ // Visits FSTs in reverse topological order of dependencies and performs
+ // replacements.
+ for (Label o = toporder.size() - 1; o >= 0; --o) {
+ std::vector<FstPair> fst_pairs;
+ auto s = toporder[o];
+ for (ArcIterator<VectorFst<Arc>> aiter(pfst, s); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto label = nonterminal_array_[arc.nextstate];
+ const auto *fst = fst_array_[arc.nextstate];
+ fst_pairs.push_back(std::make_pair(label, fst));
+ }
+ if (fst_pairs.empty()) continue;
+ const auto label = nonterminal_array_[s];
+ const auto *fst = fst_array_[s];
+ fst_pairs.push_back(std::make_pair(label, fst));
+ const ReplaceUtilOptions opts(label, call_label_type_, return_label_type_,
+ return_label_);
+ Replace(fst_pairs, mutable_fst_array_[s], opts);
+ }
+ ClearDependencies();
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::ReplaceBySize(size_t nstates, size_t narcs,
+ size_t nnonterms) {
+ std::vector<Label> labels;
+ GetDependencies(true);
+ std::vector<Label> toporder;
+ if (!GetTopOrder(depfst_, &toporder)) {
+ ClearDependencies();
+ return;
+ }
+ for (Label o = toporder.size() - 1; o >= 0; --o) {
+ const auto j = toporder[o];
+ if (stats_[j].nstates <= nstates && stats_[j].narcs <= narcs &&
+ stats_[j].nnonterms <= nnonterms) {
+ labels.push_back(nonterminal_array_[j]);
+ UpdateStats(j);
+ }
+ }
+ ReplaceLabels(labels);
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::ReplaceByInstances(size_t ninstances) {
+ std::vector<Label> labels;
+ GetDependencies(true);
+ std::vector<Label> toporder;
+ if (!GetTopOrder(depfst_, &toporder)) {
+ ClearDependencies();
+ return;
+ }
+ for (Label o = 0; o < toporder.size(); ++o) {
+ const auto j = toporder[o];
+ if (stats_[j].nref <= ninstances) {
+ labels.push_back(nonterminal_array_[j]);
+ UpdateStats(j);
+ }
+ }
+ ReplaceLabels(labels);
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::GetFstPairs(std::vector<FstPair> *fst_pairs) {
+ CheckMutableFsts();
+ fst_pairs->clear();
+ for (Label i = 0; i < fst_array_.size(); ++i) {
+ const auto label = nonterminal_array_[i];
+ const auto *fst = fst_array_[i];
+ if (!fst) continue;
+ fst_pairs->push_back(std::make_pair(label, fst));
+ }
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::GetMutableFstPairs(
+ std::vector<MutableFstPair> *mutable_fst_pairs) {
+ CheckMutableFsts();
+ mutable_fst_pairs->clear();
+ for (Label i = 0; i < mutable_fst_array_.size(); ++i) {
+ const auto label = nonterminal_array_[i];
+ const auto *fst = mutable_fst_array_[i];
+ if (!fst) continue;
+ mutable_fst_pairs->push_back(std::make_pair(label, fst->Copy()));
+ }
+}
+
+template <class Arc>
+void ReplaceUtil<Arc>::GetSCCProperties() const {
+ if (!depsccprops_.empty()) return;
+ GetDependencies(false);
+ if (depscc_.empty()) return;
+ for (StateId scc = 0; scc < depscc_.size(); ++scc) {
+ depsccprops_.push_back(kReplaceSCCLeftLinear | kReplaceSCCRightLinear);
+ }
+ if (!(depprops_ & kCyclic)) return; // No cyclic dependencies.
+ // Checks for self-loops in the dependency graph.
+ for (StateId scc = 0; scc < depscc_.size(); ++scc) {
+ for (ArcIterator<Fst<Arc> > aiter(depfst_, scc);
+ !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ if (arc.nextstate == scc) { // SCC has a self loop.
+ depsccprops_[scc] |= kReplaceSCCNonTrivial;
+ }
+ }
+ }
+ std::vector<bool> depscc_visited(depscc_.size(), false);
+ for (Label i = 0; i < fst_array_.size(); ++i) {
+ const auto *fst = fst_array_[i];
+ if (!fst) continue;
+ const auto depscc = depscc_[i];
+ if (depscc_visited[depscc]) { // SCC has more than one state.
+ depsccprops_[depscc] |= kReplaceSCCNonTrivial;
+ }
+ depscc_visited[depscc] = true;
+ std::vector<StateId> fstscc; // SCCs of the current FST.
+ uint64 fstprops;
+ SccVisitor<Arc> scc_visitor(&fstscc, nullptr, nullptr, &fstprops);
+ DfsVisit(*fst, &scc_visitor);
+ for (StateIterator<Fst<Arc>> siter(*fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ for (ArcIterator<Fst<Arc>> aiter(*fst, s); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ auto it = nonterminal_hash_.find(arc.olabel);
+ if (it == nonterminal_hash_.end() || depscc_[it->second] != depscc) {
+ continue; // Skips if a terminal or a non-terminal not in SCC.
+ }
+ const bool arc_in_cycle = fstscc[s] == fstscc[arc.nextstate];
+ // Left linear iff all non-terminals are initial.
+ if (s != fst->Start() || arc_in_cycle) {
+ depsccprops_[depscc] &= ~kReplaceSCCLeftLinear;
+ }
+ // Right linear iff all non-terminals are final.
+ if (fst->Final(arc.nextstate) == Weight::Zero() || arc_in_cycle) {
+ depsccprops_[depscc] &= ~kReplaceSCCRightLinear;
+ }
+ }
+ }
+ }
+}
+
+} // namespace fst
+
+#endif // FST_LIB_REPLACE_UTIL_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes for the recursive replacement of FSTs.
+
+#ifndef FST_LIB_REPLACE_H_
+#define FST_LIB_REPLACE_H_
+
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/expanded-fst.h>
+#include <fst/fst-decl.h> // For optional argument declarations.
+#include <fst/fst.h>
+#include <fst/matcher.h>
+#include <fst/replace-util.h>
+#include <fst/state-table.h>
+#include <fst/test-properties.h>
+
+namespace fst {
+
+// Replace state tables have the form:
+//
+// template <class Arc, class P>
+// class ReplaceStateTable {
+// public:
+// using Label = typename Arc::Label Label;
+// using StateId = typename Arc::StateId;
+//
+// using PrefixId = P;
+// using StateTuple = ReplaceStateTuple<StateId, PrefixId>;
+// using StackPrefix = ReplaceStackPrefix<Label, StateId>;
+//
+// // Required constructor.
+// ReplaceStateTable(
+// const std::vector<std::pair<Label, const Fst<Arc> *>> &fst_list,
+// Label root);
+//
+// // Required copy constructor that does not copy state.
+// ReplaceStateTable(const ReplaceStateTable<Arc, PrefixId> &table);
+//
+// // Looks up state ID by tuple, adding it if it doesn't exist.
+// StateId FindState(const StateTuple &tuple);
+//
+// // Looks up state tuple by ID.
+// const StateTuple &Tuple(StateId id) const;
+//
+// // Lookus up prefix ID by stack prefix, adding it if it doesn't exist.
+// PrefixId FindPrefixId(const StackPrefix &stack_prefix);
+//
+// // Looks up stack prefix by ID.
+// const StackPrefix &GetStackPrefix(PrefixId id) const;
+// };
+
+// Tuple that uniquely defines a state in replace.
+template <class S, class P>
+struct ReplaceStateTuple {
+ using StateId = S;
+ using PrefixId = P;
+
+ ReplaceStateTuple(PrefixId prefix_id = -1, StateId fst_id = kNoStateId,
+ StateId fst_state = kNoStateId)
+ : prefix_id(prefix_id), fst_id(fst_id), fst_state(fst_state) {}
+
+ PrefixId prefix_id; // Index in prefix table.
+ StateId fst_id; // Current FST being walked.
+ StateId fst_state; // Current state in FST being walked (not to be
+ // confused with the thse StateId of the combined FST).
+};
+
+// Equality of replace state tuples.
+template <class StateId, class PrefixId>
+inline bool operator==(const ReplaceStateTuple<StateId, PrefixId> &x,
+ const ReplaceStateTuple<StateId, PrefixId> &y) {
+ return x.prefix_id == y.prefix_id && x.fst_id == y.fst_id &&
+ x.fst_state == y.fst_state;
+}
+
+// Functor returning true for tuples corresponding to states in the root FST.
+template <class StateId, class PrefixId>
+class ReplaceRootSelector {
+ public:
+ bool operator()(const ReplaceStateTuple<StateId, PrefixId> &tuple) const {
+ return tuple.prefix_id == 0;
+ }
+};
+
+// Functor for fingerprinting replace state tuples.
+template <class StateId, class PrefixId>
+class ReplaceFingerprint {
+ public:
+ explicit ReplaceFingerprint(const std::vector<uint64> *size_array)
+ : size_array_(size_array) {}
+
+ uint64 operator()(const ReplaceStateTuple<StateId, PrefixId> &tuple) const {
+ return tuple.prefix_id * size_array_->back() +
+ size_array_->at(tuple.fst_id - 1) + tuple.fst_state;
+ }
+
+ private:
+ const std::vector<uint64> *size_array_;
+};
+
+// Useful when the fst_state uniquely define the tuple.
+template <class StateId, class PrefixId>
+class ReplaceFstStateFingerprint {
+ public:
+ uint64 operator()(const ReplaceStateTuple<StateId, PrefixId> &tuple) const {
+ return tuple.fst_state;
+ }
+};
+
+// A generic hash function for replace state tuples.
+template <typename S, typename P>
+class ReplaceHash {
+ public:
+ size_t operator()(const ReplaceStateTuple<S, P>& t) const {
+ static constexpr auto prime0 = 7853;
+ static constexpr auto prime1 = 7867;
+ return t.prefix_id + t.fst_id * prime0 + t.fst_state * prime1;
+ }
+};
+
+// Container for stack prefix.
+template <class Label, class StateId>
+class ReplaceStackPrefix {
+ public:
+ struct PrefixTuple {
+ PrefixTuple(Label fst_id = kNoLabel, StateId nextstate = kNoStateId)
+ : fst_id(fst_id), nextstate(nextstate) {}
+
+ Label fst_id;
+ StateId nextstate;
+ };
+
+ ReplaceStackPrefix() {}
+
+ ReplaceStackPrefix(const ReplaceStackPrefix &other)
+ : prefix_(other.prefix_) {}
+
+ void Push(StateId fst_id, StateId nextstate) {
+ prefix_.push_back(PrefixTuple(fst_id, nextstate));
+ }
+
+ void Pop() { prefix_.pop_back(); }
+
+ const PrefixTuple &Top() const { return prefix_[prefix_.size() - 1]; }
+
+ size_t Depth() const { return prefix_.size(); }
+
+ public:
+ std::vector<PrefixTuple> prefix_;
+};
+
+// Equality stack prefix classes.
+template <class Label, class StateId>
+inline bool operator==(const ReplaceStackPrefix<Label, StateId> &x,
+ const ReplaceStackPrefix<Label, StateId> &y) {
+ if (x.prefix_.size() != y.prefix_.size()) return false;
+ for (size_t i = 0; i < x.prefix_.size(); ++i) {
+ if (x.prefix_[i].fst_id != y.prefix_[i].fst_id ||
+ x.prefix_[i].nextstate != y.prefix_[i].nextstate) {
+ return false;
+ }
+ }
+ return true;
+}
+
+// Hash function for stack prefix to prefix id.
+template <class Label, class StateId>
+class ReplaceStackPrefixHash {
+ public:
+ size_t operator()(const ReplaceStackPrefix<Label, StateId> &prefix) const {
+ size_t sum = 0;
+ for (const auto &pair : prefix.prefix_) {
+ static constexpr auto prime = 7863;
+ sum += pair.fst_id + pair.nextstate * prime;
+ }
+ return sum;
+ }
+};
+
+// Replace state tables.
+
+// A two-level state table for replace. Warning: calls CountStates to compute
+// the number of states of each component FST.
+template <class Arc, class P = ssize_t>
+class VectorHashReplaceStateTable {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+
+ using PrefixId = P;
+
+ using StateTuple = ReplaceStateTuple<StateId, PrefixId>;
+ using StateTable =
+ VectorHashStateTable<ReplaceStateTuple<StateId, PrefixId>,
+ ReplaceRootSelector<StateId, PrefixId>,
+ ReplaceFstStateFingerprint<StateId, PrefixId>,
+ ReplaceFingerprint<StateId, PrefixId>>;
+ using StackPrefix = ReplaceStackPrefix<Label, StateId>;
+ using StackPrefixTable =
+ CompactHashBiTable<PrefixId, StackPrefix,
+ ReplaceStackPrefixHash<Label, StateId>>;
+
+ VectorHashReplaceStateTable(
+ const std::vector<std::pair<Label, const Fst<Arc> *>> &fst_list,
+ Label root)
+ : root_size_(0) {
+ size_array_.push_back(0);
+ for (const auto &fst_pair : fst_list) {
+ if (fst_pair.first == root) {
+ root_size_ = CountStates(*(fst_pair.second));
+ size_array_.push_back(size_array_.back());
+ } else {
+ size_array_.push_back(size_array_.back() +
+ CountStates(*(fst_pair.second)));
+ }
+ }
+ state_table_.reset(
+ new StateTable(new ReplaceRootSelector<StateId, PrefixId>,
+ new ReplaceFstStateFingerprint<StateId, PrefixId>,
+ new ReplaceFingerprint<StateId, PrefixId>(&size_array_),
+ root_size_, root_size_ + size_array_.back()));
+ }
+
+ VectorHashReplaceStateTable(
+ const VectorHashReplaceStateTable<Arc, PrefixId> &table)
+ : root_size_(table.root_size_),
+ size_array_(table.size_array_),
+ prefix_table_(table.prefix_table_) {
+ state_table_.reset(
+ new StateTable(new ReplaceRootSelector<StateId, PrefixId>,
+ new ReplaceFstStateFingerprint<StateId, PrefixId>,
+ new ReplaceFingerprint<StateId, PrefixId>(&size_array_),
+ root_size_, root_size_ + size_array_.back()));
+ }
+
+ StateId FindState(const StateTuple &tuple) {
+ return state_table_->FindState(tuple);
+ }
+
+ const StateTuple &Tuple(StateId id) const { return state_table_->Tuple(id); }
+
+ PrefixId FindPrefixId(const StackPrefix &prefix) {
+ return prefix_table_.FindId(prefix);
+ }
+
+ const StackPrefix& GetStackPrefix(PrefixId id) const {
+ return prefix_table_.FindEntry(id);
+ }
+
+ private:
+ StateId root_size_;
+ std::vector<uint64> size_array_;
+ std::unique_ptr<StateTable> state_table_;
+ StackPrefixTable prefix_table_;
+};
+
+// Default replace state table.
+template <class Arc, class P /* = size_t */>
+class DefaultReplaceStateTable
+ : public CompactHashStateTable<ReplaceStateTuple<typename Arc::StateId, P>,
+ ReplaceHash<typename Arc::StateId, P>> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+
+ using PrefixId = P;
+ using StateTuple = ReplaceStateTuple<StateId, PrefixId>;
+ using StateTable =
+ CompactHashStateTable<StateTuple, ReplaceHash<StateId, PrefixId>>;
+ using StackPrefix = ReplaceStackPrefix<Label, StateId>;
+ using StackPrefixTable =
+ CompactHashBiTable<PrefixId, StackPrefix,
+ ReplaceStackPrefixHash<Label, StateId>>;
+
+ using StateTable::FindState;
+ using StateTable::Tuple;
+
+ DefaultReplaceStateTable(
+ const std::vector<std::pair<Label, const Fst<Arc> *>> &, Label) {}
+
+ DefaultReplaceStateTable(const DefaultReplaceStateTable<Arc, PrefixId> &table)
+ : StateTable(), prefix_table_(table.prefix_table_) {}
+
+ PrefixId FindPrefixId(const StackPrefix &prefix) {
+ return prefix_table_.FindId(prefix);
+ }
+
+ const StackPrefix &GetStackPrefix(PrefixId id) const {
+ return prefix_table_.FindEntry(id);
+ }
+
+ private:
+ StackPrefixTable prefix_table_;
+};
+
+// By default ReplaceFst 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
+template <class Arc, class StateTable = DefaultReplaceStateTable<Arc>,
+ class CacheStore = DefaultCacheStore<Arc>>
+struct ReplaceFstOptions : CacheImplOptions<CacheStore> {
+ using Label = typename Arc::Label;
+
+ // Index of root rule for expansion.
+ Label root;
+ // How to label call arc.
+ ReplaceLabelType call_label_type = REPLACE_LABEL_INPUT;
+ // How to label return arc.
+ ReplaceLabelType return_label_type = REPLACE_LABEL_NEITHER;
+ // Specifies output label to put on call arc; if kNoLabel, use existing label
+ // on call arc. Otherwise, use this field as the output label.
+ Label call_output_label = kNoLabel;
+ // Specifies label to put on return arc.
+ Label return_label = 0;
+ // Take ownership of input FSTs?
+ bool take_ownership = false;
+ // Pointer to optional pre-constructed state table.
+ StateTable *state_table = nullptr;
+
+ explicit ReplaceFstOptions(const CacheImplOptions<CacheStore> &opts,
+ Label root = kNoLabel)
+ : CacheImplOptions<CacheStore>(opts), root(root) {}
+
+ explicit ReplaceFstOptions(const CacheOptions &opts, Label root = kNoLabel)
+ : CacheImplOptions<CacheStore>(opts), root(root) {}
+
+ // FIXME(kbg): There are too many constructors here. Come up with a consistent
+ // position for call_output_label (probably the very end) so that it is
+ // possible to express all the remaining constructors with a single
+ // default-argument constructor. Also move clients off of the "backwards
+ // compatibility" constructor, for good.
+
+ explicit ReplaceFstOptions(Label root) : root(root) {}
+
+ explicit ReplaceFstOptions(Label root, ReplaceLabelType call_label_type,
+ ReplaceLabelType return_label_type,
+ Label return_label)
+ : root(root),
+ call_label_type(call_label_type),
+ return_label_type(return_label_type),
+ return_label(return_label) {}
+
+ explicit ReplaceFstOptions(Label root, ReplaceLabelType call_label_type,
+ ReplaceLabelType return_label_type,
+ Label call_output_label, Label return_label)
+ : root(root),
+ call_label_type(call_label_type),
+ return_label_type(return_label_type),
+ call_output_label(call_output_label),
+ return_label(return_label) {}
+
+ explicit ReplaceFstOptions(const ReplaceUtilOptions &opts)
+ : ReplaceFstOptions(opts.root, opts.call_label_type,
+ opts.return_label_type, opts.return_label) {}
+
+ ReplaceFstOptions() : root(kNoLabel) {}
+
+ // For backwards compatibility.
+ ReplaceFstOptions(int64 root, bool epsilon_replace_arc)
+ : root(root),
+ call_label_type(epsilon_replace_arc ? REPLACE_LABEL_NEITHER
+ : REPLACE_LABEL_INPUT),
+ call_output_label(epsilon_replace_arc ? 0 : kNoLabel) {}
+};
+
+// Forward declaration.
+template <class Arc, class StateTable, class CacheStore>
+class ReplaceFstMatcher;
+
+template <class Arc>
+using FstList = std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>;
+
+// Returns true if label type on arc results in epsilon input label.
+inline bool EpsilonOnInput(ReplaceLabelType label_type) {
+ return label_type == REPLACE_LABEL_NEITHER ||
+ label_type == REPLACE_LABEL_OUTPUT;
+}
+
+// Returns true if label type on arc results in epsilon input label.
+inline bool EpsilonOnOutput(ReplaceLabelType label_type) {
+ return label_type == REPLACE_LABEL_NEITHER ||
+ label_type == REPLACE_LABEL_INPUT;
+}
+
+// Returns true if for either the call or return arc ilabel != olabel.
+template <class Label>
+bool ReplaceTransducer(ReplaceLabelType call_label_type,
+ ReplaceLabelType return_label_type,
+ Label call_output_label) {
+ return call_label_type == REPLACE_LABEL_INPUT ||
+ call_label_type == REPLACE_LABEL_OUTPUT ||
+ (call_label_type == REPLACE_LABEL_BOTH &&
+ call_output_label != kNoLabel) ||
+ return_label_type == REPLACE_LABEL_INPUT ||
+ return_label_type == REPLACE_LABEL_OUTPUT;
+}
+
+template <class Arc>
+uint64 ReplaceFstProperties(typename Arc::Label root_label,
+ const FstList<Arc> &fst_list,
+ ReplaceLabelType call_label_type,
+ ReplaceLabelType return_label_type,
+ typename Arc::Label call_output_label,
+ bool *sorted_and_non_empty) {
+ using Label = typename Arc::Label;
+ std::vector<uint64> inprops;
+ bool all_ilabel_sorted = true;
+ bool all_olabel_sorted = true;
+ bool all_non_empty = true;
+ // All nonterminals are negative?
+ bool all_negative = true;
+ // All nonterminals are positive and form a dense range containing 1?
+ bool dense_range = true;
+ Label root_fst_idx = 0;
+ for (Label i = 0; i < fst_list.size(); ++i) {
+ const auto label = fst_list[i].first;
+ if (label >= 0) all_negative = false;
+ if (label > fst_list.size() || label <= 0) dense_range = false;
+ if (label == root_label) root_fst_idx = i;
+ const auto *fst = fst_list[i].second;
+ if (fst->Start() == kNoStateId) all_non_empty = false;
+ if (!fst->Properties(kILabelSorted, false)) all_ilabel_sorted = false;
+ if (!fst->Properties(kOLabelSorted, false)) all_olabel_sorted = false;
+ inprops.push_back(fst->Properties(kCopyProperties, false));
+ }
+ const auto props = ReplaceProperties(
+ inprops, root_fst_idx, EpsilonOnInput(call_label_type),
+ EpsilonOnInput(return_label_type), EpsilonOnOutput(call_label_type),
+ EpsilonOnOutput(return_label_type),
+ ReplaceTransducer(call_label_type, return_label_type, call_output_label),
+ all_non_empty, all_ilabel_sorted, all_olabel_sorted,
+ all_negative || dense_range);
+ const bool sorted = props & (kILabelSorted | kOLabelSorted);
+ *sorted_and_non_empty = all_non_empty && sorted;
+ return props;
+}
+
+namespace internal {
+
+// The replace implementation class supports a dynamic expansion of a recursive
+// transition network represented as label/FST pairs with dynamic replacable
+// arcs.
+template <class Arc, class StateTable, class CacheStore>
+class ReplaceFstImpl
+ : public CacheBaseImpl<typename CacheStore::State, CacheStore> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using State = typename CacheStore::State;
+ using CacheImpl = CacheBaseImpl<State, CacheStore>;
+ using PrefixId = typename StateTable::PrefixId;
+ using StateTuple = ReplaceStateTuple<StateId, PrefixId>;
+ using StackPrefix = ReplaceStackPrefix<Label, StateId>;
+ using NonTerminalHash = std::unordered_map<Label, Label>;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::WriteHeader;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+ using FstImpl<Arc>::InputSymbols;
+ using FstImpl<Arc>::OutputSymbols;
+
+ using CacheImpl::PushArc;
+ using CacheImpl::HasArcs;
+ using CacheImpl::HasFinal;
+ using CacheImpl::HasStart;
+ using CacheImpl::SetArcs;
+ using CacheImpl::SetFinal;
+ using CacheImpl::SetStart;
+
+ friend class ReplaceFstMatcher<Arc, StateTable, CacheStore>;
+
+ ReplaceFstImpl(const FstList<Arc> &fst_list,
+ const ReplaceFstOptions<Arc, StateTable, CacheStore> &opts)
+ : CacheImpl(opts),
+ call_label_type_(opts.call_label_type),
+ return_label_type_(opts.return_label_type),
+ call_output_label_(opts.call_output_label),
+ return_label_(opts.return_label),
+ state_table_(opts.state_table ? opts.state_table
+ : new StateTable(fst_list, opts.root)) {
+ SetType("replace");
+ // If the label is epsilon, then all replace label options are equivalent,
+ // so we set the label types to NEITHER for simplicity.
+ if (call_output_label_ == 0) call_label_type_ = REPLACE_LABEL_NEITHER;
+ if (return_label_ == 0) return_label_type_ = REPLACE_LABEL_NEITHER;
+ if (!fst_list.empty()) {
+ SetInputSymbols(fst_list[0].second->InputSymbols());
+ SetOutputSymbols(fst_list[0].second->OutputSymbols());
+ }
+ fst_array_.push_back(nullptr);
+ for (Label i = 0; i < fst_list.size(); ++i) {
+ const auto label = fst_list[i].first;
+ const auto *fst = fst_list[i].second;
+ nonterminal_hash_[label] = fst_array_.size();
+ nonterminal_set_.insert(label);
+ fst_array_.emplace_back(opts.take_ownership ? fst : fst->Copy());
+ if (i) {
+ if (!CompatSymbols(InputSymbols(), fst->InputSymbols())) {
+ FSTERROR() << "ReplaceFstImpl: Input symbols of FST " << i
+ << " do not match input symbols of base FST (0th FST)";
+ SetProperties(kError, kError);
+ }
+ if (!CompatSymbols(OutputSymbols(), fst->OutputSymbols())) {
+ FSTERROR() << "ReplaceFstImpl: Output symbols of FST " << i
+ << " do not match output symbols of base FST (0th FST)";
+ SetProperties(kError, kError);
+ }
+ }
+ }
+ const auto nonterminal = nonterminal_hash_[opts.root];
+ if ((nonterminal == 0) && (fst_array_.size() > 1)) {
+ FSTERROR() << "ReplaceFstImpl: No FST corresponding to root label "
+ << opts.root << " in the input tuple vector";
+ SetProperties(kError, kError);
+ }
+ root_ = (nonterminal > 0) ? nonterminal : 1;
+ bool all_non_empty_and_sorted = false;
+ SetProperties(ReplaceFstProperties(opts.root, fst_list, call_label_type_,
+ return_label_type_, call_output_label_,
+ &all_non_empty_and_sorted));
+ // Enables optional caching as long as sorted and all non-empty.
+ always_cache_ = !all_non_empty_and_sorted;
+ VLOG(2) << "ReplaceFstImpl::ReplaceFstImpl: always_cache = "
+ << (always_cache_ ? "true" : "false");
+ }
+
+ ReplaceFstImpl(const ReplaceFstImpl &impl)
+ : CacheImpl(impl),
+ call_label_type_(impl.call_label_type_),
+ return_label_type_(impl.return_label_type_),
+ call_output_label_(impl.call_output_label_),
+ return_label_(impl.return_label_),
+ always_cache_(impl.always_cache_),
+ state_table_(new StateTable(*(impl.state_table_))),
+ nonterminal_set_(impl.nonterminal_set_),
+ nonterminal_hash_(impl.nonterminal_hash_),
+ root_(impl.root_) {
+ SetType("replace");
+ SetProperties(impl.Properties(), kCopyProperties);
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ fst_array_.reserve(impl.fst_array_.size());
+ fst_array_.emplace_back(nullptr);
+ for (Label i = 1; i < impl.fst_array_.size(); ++i) {
+ fst_array_.emplace_back(impl.fst_array_[i]->Copy(true));
+ }
+ }
+
+ // Computes the dependency graph of the replace class and returns
+ // true if the dependencies are cyclic. Cyclic dependencies will result
+ // in an un-expandable FST.
+ bool CyclicDependencies() const {
+ const ReplaceUtilOptions opts(root_);
+ ReplaceUtil<Arc> replace_util(fst_array_, nonterminal_hash_, opts);
+ return replace_util.CyclicDependencies();
+ }
+
+ StateId Start() {
+ if (!HasStart()) {
+ if (fst_array_.size() == 1) {
+ SetStart(kNoStateId);
+ return kNoStateId;
+ } else {
+ const auto fst_start = fst_array_[root_]->Start();
+ if (fst_start == kNoStateId) return kNoStateId;
+ const auto prefix = GetPrefixId(StackPrefix());
+ const auto start =
+ state_table_->FindState(StateTuple(prefix, root_, fst_start));
+ SetStart(start);
+ return start;
+ }
+ } else {
+ return CacheImpl::Start();
+ }
+ }
+
+ Weight Final(StateId s) {
+ if (HasFinal(s)) return CacheImpl::Final(s);
+ const auto &tuple = state_table_->Tuple(s);
+ auto weight = Weight::Zero();
+ if (tuple.prefix_id == 0) {
+ const auto fst_state = tuple.fst_state;
+ weight = fst_array_[tuple.fst_id]->Final(fst_state);
+ }
+ if (always_cache_ || HasArcs(s)) SetFinal(s, weight);
+ return weight;
+ }
+
+ size_t NumArcs(StateId s) {
+ if (HasArcs(s)) {
+ return CacheImpl::NumArcs(s);
+ } else if (always_cache_) { // If always caching, expands and caches state.
+ Expand(s);
+ return CacheImpl::NumArcs(s);
+ } else { // Otherwise computes the number of arcs without expanding.
+ const auto tuple = state_table_->Tuple(s);
+ if (tuple.fst_state == kNoStateId) return 0;
+ auto num_arcs = fst_array_[tuple.fst_id]->NumArcs(tuple.fst_state);
+ if (ComputeFinalArc(tuple, nullptr)) ++num_arcs;
+ return num_arcs;
+ }
+ }
+
+ // Returns whether a given label is a non-terminal.
+ bool IsNonTerminal(Label label) const {
+ if (label < *nonterminal_set_.begin() ||
+ label > *nonterminal_set_.rbegin()) {
+ return false;
+ } else {
+ return nonterminal_hash_.count(label);
+ }
+ // TODO(allauzen): be smarter and take advantage of all_dense or
+ // all_negative. Also use this in ComputeArc. This would require changes to
+ // Replace so that recursing into an empty FST lead to a non co-accessible
+ // state instead of deleting the arc as done currently. The current use
+ // correct, since labels are sorted if all_non_empty is true.
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (HasArcs(s)) {
+ return CacheImpl::NumInputEpsilons(s);
+ } else if (always_cache_ || !Properties(kILabelSorted)) {
+ // If always caching or if the number of input epsilons is too expensive
+ // to compute without caching (i.e., not ilabel-sorted), then expands and
+ // caches state.
+ Expand(s);
+ return CacheImpl::NumInputEpsilons(s);
+ } else {
+ // Otherwise, computes the number of input epsilons without caching.
+ const auto tuple = state_table_->Tuple(s);
+ if (tuple.fst_state == kNoStateId) return 0;
+ size_t num = 0;
+ if (!EpsilonOnInput(call_label_type_)) {
+ // If EpsilonOnInput(c) is false, all input epsilon arcs
+ // are also input epsilons arcs in the underlying machine.
+ num = fst_array_[tuple.fst_id]->NumInputEpsilons(tuple.fst_state);
+ } else {
+ // Otherwise, one need to consider that all non-terminal arcs
+ // in the underlying machine also become input epsilon arc.
+ ArcIterator<Fst<Arc>> aiter(*fst_array_[tuple.fst_id], tuple.fst_state);
+ for (; !aiter.Done() && ((aiter.Value().ilabel == 0) ||
+ IsNonTerminal(aiter.Value().olabel));
+ aiter.Next()) {
+ ++num;
+ }
+ }
+ if (EpsilonOnInput(return_label_type_) &&
+ ComputeFinalArc(tuple, nullptr)) {
+ ++num;
+ }
+ return num;
+ }
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (HasArcs(s)) {
+ return CacheImpl::NumOutputEpsilons(s);
+ } else if (always_cache_ || !Properties(kOLabelSorted)) {
+ // If always caching or if the number of output epsilons is too expensive
+ // to compute without caching (i.e., not olabel-sorted), then expands and
+ // caches state.
+ Expand(s);
+ return CacheImpl::NumOutputEpsilons(s);
+ } else {
+ // Otherwise, computes the number of output epsilons without caching.
+ const auto tuple = state_table_->Tuple(s);
+ if (tuple.fst_state == kNoStateId) return 0;
+ size_t num = 0;
+ if (!EpsilonOnOutput(call_label_type_)) {
+ // If EpsilonOnOutput(c) is false, all output epsilon arcs are also
+ // output epsilons arcs in the underlying machine.
+ num = fst_array_[tuple.fst_id]->NumOutputEpsilons(tuple.fst_state);
+ } else {
+ // Otherwise, one need to consider that all non-terminal arcs in the
+ // underlying machine also become output epsilon arc.
+ ArcIterator<Fst<Arc>> aiter(*fst_array_[tuple.fst_id], tuple.fst_state);
+ for (; !aiter.Done() && ((aiter.Value().olabel == 0) ||
+ IsNonTerminal(aiter.Value().olabel));
+ aiter.Next()) {
+ ++num;
+ }
+ }
+ if (EpsilonOnOutput(return_label_type_) &&
+ ComputeFinalArc(tuple, nullptr)) {
+ ++num;
+ }
+ return num;
+ }
+ }
+
+ 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) {
+ for (Label i = 1; i < fst_array_.size(); ++i) {
+ if (fst_array_[i]->Properties(kError, false)) {
+ SetProperties(kError, kError);
+ }
+ }
+ }
+ return FstImpl<Arc>::Properties(mask);
+ }
+
+ // Returns the base arc iterator, and if arcs have not been computed yet,
+ // extends and recurses for new arcs.
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl::InitArcIterator(s, data);
+ // TODO(allauzen): Set behaviour of generic iterator.
+ // Warning: ArcIterator<ReplaceFst<A>>::InitCache() relies on current
+ // behaviour.
+ }
+
+ // Extends current state (walk arcs one level deep).
+ void Expand(StateId s) {
+ const auto tuple = state_table_->Tuple(s);
+ if (tuple.fst_state == kNoStateId) { // Local FST is empty.
+ SetArcs(s);
+ return;
+ }
+ ArcIterator<Fst<Arc>> aiter(*fst_array_[tuple.fst_id], tuple.fst_state);
+ Arc arc;
+ // Creates a final arc when needed.
+ if (ComputeFinalArc(tuple, &arc)) PushArc(s, arc);
+ // Expands all arcs leaving the state.
+ for (; !aiter.Done(); aiter.Next()) {
+ if (ComputeArc(tuple, aiter.Value(), &arc)) PushArc(s, arc);
+ }
+ SetArcs(s);
+ }
+
+ void Expand(StateId s, const StateTuple &tuple,
+ const ArcIteratorData<Arc> &data) {
+ if (tuple.fst_state == kNoStateId) { // Local FST is empty.
+ SetArcs(s);
+ return;
+ }
+ ArcIterator<Fst<Arc>> aiter(data);
+ Arc arc;
+ // Creates a final arc when needed.
+ if (ComputeFinalArc(tuple, &arc)) AddArc(s, arc);
+ // Expands all arcs leaving the state.
+ for (; !aiter.Done(); aiter.Next()) {
+ if (ComputeArc(tuple, aiter.Value(), &arc)) AddArc(s, arc);
+ }
+ SetArcs(s);
+ }
+
+ // If acpp is null, only returns true if a final arcp is required, but does
+ // not actually compute it.
+ bool ComputeFinalArc(const StateTuple &tuple, Arc *arcp,
+ uint32 flags = kArcValueFlags) {
+ const auto fst_state = tuple.fst_state;
+ if (fst_state == kNoStateId) return false;
+ // If state is final, pops the stack.
+ if (fst_array_[tuple.fst_id]->Final(fst_state) != Weight::Zero() &&
+ tuple.prefix_id) {
+ if (arcp) {
+ arcp->ilabel = (EpsilonOnInput(return_label_type_)) ? 0 : return_label_;
+ arcp->olabel =
+ (EpsilonOnOutput(return_label_type_)) ? 0 : return_label_;
+ if (flags & kArcNextStateValue) {
+ const auto &stack = state_table_->GetStackPrefix(tuple.prefix_id);
+ const auto prefix_id = PopPrefix(stack);
+ const auto &top = stack.Top();
+ arcp->nextstate = state_table_->FindState(
+ StateTuple(prefix_id, top.fst_id, top.nextstate));
+ }
+ if (flags & kArcWeightValue) {
+ arcp->weight = fst_array_[tuple.fst_id]->Final(fst_state);
+ }
+ }
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ // Computes an arc in the FST corresponding to one in the underlying machine.
+ // Returns false if the underlying arc corresponds to no arc in the resulting
+ // FST.
+ bool ComputeArc(const StateTuple &tuple, const Arc &arc, Arc *arcp,
+ uint32 flags = kArcValueFlags) {
+ if (!EpsilonOnInput(call_label_type_) &&
+ (flags == (flags & (kArcILabelValue | kArcWeightValue)))) {
+ *arcp = arc;
+ return true;
+ }
+ if (arc.olabel == 0 || arc.olabel < *nonterminal_set_.begin() ||
+ arc.olabel > *nonterminal_set_.rbegin()) { // Expands local FST.
+ const auto nextstate =
+ flags & kArcNextStateValue
+ ? state_table_->FindState(
+ StateTuple(tuple.prefix_id, tuple.fst_id, arc.nextstate))
+ : kNoStateId;
+ *arcp = Arc(arc.ilabel, arc.olabel, arc.weight, nextstate);
+ } else {
+ // Checks for non-terminal.
+ const auto it = nonterminal_hash_.find(arc.olabel);
+ if (it != nonterminal_hash_.end()) { // Recurses into non-terminal.
+ const auto nonterminal = it->second;
+ const auto nt_prefix =
+ PushPrefix(state_table_->GetStackPrefix(tuple.prefix_id),
+ tuple.fst_id, arc.nextstate);
+ // If the start state is valid, replace; othewise, the arc is implicitly
+ // deleted.
+ const auto nt_start = fst_array_[nonterminal]->Start();
+ if (nt_start != kNoStateId) {
+ const auto nt_nextstate = flags & kArcNextStateValue
+ ? state_table_->FindState(StateTuple(
+ nt_prefix, nonterminal, nt_start))
+ : kNoStateId;
+ const auto ilabel =
+ (EpsilonOnInput(call_label_type_)) ? 0 : arc.ilabel;
+ const auto olabel =
+ (EpsilonOnOutput(call_label_type_))
+ ? 0
+ : ((call_output_label_ == kNoLabel) ? arc.olabel
+ : call_output_label_);
+ *arcp = Arc(ilabel, olabel, arc.weight, nt_nextstate);
+ } else {
+ return false;
+ }
+ } else {
+ const auto nextstate =
+ flags & kArcNextStateValue
+ ? state_table_->FindState(
+ StateTuple(tuple.prefix_id, tuple.fst_id, arc.nextstate))
+ : kNoStateId;
+ *arcp = Arc(arc.ilabel, arc.olabel, arc.weight, nextstate);
+ }
+ }
+ return true;
+ }
+
+ // Returns the arc iterator flags supported by this FST.
+ uint32 ArcIteratorFlags() const {
+ uint32 flags = kArcValueFlags;
+ if (!always_cache_) flags |= kArcNoCache;
+ return flags;
+ }
+
+ StateTable *GetStateTable() const { return state_table_.get(); }
+
+ const Fst<Arc> *GetFst(Label fst_id) const {
+ return fst_array_[fst_id].get();
+ }
+
+ Label GetFstId(Label nonterminal) const {
+ const auto it = nonterminal_hash_.find(nonterminal);
+ if (it == nonterminal_hash_.end()) {
+ FSTERROR() << "ReplaceFstImpl::GetFstId: Nonterminal not found: "
+ << nonterminal;
+ }
+ return it->second;
+ }
+
+ // Returns true if label type on call arc results in epsilon input label.
+ bool EpsilonOnCallInput() { return EpsilonOnInput(call_label_type_); }
+
+ private:
+ // The unique index into stack prefix table.
+ PrefixId GetPrefixId(const StackPrefix &prefix) {
+ return state_table_->FindPrefixId(prefix);
+ }
+
+ // The prefix ID after a stack pop.
+ PrefixId PopPrefix(StackPrefix prefix) {
+ prefix.Pop();
+ return GetPrefixId(prefix);
+ }
+
+ // The prefix ID after a stack push.
+ PrefixId PushPrefix(StackPrefix prefix, Label fst_id, StateId nextstate) {
+ prefix.Push(fst_id, nextstate);
+ return GetPrefixId(prefix);
+ }
+
+ // Runtime options
+ ReplaceLabelType call_label_type_; // How to label call arc.
+ ReplaceLabelType return_label_type_; // How to label return arc.
+ int64 call_output_label_; // Specifies output label to put on call arc
+ int64 return_label_; // Specifies label to put on return arc.
+ bool always_cache_; // Disable optional caching of arc iterator?
+
+ // State table.
+ std::unique_ptr<StateTable> state_table_;
+
+ // Replace components.
+ std::set<Label> nonterminal_set_;
+ NonTerminalHash nonterminal_hash_;
+ std::vector<std::unique_ptr<const Fst<Arc>>> fst_array_;
+ Label root_;
+};
+
+} // namespace internal
+
+//
+// ReplaceFst supports dynamic replacement of arcs in one FST with another FST.
+// This replacement is recursive. ReplaceFst can be used to support a variety of
+// delayed constructions such as recursive
+// transition networks, union, or closure. It is constructed with 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 the ReplaceFst 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 the constructor uses a vector of pairs. These correspond to the
+// tuple of non-terminal Label and corresponding FST. For example to implement
+// the closure operation we need 2 FSTs. The first root FST is a single
+// self-loop arc on the start state.
+//
+// The ReplaceFst class supports an optionally caching arc iterator.
+//
+// The ReplaceFst needs to be built such that it is known to be ilabel- or
+// olabel-sorted (see usage below).
+//
+// Observe that Matcher<Fst<A>> will use the optionally caching arc iterator
+// when available (the FST is ilabel-sorted and matching on the input, or the
+// FST is olabel -orted and matching on the output). In order to obtain the
+// most efficient behaviour, it is recommended to set call_label_type to
+// REPLACE_LABEL_INPUT or REPLACE_LABEL_BOTH and return_label_type to
+// REPLACE_LABEL_OUTPUT or REPLACE_LABEL_NEITHER. This means that the call arc
+// does not have epsilon on the input side and the return arc has epsilon on the
+// input side) and matching on the input side.
+//
+// This class attaches interface to implementation and handles reference
+// counting, delegating most methods to ImplToFst.
+template <class A, class T /* = DefaultReplaceStateTable<A> */,
+ class CacheStore /* = DefaultCacheStore<A> */>
+class ReplaceFst
+ : public ImplToFst<internal::ReplaceFstImpl<A, T, CacheStore>> {
+ 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<Arc, StateTable, CacheStore>;
+ using CacheImpl = internal::CacheBaseImpl<State, CacheStore>;
+
+ using ImplToFst<Impl>::Properties;
+
+ friend class ArcIterator<ReplaceFst<Arc, StateTable, CacheStore>>;
+ friend class StateIterator<ReplaceFst<Arc, StateTable, CacheStore>>;
+ friend class ReplaceFstMatcher<Arc, StateTable, CacheStore>;
+
+ ReplaceFst(const std::vector<std::pair<Label, const Fst<Arc> *>> &fst_array,
+ Label root)
+ : ImplToFst<Impl>(std::make_shared<Impl>(
+ fst_array, ReplaceFstOptions<Arc, StateTable, CacheStore>(root))) {}
+
+ ReplaceFst(const std::vector<std::pair<Label, const Fst<Arc> *>> &fst_array,
+ const ReplaceFstOptions<Arc, StateTable, CacheStore> &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst_array, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ ReplaceFst(const ReplaceFst<Arc, StateTable, CacheStore> &fst,
+ bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this ReplaceFst. See Fst<>::Copy() for further doc.
+ ReplaceFst<Arc, StateTable, CacheStore> *Copy(
+ bool safe = false) const override {
+ return new ReplaceFst<Arc, StateTable, CacheStore>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ MatcherBase<Arc> *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<Arc, StateTable, CacheStore>(*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<Arc> &GetFst(Label nonterminal) const {
+ return *GetImpl()->GetFst(GetImpl()->GetFstId(nonterminal));
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ ReplaceFst &operator=(const ReplaceFst &) = delete;
+};
+
+// Specialization for ReplaceFst.
+template <class Arc, class StateTable, class CacheStore>
+class StateIterator<ReplaceFst<Arc, StateTable, CacheStore>>
+ : public CacheStateIterator<ReplaceFst<Arc, StateTable, CacheStore>> {
+ public:
+ explicit StateIterator(const ReplaceFst<Arc, StateTable, CacheStore> &fst)
+ : CacheStateIterator<ReplaceFst<Arc, StateTable, CacheStore>>(
+ fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for ReplaceFst, implementing optional caching. It is be used
+// as follows:
+//
+// ReplaceFst<A> replace;
+// ArcIterator<ReplaceFst<A>> aiter(replace, s);
+// // Note: ArcIterator< Fst<A>> 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 Arc, class StateTable, class CacheStore>
+class ArcIterator<ReplaceFst<Arc, StateTable, CacheStore>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ using StateTuple = typename StateTable::StateTuple;
+
+ ArcIterator(const ReplaceFst<Arc, StateTable, CacheStore> &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<A>*>::InitArcIterator(s_,
+ // &cache_data_);
+ //
+ fst_.InitArcIterator(s_, &cache_data_); // Expand and cache state.
+ arcs_ = cache_data_.arcs; // arcs_ is a pointer to the cached arcs.
+ data_flags_ = kArcValueFlags; // All the arc member values are valid.
+ offset_ = 0; // No offset.
+ }
+
+ void Init() {
+ if (flags_ & kArcNoCache) { // If caching is disabled
+ // arcs_ is a pointer to the arcs in the underlying machine.
+ arcs_ = local_data_.arcs;
+ // Sets the arcs value flags that hold for arcs_.
+ data_flags_ = kArcWeightValue;
+ if (!fst_.GetMutableImpl()->EpsilonOnCallInput()) {
+ data_flags_ |= kArcILabelValue;
+ }
+ // Sets the offset between the underlying arc positions and the positions
+ // in the arc iterator.
+ offset_ = num_arcs_ - local_data_.narcs;
+ } else {
+ ExpandAndCache();
+ }
+ }
+
+ bool Done() const { return pos_ >= num_arcs_; }
+
+ const Arc &Value() const {
+ // If data_flags_ is 0, non-caching was not requested.
+ if (!data_flags_) {
+ // TODO(allauzen): Revisit this.
+ if (flags_ & kArcNoCache) {
+ // Should never happen.
+ FSTERROR() << "ReplaceFst: Inconsistent arc iterator flags";
+ }
+ ExpandAndCache();
+ }
+ if (pos_ - offset_ >= 0) { // The requested arc is not the final arc.
+ const auto &arc = arcs_[pos_ - offset_];
+ if ((data_flags_ & flags_) == (flags_ & kArcValueFlags)) {
+ // If the value flags match the recquired value flags then returns the
+ // arc.
+ return arc;
+ } else {
+ // Otherwise, compute the corresponding arc on-the-fly.
+ fst_.GetMutableImpl()->ComputeArc(tuple_, arc, &arc_,
+ flags_ & kArcValueFlags);
+ return arc_;
+ }
+ } else { // The requested arc is the final arc.
+ if ((final_flags_ & flags_) != (flags_ & kArcValueFlags)) {
+ // If the arc value flags that hold for the final arc do not match the
+ // requested value flags, then
+ // final_arc_ needs to be updated.
+ fst_.GetMutableImpl()->ComputeFinalArc(tuple_, &final_arc_,
+ flags_ & kArcValueFlags);
+ final_flags_ = flags_ & kArcValueFlags;
+ }
+ return final_arc_;
+ }
+ }
+
+ void Next() { ++pos_; }
+
+ size_t Position() const { return pos_; }
+
+ void Reset() { pos_ = 0; }
+
+ void Seek(size_t pos) { pos_ = pos; }
+
+ uint32 Flags() const { return flags_; }
+
+ void SetFlags(uint32 flags, uint32 mask) {
+ // Updates the flags taking into account what flags are supported
+ // by the FST.
+ flags_ &= ~mask;
+ flags_ |= (flags & fst_.GetImpl()->ArcIteratorFlags());
+ // If non-caching is not requested (and caching has not already been
+ // performed), then flush data_flags_ to request caching during the next
+ // call to Value().
+ if (!(flags_ & kArcNoCache) && data_flags_ != kArcValueFlags) {
+ if (!fst_.GetImpl()->HasArcs(s_)) data_flags_ = 0;
+ }
+ // If data_flags_ has been flushed but non-caching is requested before
+ // calling Value(), then set up the iterator for non-caching.
+ if ((flags & kArcNoCache) && (!data_flags_)) Init();
+ }
+
+ private:
+ const ReplaceFst<Arc, StateTable, CacheStore> &fst_; // Reference to the FST.
+ StateId s_; // State in the FST.
+ mutable StateTuple tuple_; // Tuple corresponding to state_.
+
+ ssize_t pos_; // Current position.
+ mutable ssize_t offset_; // Offset between position in iterator and in arcs_.
+ ssize_t num_arcs_; // Number of arcs at state_.
+ uint32 flags_; // Behavorial flags for the arc iterator
+ mutable Arc arc_; // Memory to temporarily store computed arcs.
+
+ mutable ArcIteratorData<Arc> cache_data_; // Arc iterator data in cache.
+ mutable ArcIteratorData<Arc> local_data_; // Arc iterator data in local FST.
+
+ mutable const Arc *arcs_; // Array of arcs.
+ mutable uint32 data_flags_; // Arc value flags valid for data in arcs_.
+ mutable Arc final_arc_; // Final arc (when required).
+ mutable uint32 final_flags_; // Arc value flags valid for final_arc_.
+
+ ArcIterator(const ArcIterator &) = delete;
+ ArcIterator &operator=(const ArcIterator &) = delete;
+};
+
+template <class Arc, class StateTable, class CacheStore>
+class ReplaceFstMatcher : public MatcherBase<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FST = ReplaceFst<Arc, StateTable, CacheStore>;
+ using LocalMatcher = MultiEpsMatcher<Matcher<Fst<Arc>>>;
+
+ using StateTuple = typename StateTable::StateTuple;
+
+ ReplaceFstMatcher(const ReplaceFst<Arc, StateTable, CacheStore> &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();
+ }
+
+ ReplaceFstMatcher(
+ const ReplaceFstMatcher<Arc, StateTable, CacheStore> &matcher,
+ bool safe = false)
+ : fst_(matcher.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<Arc, StateTable, CacheStore> *Copy(
+ bool safe = false) const override {
+ return new ReplaceFstMatcher<Arc, StateTable, CacheStore>(*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<Arc> &GetFst() const override { return fst_; }
+
+ uint64 Properties(uint64 props) const override { return props; }
+
+ private:
+ // Sets the state from which our matching happens.
+ void SetState_(StateId s) override {
+ 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) override {
+ 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 override {
+ return !current_loop_ && !final_arc_ && current_matcher_->Done();
+ }
+
+ const Arc &Value_() const override {
+ 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_() override {
+ if (current_loop_) {
+ current_loop_ = false;
+ return;
+ }
+ if (final_arc_) {
+ final_arc_ = false;
+ return;
+ }
+ current_matcher_->Next();
+ }
+
+ ssize_t Priority_(StateId s) override { return fst_.NumArcs(s); }
+
+ const ReplaceFst<Arc, StateTable, CacheStore> &fst_;
+ internal::ReplaceFstImpl<Arc, StateTable, CacheStore> *impl_;
+ LocalMatcher *current_matcher_;
+ std::vector<std::unique_ptr<LocalMatcher>> 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 <class Arc, class StateTable, class CacheStore>
+inline void ReplaceFst<Arc, StateTable, CacheStore>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base =
+ new StateIterator<ReplaceFst<Arc, StateTable, CacheStore>>(*this);
+}
+
+using StdReplaceFst = ReplaceFst<StdArc>;
+
+// 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 <class Arc>
+void Replace(const std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>
+ &ifst_array,
+ MutableFst<Arc> *ofst,
+ ReplaceFstOptions<Arc> opts = ReplaceFstOptions<Arc>()) {
+ opts.gc = true;
+ opts.gc_limit = 0; // Caches only the last state for fastest copy.
+ *ofst = ReplaceFst<Arc>(ifst_array, opts);
+}
+
+template <class Arc>
+void Replace(const std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>
+ &ifst_array,
+ MutableFst<Arc> *ofst, const ReplaceUtilOptions &opts) {
+ Replace(ifst_array, ofst, ReplaceFstOptions<Arc>(opts));
+}
+
+// For backwards compatibility.
+template <class Arc>
+void Replace(const std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>
+ &ifst_array,
+ MutableFst<Arc> *ofst, typename Arc::Label root,
+ bool epsilon_on_replace) {
+ Replace(ifst_array, ofst, ReplaceFstOptions<Arc>(root, epsilon_on_replace));
+}
+
+template <class Arc>
+void Replace(const std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>
+ &ifst_array,
+ MutableFst<Arc> *ofst, typename Arc::Label root) {
+ Replace(ifst_array, ofst, ReplaceFstOptions<Arc>(root));
+}
+
+} // namespace fst
+
+#endif // FST_LIB_REPLACE_H_
--- /dev/null
+// 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_LIB_REVERSE_H_
+#define FST_LIB_REVERSE_H_
+
+#include <algorithm>
+#include <vector>
+
+#include <fst/cache.h>
+
+
+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 <class FromArc, class ToArc>
+void Reverse(const Fst<FromArc> &ifst, MutableFst<ToArc> *ofst,
+ bool require_superinitial = true) {
+ using StateId = typename FromArc::StateId;
+ using FromWeight = typename FromArc::Weight;
+ using ToWeight = typename ToArc::Weight;
+ ofst->DeleteStates();
+ ofst->SetInputSymbols(ifst.InputSymbols());
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ if (ifst.Properties(kExpanded, false)) {
+ ofst->ReserveStates(CountStates(ifst) + 1);
+ }
+ StateId istart = ifst.Start();
+ StateId ostart = kNoStateId;
+ StateId offset = 0;
+ uint64 dfs_iprops = 0;
+ uint64 dfs_oprops = 0;
+ if (!require_superinitial) {
+ for (StateIterator<Fst<FromArc>> siter(ifst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ if (ifst.Final(s) == FromWeight::Zero()) continue;
+ if (ostart != kNoStateId) {
+ ostart = kNoStateId;
+ break;
+ } else {
+ ostart = s;
+ }
+ }
+ if (ostart != kNoStateId && ifst.Final(ostart) != FromWeight::One()) {
+ std::vector<StateId> scc;
+ SccVisitor<FromArc> scc_visitor(&scc, nullptr, nullptr, &dfs_iprops);
+ DfsVisit(ifst, &scc_visitor);
+ if (count(scc.begin(), scc.end(), scc[ostart]) > 1) {
+ ostart = kNoStateId;
+ } else {
+ for (ArcIterator<Fst<FromArc>> 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<Fst<FromArc>> siter(ifst); !siter.Done(); siter.Next()) {
+ const auto is = siter.Value();
+ const auto os = is + offset;
+ while (ofst->NumStates() <= os) ofst->AddState();
+ if (is == istart) ofst->SetFinal(os, ToWeight::One());
+ const auto weight = ifst.Final(is);
+ if ((weight != FromWeight::Zero()) && (offset == 1)) {
+ const ToArc oarc(0, 0, weight.Reverse(), os);
+ ofst->AddArc(0, oarc);
+ }
+ for (ArcIterator<Fst<FromArc>> 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_LIB_REVERSE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Function to reweight an FST.
+
+#ifndef FST_LIB_REWEIGHT_H_
+#define FST_LIB_REWEIGHT_H_
+
+#include <vector>
+
+#include <fst/mutable-fst.h>
+
+
+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 <class Arc>
+void Reweight(MutableFst<Arc> *fst,
+ const std::vector<typename Arc::Weight> &potential,
+ ReweightType type) {
+ using Weight = typename Arc::Weight;
+ if (fst->NumStates() == 0) return;
+ // TODO(kbg): Make this a compile-time static_assert once:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this operation for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ 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:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this operation for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ 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<MutableFst<Arc>> 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<MutableFst<Arc>> 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<MutableFst<Arc>> 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_LIB_REWEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes that implemement epsilon-removal.
+
+#ifndef FST_LIB_RMEPSILON_H_
+#define FST_LIB_RMEPSILON_H_
+
+#include <forward_list>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/arcfilter.h>
+#include <fst/cache.h>
+#include <fst/connect.h>
+#include <fst/factor-weight.h>
+#include <fst/invert.h>
+#include <fst/prune.h>
+#include <fst/queue.h>
+#include <fst/shortest-distance.h>
+#include <fst/topsort.h>
+
+
+namespace fst {
+
+template <class Arc, class Queue>
+class RmEpsilonOptions
+ : public ShortestDistanceOptions<Arc, Queue, EpsilonArcFilter<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ bool connect; // Connect output
+ Weight weight_threshold; // Pruning weight threshold.
+ StateId state_threshold; // Pruning state threshold.
+
+ explicit RmEpsilonOptions(Queue *queue, float delta = kDelta,
+ bool connect = true,
+ Weight weight_threshold = Weight::Zero(),
+ StateId state_threshold = kNoStateId)
+ : ShortestDistanceOptions<Arc, Queue, EpsilonArcFilter<Arc>>(
+ queue, EpsilonArcFilter<Arc>(), 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 Arc, class Queue>
+class RmEpsilonState {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ RmEpsilonState(const Fst<Arc> &fst, std::vector<Weight> *distance,
+ const RmEpsilonOptions<Arc, Queue> &opts)
+ : fst_(fst),
+ distance_(distance),
+ sd_state_(fst_, distance, opts, true),
+ expand_id_(0) {}
+
+ void Expand(StateId s);
+
+ std::vector<Arc> &Arcs() { return arcs_; }
+
+ const Weight &Final() const { return final_; }
+
+ bool Error() const { return sd_state_.Error(); }
+
+ private:
+ struct Element {
+ Label ilabel;
+ Label olabel;
+ StateId nextstate;
+
+ Element() {}
+
+ Element(Label ilabel, Label olabel, StateId nexstate)
+ : ilabel(ilabel), olabel(olabel), nextstate(nexstate) {}
+ };
+
+ struct ElementHash {
+ public:
+ size_t operator()(const Element &element) const {
+ static constexpr auto prime0 = 7853;
+ static constexpr auto prime1 = 7867;
+ return element.nextstate + element.ilabel * prime0 +
+ 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<Element, std::pair<StateId, size_t>,
+ ElementHash, ElementEqual>;
+
+ const Fst<Arc> &fst_;
+ // Distance from state being expanded in epsilon-closure.
+ std::vector<Weight> *distance_;
+ // Shortest distance algorithm computation state.
+ internal::ShortestDistanceState<Arc, Queue, EpsilonArcFilter<Arc>> 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<Arc> eps_filter_;
+ std::stack<StateId> eps_queue_; // Queue used to visit the epsilon-closure.
+ std::vector<bool> visited_; // True if the state has been visited.
+ std::forward_list<StateId> visited_states_; // List of visited states.
+ std::vector<Arc> arcs_; // Arcs of state being expanded
+ Weight final_; // Final weight of state being expanded.
+ StateId expand_id_; // Unique ID for each call to Expand
+
+ RmEpsilonState(const RmEpsilonState &) = delete;
+ RmEpsilonState &operator=(const RmEpsilonState &) = delete;
+};
+
+template <class Arc, class Queue>
+void RmEpsilonState<Arc, Queue>::Expand(typename Arc::StateId source) {
+ final_ = Weight::Zero();
+ arcs_.clear();
+ sd_state_.ShortestDistance(source);
+ if (sd_state_.Error()) return;
+ eps_queue_.push(source);
+ while (!eps_queue_.empty()) {
+ const auto state = eps_queue_.top();
+ eps_queue_.pop();
+ while (visited_.size() <= state) visited_.push_back(false);
+ if (visited_[state]) continue;
+ visited_[state] = true;
+ visited_states_.push_front(state);
+ for (ArcIterator<Fst<Arc>> aiter(fst_, state); !aiter.Done();
+ aiter.Next()) {
+ auto arc = aiter.Value();
+ arc.weight = Times((*distance_)[state], arc.weight);
+ if (eps_filter_(arc)) {
+ while (visited_.size() <= arc.nextstate) visited_.push_back(false);
+ if (!visited_[arc.nextstate]) eps_queue_.push(arc.nextstate);
+ } else {
+ const Element element(arc.ilabel, arc.olabel, arc.nextstate);
+ auto insert_result = element_map_.insert(
+ std::make_pair(element, std::make_pair(expand_id_, arcs_.size())));
+ if (insert_result.second) {
+ arcs_.push_back(arc);
+ } else {
+ if (insert_result.first->second.first == expand_id_) {
+ auto &weight = arcs_[insert_result.first->second.second].weight;
+ weight = Plus(weight, arc.weight);
+ } else {
+ insert_result.first->second.first = expand_id_;
+ insert_result.first->second.second = arcs_.size();
+ arcs_.push_back(arc);
+ }
+ }
+ }
+ }
+ final_ = Plus(final_, Times((*distance_)[state], fst_.Final(state)));
+ }
+ while (!visited_states_.empty()) {
+ visited_[visited_states_.front()] = false;
+ visited_states_.pop_front();
+ }
+ ++expand_id_;
+}
+
+} // namespace internal
+
+// Removes epsilon-transitions (when both the input and output label are an
+// epsilon) from a transducer. The result will be an equivalent FST that has no
+// such epsilon transitions. This version modifies its input. It allows fine
+// control via the options argument; see below for a simpler interface.
+//
+// Thei 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 <class Arc, class Queue>
+void RmEpsilon(MutableFst<Arc> *fst,
+ std::vector<typename Arc::Weight> *distance,
+ const RmEpsilonOptions<Arc, Queue> &opts) {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ if (fst->Start() == kNoStateId) return;
+ // noneps_in[s] will be set to true iff s'admits a non-epsilon incoming
+ // transition or is the start state.
+ std::vector<bool> noneps_in(fst->NumStates(), false);
+ noneps_in[fst->Start()] = true;
+ for (auto i = 0; i < fst->NumStates(); ++i) {
+ for (ArcIterator<Fst<Arc>> 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<StateId> states;
+ states.reserve(fst->NumStates());
+ if (fst->Properties(kTopSorted, false) & kTopSorted) {
+ for (auto i = 0; i < fst->NumStates(); i++) states.push_back(i);
+ } else if (fst->Properties(kAcyclic, false) & kAcyclic) {
+ std::vector<StateId> order;
+ bool acyclic;
+ TopOrderVisitor<Arc> top_order_visitor(&order, &acyclic);
+ DfsVisit(*fst, &top_order_visitor, EpsilonArcFilter<Arc>());
+ // 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<StateId> scc;
+ SccVisitor<Arc> scc_visitor(&scc, nullptr, nullptr, &props);
+ DfsVisit(*fst, &scc_visitor, EpsilonArcFilter<Arc>());
+ std::vector<StateId> first(scc.size(), kNoStateId);
+ std::vector<StateId> 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<Arc, Queue> 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 (auto 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 <class Arc>
+void RmEpsilon(MutableFst<Arc> *fst, bool connect = true,
+ typename Arc::Weight weight_threshold = Arc::Weight::Zero(),
+ typename Arc::StateId state_threshold = kNoStateId,
+ float delta = kDelta) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ std::vector<Weight> distance;
+ AutoQueue<StateId> state_queue(*fst, &distance, EpsilonArcFilter<Arc>());
+ RmEpsilonOptions<Arc, AutoQueue<StateId>> 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 = kDelta)
+ : CacheOptions(opts), delta(delta) {}
+
+ explicit RmEpsilonFstOptions(float delta = kDelta) : delta(delta) {}
+};
+
+namespace internal {
+
+// Implementation of delayed RmEpsilonFst.
+template <class Arc>
+class RmEpsilonFstImpl : public CacheImpl<Arc> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+
+ using FstImpl<Arc>::Properties;
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheBaseImpl<CacheState<Arc>>::HasArcs;
+ using CacheBaseImpl<CacheState<Arc>>::HasFinal;
+ using CacheBaseImpl<CacheState<Arc>>::HasStart;
+ using CacheBaseImpl<CacheState<Arc>>::PushArc;
+ using CacheBaseImpl<CacheState<Arc>>::SetArcs;
+ using CacheBaseImpl<CacheState<Arc>>::SetFinal;
+ using CacheBaseImpl<CacheState<Arc>>::SetStart;
+
+ RmEpsilonFstImpl(const Fst<Arc> &fst, const RmEpsilonFstOptions &opts)
+ : CacheImpl<Arc>(opts),
+ fst_(fst.Copy()),
+ delta_(opts.delta),
+ rmeps_state_(
+ *fst_, &distance_,
+ RmEpsilonOptions<Arc, FifoQueue<StateId>>(&queue_, delta_, false)) {
+ SetType("rmepsilon");
+ SetProperties(
+ RmEpsilonProperties(fst.Properties(kFstProperties, false), true),
+ kCopyProperties);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ }
+
+ RmEpsilonFstImpl(const RmEpsilonFstImpl &impl)
+ : CacheImpl<Arc>(impl),
+ fst_(impl.fst_->Copy(true)),
+ delta_(impl.delta_),
+ rmeps_state_(
+ *fst_, &distance_,
+ RmEpsilonOptions<Arc, FifoQueue<StateId>>(&queue_, delta_, false)) {
+ SetType("rmepsilon");
+ SetProperties(impl.Properties(), kCopyProperties);
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ StateId Start() {
+ if (!HasStart()) SetStart(fst_->Start());
+ return CacheImpl<Arc>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) Expand(s);
+ return CacheImpl<Arc>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::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<Arc>::Properties(mask);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<Arc>::InitArcIterator(s, data);
+ }
+
+ void Expand(StateId s) {
+ rmeps_state_.Expand(s);
+ SetFinal(s, rmeps_state_.Final());
+ auto &arcs = rmeps_state_.Arcs();
+ while (!arcs.empty()) {
+ PushArc(s, arcs.back());
+ arcs.pop_back();
+ }
+ SetArcs(s);
+ }
+
+ private:
+ std::unique_ptr<const Fst<Arc>> fst_;
+ float delta_;
+ std::vector<Weight> distance_;
+ FifoQueue<StateId> queue_;
+ internal::RmEpsilonState<Arc, FifoQueue<StateId>> 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 A>
+class RmEpsilonFst : public ImplToFst<internal::RmEpsilonFstImpl<A>> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::RmEpsilonFstImpl<Arc>;
+
+ friend class ArcIterator<RmEpsilonFst<Arc>>;
+ friend class StateIterator<RmEpsilonFst<Arc>>;
+
+ explicit RmEpsilonFst(const Fst<Arc> &fst)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, RmEpsilonFstOptions())) {}
+
+ RmEpsilonFst(const Fst<A> &fst, const RmEpsilonFstOptions &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ RmEpsilonFst(const RmEpsilonFst<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this RmEpsilonFst. See Fst<>::Copy() for further doc.
+ RmEpsilonFst<Arc> *Copy(bool safe = false) const override {
+ return new RmEpsilonFst<Arc>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ RmEpsilonFst &operator=(const RmEpsilonFst &) = delete;
+};
+
+// Specialization for RmEpsilonFst.
+template <class Arc>
+class StateIterator<RmEpsilonFst<Arc>>
+ : public CacheStateIterator<RmEpsilonFst<Arc>> {
+ public:
+ explicit StateIterator(const RmEpsilonFst<Arc> &fst)
+ : CacheStateIterator<RmEpsilonFst<Arc>>(fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for RmEpsilonFst.
+template <class Arc>
+class ArcIterator<RmEpsilonFst<Arc>>
+ : public CacheArcIterator<RmEpsilonFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const RmEpsilonFst<Arc> &fst, StateId s)
+ : CacheArcIterator<RmEpsilonFst<Arc>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class Arc>
+inline void RmEpsilonFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<RmEpsilonFst<Arc>>(*this);
+}
+
+// Useful alias when using StdArc.
+using StdRmEpsilonFst = RmEpsilonFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_RMEPSILON_H_
--- /dev/null
+// 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_LIB_RMFINALEPSILON_H_
+#define FST_LIB_RMFINALEPSILON_H_
+
+#include <unordered_set>
+#include <vector>
+
+#include <fst/connect.h>
+#include <fst/mutable-fst.h>
+
+
+namespace fst {
+
+// Removes final states that have epsilon-only input arcs.
+template <class Arc>
+void RmFinalEpsilon(MutableFst<Arc> *fst) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ // Determines the coaccesibility of states.
+ std::vector<bool> access;
+ std::vector<bool> coaccess;
+ uint64 props = 0;
+ SccVisitor<Arc> 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<StateId> finals;
+ for (StateIterator<Fst<Arc>> siter(*fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ if (fst->Final(s) != Weight::Zero()) {
+ bool future_coaccess = false;
+ for (ArcIterator<Fst<Arc>> 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<Arc> arcs;
+ for (StateIterator<Fst<Arc>> siter(*fst); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ auto weight = fst->Final(s);
+ arcs.clear();
+ for (ArcIterator<Fst<Arc>> 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_LIB_RMFINALEPSILON_H_
--- /dev/null
+// 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 <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+// A struct representing an arc while ignoring arc type. It is passed as an
+// argument to AddArc.
+
+struct ArcClass {
+ template <class Arc>
+ 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 <class Arc>
+ Arc GetArc() const {
+ return Arc(ilabel, olabel, *(weight.GetWeight<typename Arc::Weight>()),
+ nextstate);
+ }
+
+ int64 ilabel;
+ int64 olabel;
+ WeightClass weight;
+ int64 nextstate;
+};
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_ARC_CLASS_H_
--- /dev/null
+// 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 <memory>
+#include <utility>
+
+#include <fst/fstlib.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+// 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<F>.
+class ArcIteratorImplBase {
+ public:
+ virtual bool Done() const = 0;
+ virtual uint32 Flags() const = 0;
+ virtual void Next() = 0;
+ virtual size_t Position() const = 0;
+ virtual void Reset() = 0;
+ virtual void Seek(size_t a) = 0;
+ virtual void SetFlags(uint32 flags, uint32 mask) = 0;
+ virtual ArcClass Value() const = 0;
+ virtual ~ArcIteratorImplBase() {}
+};
+
+// Templated implementation.
+template <class Arc>
+class ArcIteratorClassImpl : public ArcIteratorImplBase {
+ public:
+ explicit ArcIteratorClassImpl(const Fst<Arc> &fst, int64 s)
+ : aiter_(fst, s) {}
+
+ bool Done() const override { return aiter_.Done(); }
+
+ uint32 Flags() const override { return aiter_.Flags(); }
+
+ void Next() override { aiter_.Next(); }
+
+ size_t Position() const override { return aiter_.Position(); }
+
+ void Reset() override { aiter_.Reset(); }
+
+ void Seek(size_t a) override { aiter_.Seek(a); }
+
+ void SetFlags(uint32 flags, uint32 mask) override {
+ 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 override { return ArcClass(aiter_.Value()); }
+
+ ~ArcIteratorClassImpl() override {}
+
+ private:
+ ArcIterator<Fst<Arc>> aiter_;
+};
+
+class ArcIteratorClass;
+
+using InitArcIteratorClassArgs =
+ args::Package<const FstClass &, int64, ArcIteratorClass *>;
+
+// Untemplated user-facing class holding a templated pimpl.
+class ArcIteratorClass {
+ public:
+ ArcIteratorClass(const FstClass &fst, int64 s);
+
+ template <class Arc>
+ ArcIteratorClass(const Fst<Arc> &fst, int64 s)
+ : impl_(new ArcIteratorClassImpl<Arc>(fst, s)) {}
+
+ bool Done() const { return impl_->Done(); }
+
+ uint32 Flags() const { return impl_->Flags(); }
+
+ void Next() { impl_->Next(); }
+
+ size_t Position() const { return impl_->Position(); }
+
+ void Reset() { impl_->Reset(); }
+
+ void Seek(size_t a) { impl_->Seek(a); }
+
+ void SetFlags(uint32 flags, uint32 mask) { impl_->SetFlags(flags, mask); }
+
+ ArcClass Value() const { return impl_->Value(); }
+
+ template <class Arc>
+ friend void InitArcIteratorClass(InitArcIteratorClassArgs *args);
+
+ private:
+ std::unique_ptr<ArcIteratorImplBase> impl_;
+};
+
+template <class Arc>
+void InitArcIteratorClass(InitArcIteratorClassArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ args->arg3->impl_.reset(new ArcIteratorClassImpl<Arc>(fst, args->arg2));
+}
+
+// Mutable arc iterators.
+
+// Virtual interface implemented by each concrete MutableArcIteratorImpl<F>.
+class MutableArcIteratorImplBase : public ArcIteratorImplBase {
+ public:
+ virtual void SetValue(const ArcClass &) = 0;
+ ~MutableArcIteratorImplBase() override {}
+};
+
+// Templated implementation.
+template <class Arc>
+class MutableArcIteratorClassImpl
+ : public MutableArcIteratorImplBase {
+ public:
+ explicit MutableArcIteratorClassImpl(MutableFst<Arc> *fst, int64 s)
+ : aiter_(fst, s) {}
+
+ bool Done() const override { return aiter_.Done(); }
+
+ uint32 Flags() const override { return aiter_.Flags(); }
+
+ void Next() override { aiter_.Next(); }
+
+ size_t Position() const override { return aiter_.Position(); }
+
+ void Reset() override { aiter_.Reset(); }
+
+ void Seek(size_t a) override { aiter_.Seek(a); }
+
+ void SetFlags(uint32 flags, uint32 mask) override {
+ aiter_.SetFlags(flags, mask);
+ }
+
+ void SetValue(const Arc &arc) { aiter_.SetValue(arc); }
+
+ void SetValue(const ArcClass &ac) override {
+ aiter_.SetValue(ac.GetArc<Arc>());
+ }
+
+ // This is returned by value because it has not yet been constructed, and
+ // is likely to participate in return-value optimization.
+ ArcClass Value() const override { return ArcClass(aiter_.Value()); }
+
+ ~MutableArcIteratorClassImpl() override {}
+
+ private:
+ MutableArcIterator<MutableFst<Arc>> aiter_;
+};
+
+class MutableArcIteratorClass;
+
+using InitMutableArcIteratorClassArgs =
+ args::Package<MutableFstClass *, int64, MutableArcIteratorClass *>;
+
+// Untemplated user-facing class holding a templated pimpl.
+class MutableArcIteratorClass {
+ public:
+ MutableArcIteratorClass(MutableFstClass *fst, int64 s);
+
+ template <class Arc>
+ MutableArcIteratorClass(MutableFst<Arc> *fst, int64 s)
+ : impl_(new MutableArcIteratorClassImpl<Arc>(fst, s)) {}
+
+ bool Done() const { return impl_->Done(); }
+
+ uint32 Flags() const { return impl_->Flags(); }
+
+ void Next() { impl_->Next(); }
+
+ size_t Position() const { return impl_->Position(); }
+
+ void Reset() { impl_->Reset(); }
+
+ void Seek(size_t a) { impl_->Seek(a); }
+
+ void SetFlags(uint32 flags, uint32 mask) { impl_->SetFlags(flags, mask); }
+
+ void SetValue(const ArcClass &ac) { impl_->SetValue(ac); }
+
+ ArcClass Value() const { return impl_->Value(); }
+
+ template <class Arc>
+ friend void InitMutableArcIteratorClass(
+ InitMutableArcIteratorClassArgs *args);
+
+ private:
+ std::unique_ptr<MutableArcIteratorImplBase> impl_;
+};
+
+template <class Arc>
+void InitMutableArcIteratorClass(InitMutableArcIteratorClassArgs *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ args->arg3->impl_.reset(new MutableArcIteratorClassImpl<Arc>(fst,
+ args->arg2));
+}
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_ARCITERATOR_CLASS_H_
--- /dev/null
+// 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 <fst/arcsort.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+enum ArcSortType { ILABEL_SORT, OLABEL_SORT };
+
+using ArcSortArgs = args::Package<MutableFstClass *, ArcSortType>;
+
+template <class Arc>
+void ArcSort(ArcSortArgs *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ if (args->arg2 == ILABEL_SORT) {
+ ILabelCompare<Arc> icomp;
+ ArcSort(fst, icomp);
+ } else { // args->arg2 == OLABEL_SORT.
+ OLabelCompare<Arc> ocomp;
+ ArcSort(fst, ocomp);
+ }
+}
+
+void ArcSort(MutableFstClass *ofst, ArcSortType);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_ARCSORT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Convenience templates for defining arg packs for the FstClass operations.
+//
+// See operation-templates.h for a discussion about why these are needed; the
+// short story is that all FstClass operations must be implemented by a version
+// that takes one argument, most likely a struct bundling all the logical
+// arguments together. These template structs provide convenient ways to specify
+// these bundles (e.g., by means of appropriate typedefs).
+//
+// The ArgPack template is sufficient for bundling together all the args for
+// a particular function. The function is assumed to be void-returning. If
+// you want a space for a return value, use the WithReturnValue template
+// as follows:
+//
+// WithReturnValue<bool, ArgPack<...>>
+
+#ifndef FST_SCRIPT_ARG_PACKS_H_
+#define FST_SCRIPT_ARG_PACKS_H_
+
+namespace fst {
+namespace script {
+namespace args {
+
+// Sentinel value that means "no arg here."
+class none_type {};
+
+// Base arg pack template class. Specializations follow that allow
+// fewer numbers of arguments (down to 2). If the maximum number of arguments
+// increases, you will need to change three things:
+//
+// 1) Add more template parameters to this template
+// 2) Add more specializations to allow fewer numbers of parameters than
+// the new max.
+// 3) Add extra none_types to all existing specializations to fill
+// the new slots.
+
+// 9 args (the maximum).
+template <class T1, class T2 = none_type, class T3 = none_type,
+ class T4 = none_type, class T5 = none_type, class T6 = none_type,
+ class T7 = none_type, class T8 = none_type, class T9 = none_type>
+struct Package {
+ T1 arg1;
+ T2 arg2;
+ T3 arg3;
+ T4 arg4;
+ T5 arg5;
+ T6 arg6;
+ T7 arg7;
+ T8 arg8;
+ T9 arg9;
+
+ Package(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7,
+ T8 arg8, T9 arg9)
+ : arg1(arg1),
+ arg2(arg2),
+ arg3(arg3),
+ arg4(arg4),
+ arg5(arg5),
+ arg6(arg6),
+ arg7(arg7),
+ arg8(arg8),
+ arg9(arg9) {}
+};
+
+// 8 args.
+template <class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+ class T8>
+struct Package<T1, T2, T3, T4, T5, T6, T7, T8, none_type> {
+ T1 arg1;
+ T2 arg2;
+ T3 arg3;
+ T4 arg4;
+ T5 arg5;
+ T6 arg6;
+ T7 arg7;
+ T8 arg8;
+
+ Package(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7,
+ T8 arg8)
+ : arg1(arg1),
+ arg2(arg2),
+ arg3(arg3),
+ arg4(arg4),
+ arg5(arg5),
+ arg6(arg6),
+ arg7(arg7),
+ arg8(arg8) {}
+};
+
+// 7 args.
+template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+struct Package<T1, T2, T3, T4, T5, T6, T7, none_type, none_type> {
+ T1 arg1;
+ T2 arg2;
+ T3 arg3;
+ T4 arg4;
+ T5 arg5;
+ T6 arg6;
+ T7 arg7;
+
+ Package(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
+ : arg1(arg1),
+ arg2(arg2),
+ arg3(arg3),
+ arg4(arg4),
+ arg5(arg5),
+ arg6(arg6),
+ arg7(arg7) {}
+};
+
+// 6 args.
+template <class T1, class T2, class T3, class T4, class T5, class T6>
+struct Package<T1, T2, T3, T4, T5, T6, none_type, none_type, none_type> {
+ T1 arg1;
+ T2 arg2;
+ T3 arg3;
+ T4 arg4;
+ T5 arg5;
+ T6 arg6;
+
+ Package(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
+ : arg1(arg1),
+ arg2(arg2),
+ arg3(arg3),
+ arg4(arg4),
+ arg5(arg5),
+ arg6(arg6) {}
+};
+
+// 5 args.
+template <class T1, class T2, class T3, class T4, class T5>
+struct Package<T1, T2, T3, T4, T5, none_type, none_type, none_type, none_type> {
+ T1 arg1;
+ T2 arg2;
+ T3 arg3;
+ T4 arg4;
+ T5 arg5;
+
+ Package(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
+ : arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4), arg5(arg5) {}
+};
+
+// 4 args.
+template <class T1, class T2, class T3, class T4>
+struct Package<T1, T2, T3, T4, none_type, none_type, none_type, none_type,
+ none_type> {
+ T1 arg1;
+ T2 arg2;
+ T3 arg3;
+ T4 arg4;
+
+ Package(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
+ : arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) {}
+};
+
+// 3 args.
+template <class T1, class T2, class T3>
+struct Package<T1, T2, T3, none_type, none_type, none_type, none_type,
+ none_type, none_type> {
+ T1 arg1;
+ T2 arg2;
+ T3 arg3;
+
+ Package(T1 arg1, T2 arg2, T3 arg3) : arg1(arg1), arg2(arg2), arg3(arg3) {}
+};
+
+// 2 args (the minimum).
+template <class T1, class T2>
+struct Package<T1, T2, none_type, none_type, none_type, none_type, none_type,
+ none_type, none_type> {
+ T1 arg1;
+ T2 arg2;
+
+ Package(T1 arg1, T2 arg2) : arg1(arg1), arg2(arg2) {}
+};
+
+// Tack this on to an existing arg pack 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). The
+// alternative is to declare another slew of templates for functions that return
+// a value, analogous to the above.
+
+template <class Retval, class ArgPackage>
+struct WithReturnValue {
+ Retval retval;
+ const ArgPackage &args;
+
+ explicit WithReturnValue(const ArgPackage &args) : args(args) {}
+};
+
+// We don't want to store a reference to a reference, if ArgPackage is already
+// some reference type.
+template <class Retval, class ArgPackage>
+struct WithReturnValue<Retval, ArgPackage &> {
+ Retval retval;
+ const ArgPackage &args;
+
+ explicit WithReturnValue(const ArgPackage &args) : args(args) {}
+};
+
+} // namespace args
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_ARG_PACKS_H_
--- /dev/null
+// 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 <fst/closure.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using ClosureArgs = args::Package<MutableFstClass *, const ClosureType>;
+
+template <class Arc>
+void Closure(ClosureArgs *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ Closure(fst, args->arg2);
+}
+
+void Closure(MutableFstClass *ofst, ClosureType closure_type);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_CLOSURE_H_
--- /dev/null
+// 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 <iostream>
+#include <sstream>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include <fst/fst.h>
+#include <fst/util.h>
+#include <fst/vector-fst.h>
+
+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 Arc>
+class FstCompiler {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ // WARNING: use of negative labels not recommended as it may cause conflicts.
+ // If add_symbols_ is true, then the symbols will be dynamically added to the
+ // symbol tables. This is only useful if you set the (i/o)keep flag to attach
+ // the final symbol table, or use the accessors. (The input symbol tables are
+ // const and therefore not changed.)
+ FstCompiler(std::istream &istrm, const string &source, // NOLINT
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ const SymbolTable *ssyms, bool accep, bool ikeep,
+ bool okeep, bool nkeep, bool allow_negative_labels = false) {
+ std::unique_ptr<SymbolTable> misyms(isyms ? isyms->Copy() : nullptr);
+ std::unique_ptr<SymbolTable> mosyms(osyms ? osyms->Copy() : nullptr);
+ std::unique_ptr<SymbolTable> mssyms(ssyms ? ssyms->Copy() : nullptr);
+ Init(istrm, source, misyms.get(), mosyms.get(), mssyms.get(), accep,
+ ikeep, okeep, nkeep, allow_negative_labels, false);
+ }
+
+ FstCompiler(std::istream &istrm, const string &source, // NOLINT
+ SymbolTable *isyms, SymbolTable *osyms, SymbolTable *ssyms,
+ bool accep, bool ikeep, bool okeep, bool nkeep,
+ bool allow_negative_labels, bool add_symbols) {
+ Init(istrm, source, isyms, osyms, ssyms, accep, ikeep, okeep, nkeep,
+ allow_negative_labels, add_symbols);
+ }
+
+ void Init(std::istream &istrm, const string &source, // NOLINT
+ SymbolTable *isyms, SymbolTable *osyms, SymbolTable *ssyms,
+ bool accep, bool ikeep, bool okeep, bool nkeep,
+ bool allow_negative_labels, bool add_symbols) {
+ nline_ = 0;
+ source_ = source;
+ isyms_ = isyms;
+ osyms_ = osyms;
+ ssyms_ = ssyms;
+ nstates_ = 0;
+ keep_state_numbering_ = nkeep;
+ allow_negative_labels_ = allow_negative_labels;
+ add_symbols_ = add_symbols;
+ bool start_state_populated = false;
+ char line[kLineLen];
+ const string separator = FLAGS_fst_field_separator + "\n";
+ while (istrm.getline(line, kLineLen)) {
+ ++nline_;
+ std::vector<char *> col;
+ SplitToVector(line, separator.c_str(), &col, true);
+ if (col.size() == 0 || col[0][0] == '\0') // empty line
+ 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<Arc> &Fst() const { return fst_; }
+
+ private:
+ // Maximum line length in text file.
+ static constexpr int kLineLen = 8096;
+
+ StateId StrToId(const char *s, SymbolTable *syms, const char *name,
+ bool allow_negative = false) const {
+ StateId n = 0;
+ if (syms) {
+ n = (add_symbols_) ? syms->AddSymbol(s) : syms->Find(s);
+ if (n == -1 || (!allow_negative && n < 0)) {
+ FSTERROR() << "FstCompiler: Symbol \"" << s
+ << "\" is not mapped to any integer " << name
+ << ", symbol table = " << syms->Name()
+ << ", source = " << source_ << ", line = " << nline_;
+ fst_.SetProperties(kError, kError);
+ }
+ } else {
+ char *p;
+ n = strtoll(s, &p, 10);
+ if (p < s + strlen(s) || (!allow_negative && n < 0)) {
+ FSTERROR() << "FstCompiler: Bad " << name << " integer = \"" << s
+ << "\", source = " << source_ << ", line = " << nline_;
+ fst_.SetProperties(kError, kError);
+ }
+ }
+ return n;
+ }
+
+ StateId StrToStateId(const char *s) {
+ StateId n = StrToId(s, ssyms_, "state ID");
+ if (keep_state_numbering_) return n;
+ // Remaps state IDs to make dense set.
+ const auto it = states_.find(n);
+ if (it == states_.end()) {
+ states_[n] = nstates_;
+ return nstates_++;
+ } else {
+ return it->second;
+ }
+ }
+
+ StateId StrToILabel(const char *s) const {
+ return StrToId(s, isyms_, "arc ilabel", allow_negative_labels_);
+ }
+
+ StateId StrToOLabel(const char *s) const {
+ return StrToId(s, osyms_, "arc olabel", allow_negative_labels_);
+ }
+
+ Weight StrToWeight(const char *s, bool allow_zero) const {
+ Weight w;
+ std::istringstream strm(s);
+ strm >> w;
+ if (!strm || (!allow_zero && w == Weight::Zero())) {
+ FSTERROR() << "FstCompiler: Bad weight = \"" << s
+ << "\", source = " << source_ << ", line = " << nline_;
+ fst_.SetProperties(kError, kError);
+ w = Weight::NoWeight();
+ }
+ return w;
+ }
+
+ mutable VectorFst<Arc> fst_;
+ size_t nline_;
+ string source_; // Text FST source name.
+ SymbolTable *isyms_; // ilabel symbol table (not owned).
+ SymbolTable *osyms_; // olabel symbol table (not owned).
+ SymbolTable *ssyms_; // slabel symbol table (not owned).
+ std::unordered_map<StateId, StateId> 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_
--- /dev/null
+// 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 <istream>
+
+#include <fst/script/arg-packs.h>
+#include <fst/script/compile-impl.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+// This operation exists in two forms. 1 is a void operation which writes the
+// compiled machine to disk; 2 returns an FstClass. I/O should normally be done
+// using the binary format for efficiency, so users are STRONGLY ENCOURAGED to
+// use 1 or to construct FSTs using the C++ FST mutation operations.
+
+// Note: it is safe to pass these strings as references because
+// this struct is only used to pass them deeper in the call graph.
+// Be sure you understand why this is so before using this struct
+// for anything else!
+struct CompileFstInnerArgs {
+ std::istream &istrm;
+ const string &source;
+ const string &fst_type;
+ const fst::SymbolTable *isyms;
+ const fst::SymbolTable *osyms;
+ const fst::SymbolTable *ssyms;
+ const bool accep;
+ const bool ikeep;
+ const bool okeep;
+ const bool nkeep;
+ const bool allow_negative_labels;
+
+ CompileFstInnerArgs(std::istream &istrm, const string &source,
+ const string &fst_type, const fst::SymbolTable *isyms,
+ const fst::SymbolTable *osyms,
+ const fst::SymbolTable *ssyms, bool accep, bool ikeep,
+ bool okeep, bool nkeep,
+ bool allow_negative_labels = false)
+ : istrm(istrm),
+ source(source),
+ fst_type(fst_type),
+ isyms(isyms),
+ osyms(osyms),
+ ssyms(ssyms),
+ accep(accep),
+ ikeep(ikeep),
+ okeep(okeep),
+ nkeep(nkeep),
+ allow_negative_labels(allow_negative_labels) {}
+};
+
+// 1
+using CompileFstArgs = args::WithReturnValue<FstClass *, CompileFstInnerArgs>;
+
+// 2
+template <class Arc>
+void CompileFstInternal(CompileFstArgs *args) {
+ using fst::Convert;
+ using fst::Fst;
+ using fst::FstCompiler;
+ FstCompiler<Arc> 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<Arc> *fst = &fstcompiler.Fst();
+ if (args->args.fst_type != "vector") {
+ fst = Convert<Arc>(*fst, args->args.fst_type);
+ if (!fst) {
+ FSTERROR() << "Failed to convert FST to desired type: "
+ << args->args.fst_type;
+ }
+ }
+ args->retval = fst ? new FstClass(*fst) : nullptr;
+}
+
+// 1
+void CompileFst(std::istream &istrm, const string &source, const string &dest,
+ const string &fst_type, const string &arc_type,
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ const SymbolTable *ssyms, bool accep, bool ikeep, bool okeep,
+ bool nkeep, bool allow_negative_labels);
+
+// 2
+FstClass *CompileFstInternal(std::istream &istrm, const string &source,
+ const string &fst_type, const string &arc_type,
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ const SymbolTable *ssyms, bool accep, bool ikeep,
+ bool okeep, bool nkeep,
+ bool allow_negative_labels);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_COMPILE_H_
--- /dev/null
+// 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 <fst/compose.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using ComposeArgs1 = args::Package<const FstClass &, const FstClass &,
+ MutableFstClass *, ComposeFilter>;
+
+template <class Arc>
+void Compose(ComposeArgs1 *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ Compose(ifst1, ifst2, ofst, ComposeOptions(args->arg4));
+}
+
+using ComposeOptions = fst::ComposeOptions;
+
+using ComposeArgs2 = args::Package<const FstClass &, const FstClass &,
+ MutableFstClass *, const ComposeOptions &>;
+
+template <class Arc>
+void Compose(ComposeArgs2 *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ Compose(ifst1, ifst2, ofst, args->arg4);
+}
+
+void Compose(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst,
+ const ComposeOptions &opts = fst::script::ComposeOptions());
+
+void Compose(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, ComposeFilter compose_filter);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_COMPOSE_H_
--- /dev/null
+// 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 <fst/concat.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using ConcatArgs1 = args::Package<MutableFstClass *, const FstClass &>;
+
+template <class Arc>
+void Concat(ConcatArgs1 *args) {
+ MutableFst<Arc> *ofst = args->arg1->GetMutableFst<Arc>();
+ const Fst<Arc> &ifst = *(args->arg2.GetFst<Arc>());
+ Concat(ofst, ifst);
+}
+
+using ConcatArgs2 = args::Package<const FstClass &, MutableFstClass *>;
+
+template <class Arc>
+void Concat(ConcatArgs2 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ Concat(ifst, ofst);
+}
+
+void Concat(MutableFstClass *ofst, const FstClass &ifst);
+
+void Concat(const FstClass &ifst, MutableFstClass *ofst);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_CONCAT_H_
--- /dev/null
+// 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 <fst/connect.h>
+#include <fst/dfs-visit.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+template <class Arc>
+void Connect(MutableFstClass *fst) {
+ MutableFst<Arc> *typed_fst = fst->GetMutableFst<Arc>();
+ Connect(typed_fst);
+}
+
+void Connect(MutableFstClass *fst);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_CONNECT_H_
--- /dev/null
+// 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 <memory>
+#include <string>
+
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using ConvertInnerArgs = args::Package<const FstClass &, const string &>;
+
+using ConvertArgs = args::WithReturnValue<FstClass *, ConvertInnerArgs>;
+
+template <class Arc>
+void Convert(ConvertArgs *args) {
+ const Fst<Arc> &fst = *(args->args.arg1.GetFst<Arc>());
+ const string &new_type = args->args.arg2;
+ std::unique_ptr<Fst<Arc>> result(Convert(fst, new_type));
+ args->retval = result ? new FstClass(*result) : nullptr;
+}
+
+FstClass *Convert(const FstClass &f, const string &new_type);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_CONVERT_H_
--- /dev/null
+// 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 <memory>
+#include <string>
+
+#include <fst/encode.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/encodemapper-class.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+// 1: Decode using encoder on disk.
+using DecodeArgs1 = args::Package<MutableFstClass *, const string &>;
+
+template <class Arc>
+void Decode(DecodeArgs1 *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ std::unique_ptr<EncodeMapper<Arc>> decoder(EncodeMapper<Arc>::Read(args->arg2,
+ DECODE));
+ if (!decoder) {
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ Decode(fst, *decoder);
+}
+
+void Decode(MutableFstClass *fst, const string &coder_fname);
+
+// 2: Decode using an EncodeMapperClass.
+using DecodeArgs2 = args::Package<MutableFstClass *, const EncodeMapperClass &>;
+
+template <class Arc>
+void Decode(DecodeArgs2 *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ const EncodeMapper<Arc> &encoder = *(args->arg2.GetEncodeMapper<Arc>());
+ Decode(fst, encoder);
+}
+
+void Decode(MutableFstClass *fst, const EncodeMapperClass &encoder);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_DECODE_H_
--- /dev/null
+// 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 <fst/determinize.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+// 1: Full signature with DeterminizeOptions.
+struct DeterminizeOptions {
+ float delta;
+ const WeightClass &weight_threshold;
+ int64 state_threshold;
+ int64 subsequential_label;
+ DeterminizeType type;
+ bool increment_subsequential_label;
+
+ DeterminizeOptions(float d, const WeightClass &w,
+ int64 n = fst::kNoStateId, int64 l = 0,
+ DeterminizeType t = DETERMINIZE_FUNCTIONAL, bool i = false)
+ : delta(d),
+ weight_threshold(w),
+ state_threshold(n),
+ subsequential_label(l),
+ type(t),
+ increment_subsequential_label(i) {}
+};
+
+using DeterminizeArgs1 = args::Package<const FstClass &, MutableFstClass *,
+ const DeterminizeOptions &>;
+
+template <class Arc>
+void Determinize(DeterminizeArgs1 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ const DeterminizeOptions &opts = args->arg3;
+ typename Arc::Weight weight_threshold =
+ *(opts.weight_threshold.GetWeight<typename Arc::Weight>());
+ fst::DeterminizeOptions<Arc> detargs(
+ opts.delta, weight_threshold, opts.state_threshold,
+ opts.subsequential_label, opts.type, opts.increment_subsequential_label);
+ Determinize(ifst, ofst, detargs);
+}
+
+// 2: Signature with default WeightClass argument.
+using DeterminizeArgs2 =
+ args::Package<const FstClass &, MutableFstClass *, float, int64, int64,
+ DeterminizeType, bool>;
+
+template <class Arc>
+void Determinize(DeterminizeArgs2 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ typename Arc::Weight weight_threshold = Arc::Weight::Zero();
+ fst::DeterminizeOptions<Arc> detargs(args->arg3, weight_threshold,
+ args->arg4, args->arg5, args->arg6,
+ args->arg7);
+ Determinize(ifst, ofst, detargs);
+}
+
+// 1
+void Determinize(const FstClass &ifst, MutableFstClass *ofst,
+ const DeterminizeOptions &opts);
+
+// 2
+void Determinize(const FstClass &ifst, MutableFstClass *ofst,
+ float d = fst::kDelta, int64 n = fst::kNoStateId,
+ int64 l = 0, DeterminizeType t = DETERMINIZE_FUNCTIONAL,
+ bool i = false);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_DETERMINIZE_H_
--- /dev/null
+// 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 <fst/difference.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/compose.h> // for ComposeFilter
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using DifferenceArgs1 = args::Package<const FstClass &, const FstClass &,
+ MutableFstClass *, ComposeFilter>;
+
+template <class Arc>
+void Difference(DifferenceArgs1 *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ Difference(ifst1, ifst2, ofst, ComposeOptions(args->arg4));
+}
+
+using DifferenceArgs2 =
+ args::Package<const FstClass &, const FstClass &, MutableFstClass *,
+ const ComposeOptions &>;
+
+template <class Arc>
+void Difference(DifferenceArgs2 *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ Difference(ifst1, ifst2, ofst, ComposeOptions(args->arg4));
+}
+
+void Difference(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, ComposeFilter compose_filter);
+
+void Difference(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst,
+ const ComposeOptions &opts = fst::script::ComposeOptions());
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_DIFFERENCE_H_
--- /dev/null
+// 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 <fst/disambiguate.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+// 1: Full signature.
+struct DisambiguateOptions {
+ float delta;
+ const WeightClass &weight_threshold;
+ int64 state_threshold;
+ int64 subsequential_label;
+
+ DisambiguateOptions(float d, const WeightClass &w,
+ int64 n = fst::kNoStateId, int64 l = 0)
+ : delta(d), weight_threshold(w), state_threshold(n),
+ subsequential_label(l) {}
+};
+
+using DisambiguateArgs1 = args::Package<const FstClass &, MutableFstClass *,
+ const DisambiguateOptions &>;
+
+template <class Arc>
+void Disambiguate(DisambiguateArgs1 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ const DisambiguateOptions &opts = args->arg3;
+ typename Arc::Weight weight_threshold =
+ *(opts.weight_threshold.GetWeight<typename Arc::Weight>());
+ fst::DisambiguateOptions<Arc> disargs(opts.delta, weight_threshold,
+ opts.state_threshold,
+ opts.subsequential_label);
+ Disambiguate(ifst, ofst, disargs);
+}
+
+// 2: Signature with default WeightClass argument.
+using DisambiguateArgs2 =
+ args::Package<const FstClass &, MutableFstClass *, int64, int64>;
+
+template <class Arc>
+void Disambiguate(DisambiguateArgs2 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ typename Arc::Weight weight_threshold = Arc::Weight::Zero();
+ fst::DisambiguateOptions<Arc> disargs(kDelta, weight_threshold,
+ args->arg3, args->arg4);
+ Disambiguate(ifst, ofst, disargs);
+}
+
+// 1
+void Disambiguate(const FstClass &ifst, MutableFstClass *ofst,
+ const DisambiguateOptions &opts);
+
+// 2
+void Disambiguate(const FstClass &, MutableFstClass *ofst,
+ int64 n = fst::kNoStateId, int64 l = 0);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_DISAMBIGUATE_H_
--- /dev/null
+// 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 <ostream>
+#include <sstream>
+#include <string>
+
+#include <fst/fst.h>
+#include <fst/util.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+
+// Print a binary FST in GraphViz textual format (helper class for fstdraw.cc).
+// WARNING: Stand-alone use not recommend.
+template <class Arc>
+class FstDrawer {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ FstDrawer(const Fst<Arc> &fst, const SymbolTable *isyms,
+ const SymbolTable *osyms, const SymbolTable *ssyms, bool accep,
+ const string &title, float width, float height, bool portrait,
+ bool vertical, float ranksep, float nodesep, int fontsize,
+ int precision, 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),
+ show_weight_one_(show_weight_one) {}
+
+ // Draw Fst to an output buffer (or stdout if buf = 0)
+ void Draw(std::ostream *strm, const string &dest) {
+ ostrm_ = strm;
+ ostrm_->precision(precision_);
+ dest_ = dest;
+ StateId start = fst_.Start();
+ if (start == kNoStateId) return;
+ PrintString("digraph FST {\n");
+ if (vertical_) {
+ PrintString("rankdir = BT;\n");
+ } else {
+ PrintString("rankdir = LR;\n");
+ }
+ PrintString("size = \"");
+ Print(width_);
+ PrintString(",");
+ Print(height_);
+ PrintString("\";\n");
+ if (!dest_.empty()) PrintString("label = \"" + title_ + "\";\n");
+ PrintString("center = 1;\n");
+ if (portrait_) {
+ PrintString("orientation = Portrait;\n");
+ } else {
+ PrintString("orientation = Landscape;\n");
+ }
+ PrintString("ranksep = \"");
+ Print(ranksep_);
+ PrintString("\";\n");
+ PrintString("nodesep = \"");
+ Print(nodesep_);
+ PrintString("\";\n");
+ // Initial state first.
+ DrawState(start);
+ for (StateIterator<Fst<Arc>> siter(fst_); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ if (s != start) DrawState(s);
+ }
+ PrintString("}\n");
+ }
+
+ private:
+ // Maximum line length in text file.
+ static const int kLineLen = 8096;
+
+ void PrintString(const string &str) const { *ostrm_ << str; }
+
+ // Escapes backslash and double quote if these occur in the string. Dot will
+ // not deal gracefully with these if they are not escaped.
+ inline void EscapeChars(const string &str, string *ns) const {
+ const char *c = str.c_str();
+ while (*c) {
+ if (*c == '\\' || *c == '"') ns->push_back('\\');
+ ns->push_back(*c);
+ ++c;
+ }
+ }
+
+ void PrintId(StateId id, const SymbolTable *syms, const char *name) const {
+ if (syms) {
+ auto symbol = syms->Find(id);
+ if (symbol == "") {
+ FSTERROR() << "FstDrawer: Integer " << id
+ << " is not mapped to any textual symbol"
+ << ", symbol table = " << syms->Name()
+ << ", destination = " << dest_;
+ symbol = "?";
+ }
+ string nsymbol;
+ EscapeChars(symbol, &nsymbol);
+ PrintString(nsymbol);
+ } else {
+ string idstr;
+ Int64ToStr(id, &idstr);
+ PrintString(idstr);
+ }
+ }
+
+ 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");
+ }
+
+ template <class T>
+ void Print(T t) const { *ostrm_ << t; }
+
+ 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("/");
+ Print(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<Fst<Arc>> 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("/");
+ Print(arc.weight);
+ }
+ PrintString("\", fontsize = ");
+ Print(fontsize_);
+ PrintString("];\n");
+ }
+ }
+
+ const Fst<Arc> &fst_;
+ const SymbolTable *isyms_; // ilabel symbol table.
+ const SymbolTable *osyms_; // olabel symbol table.
+ const SymbolTable *ssyms_; // slabel symbol table.
+ bool accep_; // Print as acceptor when possible.
+ std::ostream *ostrm_; // Drawn FST destination.
+ string dest_; // Drawn FST destination name.
+
+ string title_;
+ float width_;
+ float height_;
+ bool portrait_;
+ bool vertical_;
+ float ranksep_;
+ float nodesep_;
+ int fontsize_;
+ int precision_;
+ bool show_weight_one_;
+
+ FstDrawer(const FstDrawer &) = delete;
+ FstDrawer &operator=(const FstDrawer &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_SCRIPT_DRAW_IMPL_H_
--- /dev/null
+// 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 <ostream>
+
+#include <fst/script/arg-packs.h>
+#include <fst/script/draw-impl.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+// Note: it is safe to pass these strings as references because
+// this struct is only used to pass them deeper in the call graph.
+// Be sure you understand why this is so before using this struct
+// for anything else!
+struct FstDrawerArgs {
+ const FstClass &fst;
+ const SymbolTable *isyms;
+ const SymbolTable *osyms;
+ const SymbolTable *ssyms;
+ const bool accep;
+ const string &title;
+ const float width;
+ const float height;
+ const bool portrait;
+ const bool vertical;
+ const float ranksep;
+ const float nodesep;
+ const int fontsize;
+ const int precision;
+ const bool show_weight_one;
+ std::ostream *ostrm;
+ const string &dest;
+
+ FstDrawerArgs(const FstClass &fst, const SymbolTable *isyms,
+ const SymbolTable *osyms, const SymbolTable *ssyms, bool accep,
+ const string &title, float width, float height, bool portrait,
+ bool vertical, float ranksep, float nodesep, int fontsize,
+ int precision, bool show_weight_one, std::ostream *ostrm,
+ const string &dest)
+ : fst(fst),
+ isyms(isyms),
+ osyms(osyms),
+ ssyms(ssyms),
+ accep(accep),
+ title(title),
+ width(width),
+ height(height),
+ portrait(portrait),
+ vertical(vertical),
+ ranksep(ranksep),
+ nodesep(nodesep),
+ fontsize(fontsize),
+ precision(precision),
+ show_weight_one(show_weight_one),
+ ostrm(ostrm),
+ dest(dest) {}
+};
+
+template <class Arc>
+void DrawFst(FstDrawerArgs *args) {
+ const Fst<Arc> &fst = *(args->fst.GetFst<Arc>());
+ FstDrawer<Arc> 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->show_weight_one);
+ fstdrawer.Draw(args->ostrm, args->dest);
+}
+
+void DrawFst(const FstClass &fst, const SymbolTable *isyms,
+ const SymbolTable *osyms, const SymbolTable *ssyms, bool accep,
+ const string &title, float width, float height, bool portrait,
+ bool vertical, float ranksep, float nodesep, int fontsize,
+ int precision, bool show_weight_one, std::ostream *ostrm,
+ const string &dest);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_DRAW_H_
--- /dev/null
+// 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 <memory>
+#include <string>
+
+#include <fst/encode.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/encodemapper-class.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+// 1: Encode using encoder on disk.
+using EncodeArgs1 =
+ args::Package<MutableFstClass *, uint32, bool, const string &>;
+
+template <class Arc>
+void Encode(EncodeArgs1 *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ const string &coder_fname = args->arg4;
+ // If true, reuse encode from disk. If false, make a new encoder and just use
+ // the filename argument as the destination state.
+ std::unique_ptr<EncodeMapper<Arc>> encoder(args->arg3 ?
+ EncodeMapper<Arc>::Read(coder_fname, ENCODE) :
+ new EncodeMapper<Arc>(args->arg2, ENCODE));
+ Encode(fst, encoder.get());
+ if (!args->arg3) encoder->Write(coder_fname);
+}
+
+void Encode(MutableFstClass *fst, uint32 flags, bool reuse_encoder,
+ const string &coder_fname);
+
+// 2: Encode using an EncodeMapperClass object.
+using EncodeArgs2 = args::Package<MutableFstClass *, EncodeMapperClass *>;
+
+template <class Arc>
+void Encode(EncodeArgs2 *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ EncodeMapper<Arc> *encoder = args->arg2->GetEncodeMapper<Arc>();
+ Encode(fst, encoder);
+}
+
+void Encode(MutableFstClass *fst, EncodeMapperClass *encoder);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_ENCODE_H_
--- /dev/null
+// 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 <memory>
+#include <string>
+#include <iostream>
+
+#include <fst/fstlib.h>
+#include <fst/script/arc-class.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+// Scripting API support for EncodeMapper.
+
+namespace fst {
+namespace script {
+
+// Virtual interface implemented by each concrete EncodeMapperClassImpl<A>.
+class EncodeMapperImplBase {
+ public:
+ // Returns an encoded ArcClass.
+ virtual ArcClass operator()(const ArcClass &a) = 0;
+ virtual const string &ArcType() const = 0;
+ virtual uint32 Flags() const = 0;
+ virtual uint64 Properties(uint64 inprops) = 0;
+ virtual EncodeType Type() const = 0;
+ virtual const SymbolTable *InputSymbols() const = 0;
+ virtual const SymbolTable *OutputSymbols() const = 0;
+ virtual void SetInputSymbols(const SymbolTable *syms) = 0;
+ virtual void SetOutputSymbols(const SymbolTable *syms) = 0;
+ virtual const string &WeightType() const = 0;
+ virtual ~EncodeMapperImplBase() {}
+};
+
+// Templated implementation.
+template <class Arc>
+class EncodeMapperClassImpl : public EncodeMapperImplBase {
+ public:
+ EncodeMapperClassImpl(uint32 flags, EncodeType type)
+ : encoder_(flags, type) {}
+
+ ArcClass operator()(const ArcClass &a) override;
+
+ const string &ArcType() const override { return Arc::Type(); }
+
+ uint32 Flags() const override { return encoder_.Flags(); }
+
+ uint64 Properties(uint64 inprops) override {
+ return encoder_.Properties(inprops);
+ }
+
+ EncodeType Type() const override { return encoder_.Type(); }
+
+ const SymbolTable *InputSymbols() const override {
+ return encoder_.InputSymbols();
+ }
+
+ const SymbolTable *OutputSymbols() const override {
+ return encoder_.OutputSymbols();
+ }
+
+ void SetInputSymbols(const SymbolTable *syms) override {
+ encoder_.SetInputSymbols(syms);
+ }
+
+ void SetOutputSymbols(const SymbolTable *syms) override {
+ encoder_.SetOutputSymbols(syms);
+ }
+
+ const string &WeightType() const override { return Arc::Weight::Type(); }
+
+ ~EncodeMapperClassImpl() override {}
+
+ EncodeMapper<Arc> *GetImpl() const { return &encoder_; }
+
+ EncodeMapper<Arc> *GetImpl() { return &encoder_; }
+
+ private:
+ EncodeMapper<Arc> encoder_;
+};
+
+// This is returned by value because it is very likely to undergo return-value
+// optimization.
+template <class Arc>
+inline ArcClass EncodeMapperClassImpl<Arc>::operator()(const ArcClass &a) {
+ Arc arc(a.ilabel, a.olabel, *(a.weight.GetWeight<typename Arc::Weight>()),
+ a.nextstate);
+ return ArcClass(encoder_(arc));
+}
+
+class EncodeMapperClass;
+
+using InitEncodeMapperClassArgs =
+ args::Package<uint32, EncodeType, EncodeMapperClass *>;
+
+class EncodeMapperClass {
+ public:
+ EncodeMapperClass(const string &arc_type, uint32 flags, EncodeType type);
+
+ template <class Arc>
+ EncodeMapperClass(uint32 flags, EncodeType type)
+ : impl_(new EncodeMapperClassImpl<Arc>(flags, type)) {}
+
+ ArcClass operator()(const ArcClass &arc) { return (*impl_)(arc); }
+
+ const string &ArcType() const { return impl_->ArcType(); }
+
+ uint32 Flags() const { return impl_->Flags(); }
+
+ uint64 Properties(uint64 inprops) { return impl_->Properties(inprops); }
+
+ EncodeType Type() const { return impl_->Type(); }
+
+ const SymbolTable *InputSymbols() const { return impl_->InputSymbols(); }
+
+ const SymbolTable *OutputSymbols() const { return impl_->OutputSymbols(); }
+
+ void SetInputSymbols(const SymbolTable *syms) {
+ impl_->SetInputSymbols(syms);
+ }
+
+ void SetOutputSymbols(const SymbolTable *syms) {
+ impl_->SetOutputSymbols(syms);
+ }
+
+ const string &WeightType() const { return impl_->WeightType(); }
+
+ template <class Arc>
+ friend void InitEncodeMapperClass(InitEncodeMapperClassArgs *args);
+
+ // Naturally, this exists in non-const and const forms. Encoding arcs or FSTs
+ // mutates the underlying encoder; decoding them does not.
+
+ template <class Arc>
+ EncodeMapper<Arc> *GetEncodeMapper() {
+ if (Arc::Type() != ArcType()) {
+ return nullptr;
+ } else {
+ auto *typed_impl = static_cast<EncodeMapperClassImpl<Arc> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+ }
+
+ template <class Arc>
+ const EncodeMapper<Arc> *GetEncodeMapper() const {
+ if (Arc::Type() != ArcType()) {
+ return nullptr;
+ } else {
+ auto *typed_impl = static_cast<EncodeMapperClassImpl<Arc> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+ }
+
+ private:
+ std::unique_ptr<EncodeMapperImplBase> impl_;
+};
+
+template <class Arc>
+void InitEncodeMapperClass(InitEncodeMapperClassArgs *args) {
+ args->arg3->impl_.reset(
+ new EncodeMapperClassImpl<Arc>(args->arg1, args->arg2));
+}
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_ENCODEMAPPER_CLASS_H_
--- /dev/null
+// 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 <fst/epsnormalize.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using EpsNormalizeArgs =
+ args::Package<const FstClass &, MutableFstClass *, EpsNormalizeType>;
+
+template <class Arc>
+void EpsNormalize(EpsNormalizeArgs *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ EpsNormalize(ifst, ofst, args->arg3);
+}
+
+void EpsNormalize(const FstClass &ifst, MutableFstClass *ofst,
+ EpsNormalizeType norm_type = EPS_NORM_INPUT);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_EPSNORMALIZE_H_
--- /dev/null
+// 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 <fst/equal.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using EqualInnerArgs = args::Package<const FstClass &, const FstClass &, float>;
+
+using EqualArgs = args::WithReturnValue<bool, EqualInnerArgs>;
+
+template <class Arc>
+void Equal(EqualArgs *args) {
+ const Fst<Arc> &fst1 = *(args->args.arg1.GetFst<Arc>());
+ const Fst<Arc> &fst2 = *(args->args.arg2.GetFst<Arc>());
+ args->retval = Equal(fst1, fst2, args->args.arg3);
+}
+
+bool Equal(const FstClass &fst1, const FstClass &fst2, float delta = kDelta);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_EQUAL_H_
--- /dev/null
+// 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 <fst/equivalent.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using EquivalentInnerArgs =
+ args::Package<const FstClass &, const FstClass &, float, bool *>;
+using EquivalentArgs = args::WithReturnValue<bool, EquivalentInnerArgs>;
+
+template <class Arc>
+void Equivalent(EquivalentArgs *args) {
+ const Fst<Arc> &fst1 = *(args->args.arg1.GetFst<Arc>());
+ const Fst<Arc> &fst2 = *(args->args.arg2.GetFst<Arc>());
+ args->retval = Equivalent(fst1, fst2, args->args.arg3, args->args.arg4);
+}
+
+bool Equivalent(const FstClass &fst1, const FstClass &fst2,
+ float delta = kDelta, bool *error = nullptr);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_EQUIVALENT_H_
--- /dev/null
+// 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 <algorithm>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+#include <fst/expanded-fst.h>
+#include <fst/fst.h>
+#include <fst/mutable-fst.h>
+#include <fst/vector-fst.h>
+#include <fst/script/arc-class.h>
+#include <fst/script/weight-class.h>
+
+// Classes to support "boxing" all existing types of FST arcs in a single
+// FstClass which hides the arc types. This allows clients to load
+// and work with FSTs without knowing the arc type. These classes are only
+// recommended for use in high-level scripting applications. Most users should
+// use the lower-level templated versions corresponding to these classes.
+
+namespace fst {
+namespace script {
+
+// Abstract base class defining the set of functionalities implemented in all
+// impls and passed through by all bases. Below FstClassBase the class
+// hierarchy bifurcates; FstClassImplBase serves as the base class for all
+// implementations (of which FstClassImpl is currently the only one) and
+// FstClass serves as the base class for all interfaces.
+
+class FstClassBase {
+ public:
+ virtual const string &ArcType() const = 0;
+ virtual WeightClass Final(int64) const = 0;
+ virtual const string &FstType() const = 0;
+ virtual const SymbolTable *InputSymbols() const = 0;
+ virtual size_t NumArcs(int64) const = 0;
+ virtual size_t NumInputEpsilons(int64) const = 0;
+ virtual size_t NumOutputEpsilons(int64) const = 0;
+ virtual const SymbolTable *OutputSymbols() const = 0;
+ virtual uint64 Properties(uint64, bool) const = 0;
+ virtual int64 Start() const = 0;
+ virtual const string &WeightType() const = 0;
+ virtual bool ValidStateId(int64) const = 0;
+ virtual bool Write(const string &fname) const = 0;
+ virtual bool Write(std::ostream &, const FstWriteOptions &) const = 0;
+ virtual ~FstClassBase() {}
+};
+
+// Adds all the MutableFst methods.
+class FstClassImplBase : public FstClassBase {
+ public:
+ virtual bool AddArc(int64, const ArcClass &) = 0;
+ virtual int64 AddState() = 0;
+ virtual FstClassImplBase *Copy() = 0;
+ virtual bool DeleteArcs(int64, size_t) = 0;
+ virtual bool DeleteArcs(int64) = 0;
+ virtual bool DeleteStates(const std::vector<int64> &) = 0;
+ virtual void DeleteStates() = 0;
+ virtual SymbolTable *MutableInputSymbols() = 0;
+ virtual SymbolTable *MutableOutputSymbols() = 0;
+ virtual int64 NumStates() const = 0;
+ virtual bool ReserveArcs(int64, size_t) = 0;
+ virtual void ReserveStates(int64) = 0;
+ virtual void SetInputSymbols(SymbolTable *) = 0;
+ virtual bool SetFinal(int64, const WeightClass &) = 0;
+ virtual void SetOutputSymbols(SymbolTable *) = 0;
+ virtual void SetProperties(uint64, uint64) = 0;
+ virtual bool SetStart(int64) = 0;
+ ~FstClassImplBase() override {}
+};
+
+// Containiner class wrapping an Fst<Arc>, hiding its arc type. Whether this
+// Fst<Arc> 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 Arc>
+class FstClassImpl : public FstClassImplBase {
+ public:
+ explicit FstClassImpl(Fst<Arc> *impl, bool should_own = false)
+ : impl_(should_own ? impl : impl->Copy()) {}
+
+ explicit FstClassImpl(const Fst<Arc> &impl) : impl_(impl.Copy()) {}
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ bool AddArc(int64 s, const ArcClass &ac) override {
+ 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<typename Arc::Weight>(),
+ ac.nextstate);
+ static_cast<MutableFst<Arc> *>(impl_.get())->AddArc(s, arc);
+ return true;
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ int64 AddState() override {
+ return static_cast<MutableFst<Arc> *>(impl_.get())->AddState();
+ }
+
+ const string &ArcType() const override { return Arc::Type(); }
+
+ FstClassImpl *Copy() override { return new FstClassImpl<Arc>(impl_.get()); }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ bool DeleteArcs(int64 s, size_t n) override {
+ if (!ValidStateId(s)) return false;
+ static_cast<MutableFst<Arc> *>(impl_.get())->DeleteArcs(s, n);
+ return true;
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ bool DeleteArcs(int64 s) override {
+ if (!ValidStateId(s)) return false;
+ static_cast<MutableFst<Arc> *>(impl_.get())->DeleteArcs(s);
+ return true;
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ bool DeleteStates(const std::vector<int64> &dstates) override {
+ 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<typename Arc::StateId> typed_dstates(dstates.size());
+ std::copy(dstates.begin(), dstates.end(), typed_dstates.begin());
+ static_cast<MutableFst<Arc> *>(impl_.get())->DeleteStates(typed_dstates);
+ return true;
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ void DeleteStates() override {
+ static_cast<MutableFst<Arc> *>(impl_.get())->DeleteStates();
+ }
+
+ WeightClass Final(int64 s) const override {
+ if (!ValidStateId(s)) return WeightClass::NoWeight(WeightType());
+ WeightClass w(impl_->Final(s));
+ return w;
+ }
+
+ const string &FstType() const override { return impl_->Type(); }
+
+ const SymbolTable *InputSymbols() const override {
+ return impl_->InputSymbols();
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ SymbolTable *MutableInputSymbols() override {
+ return static_cast<MutableFst<Arc> *>(impl_.get())->MutableInputSymbols();
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ SymbolTable *MutableOutputSymbols() override {
+ return static_cast<MutableFst<Arc> *>(impl_.get())->MutableOutputSymbols();
+ }
+
+ // Signals failure by returning size_t max.
+ size_t NumArcs(int64 s) const override {
+ return ValidStateId(s) ? impl_->NumArcs(s)
+ : std::numeric_limits<size_t>::max();
+ }
+
+ // Signals failure by returning size_t max.
+ size_t NumInputEpsilons(int64 s) const override {
+ return ValidStateId(s) ? impl_->NumInputEpsilons(s)
+ : std::numeric_limits<size_t>::max();
+ }
+
+ // Signals failure by returning size_t max.
+ size_t NumOutputEpsilons(int64 s) const override {
+ return ValidStateId(s) ? impl_->NumOutputEpsilons(s)
+ : std::numeric_limits<size_t>::max();
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ int64 NumStates() const override {
+ return static_cast<MutableFst<Arc> *>(impl_.get())->NumStates();
+ }
+
+ uint64 Properties(uint64 mask, bool test) const override {
+ return impl_->Properties(mask, test);
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ bool ReserveArcs(int64 s, size_t n) override {
+ if (!ValidStateId(s)) return false;
+ static_cast<MutableFst<Arc> *>(impl_.get())->ReserveArcs(s, n);
+ return true;
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ void ReserveStates(int64 s) override {
+ static_cast<MutableFst<Arc> *>(impl_.get())->ReserveStates(s);
+ }
+
+ const SymbolTable *OutputSymbols() const override {
+ return impl_->OutputSymbols();
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ void SetInputSymbols(SymbolTable *isyms) override {
+ static_cast<MutableFst<Arc> *>(impl_.get())->SetInputSymbols(isyms);
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ bool SetFinal(int64 s, const WeightClass &weight) override {
+ if (!ValidStateId(s)) return false;
+ static_cast<MutableFst<Arc> *>(impl_.get())
+ ->SetFinal(s, *weight.GetWeight<typename Arc::Weight>());
+ return true;
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ void SetOutputSymbols(SymbolTable *osyms) override {
+ static_cast<MutableFst<Arc> *>(impl_.get())->SetOutputSymbols(osyms);
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ void SetProperties(uint64 props, uint64 mask) override {
+ static_cast<MutableFst<Arc> *>(impl_.get())->SetProperties(props, mask);
+ }
+
+ // Warning: calling this method casts the FST to a mutable FST.
+ bool SetStart(int64 s) override {
+ if (!ValidStateId(s)) return false;
+ static_cast<MutableFst<Arc> *>(impl_.get())->SetStart(s);
+ return true;
+ }
+
+ int64 Start() const override { return impl_->Start(); }
+
+ bool ValidStateId(int64 s) const override {
+ // This cowardly refuses to count states if the FST is not yet expanded.
+ if (!Properties(kExpanded, true)) {
+ FSTERROR() << "Cannot get number of states for unexpanded FST";
+ return false;
+ }
+ // If the FST is already expanded, CountStates calls NumStates.
+ if (s < 0 || s >= CountStates(*impl_)) {
+ FSTERROR() << "State ID " << s << " not valid";
+ return false;
+ }
+ return true;
+ }
+
+ const string &WeightType() const override { return Arc::Weight::Type(); }
+
+ bool Write(const string &fname) const override { return impl_->Write(fname); }
+
+ bool Write(std::ostream &ostr, const FstWriteOptions &opts) const override {
+ return impl_->Write(ostr, opts);
+ }
+
+ ~FstClassImpl() override {}
+
+ Fst<Arc> *GetImpl() const { return impl_.get(); }
+
+ private:
+ std::unique_ptr<Fst<Arc>> impl_;
+};
+
+// BASE CLASS DEFINITIONS
+
+class MutableFstClass;
+
+class FstClass : public FstClassBase {
+ public:
+ FstClass() : impl_(nullptr) {}
+
+ template <class Arc>
+ explicit FstClass(const Fst<Arc> &fst) : impl_(new FstClassImpl<Arc>(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 override { return impl_->Final(s); }
+
+ const string &ArcType() const override { return impl_->ArcType(); }
+
+ const string &FstType() const override { return impl_->FstType(); }
+
+ const SymbolTable *InputSymbols() const override {
+ return impl_->InputSymbols();
+ }
+
+ size_t NumArcs(int64 s) const override { return impl_->NumArcs(s); }
+
+ size_t NumInputEpsilons(int64 s) const override {
+ return impl_->NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(int64 s) const override {
+ return impl_->NumOutputEpsilons(s);
+ }
+
+ const SymbolTable *OutputSymbols() const override {
+ return impl_->OutputSymbols();
+ }
+
+ uint64 Properties(uint64 mask, bool test) const override {
+ // Special handling for FSTs with a null impl.
+ if (!impl_) return kError & mask;
+ return impl_->Properties(mask, test);
+ }
+
+ static FstClass *Read(const string &fname);
+
+ static FstClass *Read(std::istream &istr, const string &source);
+
+ static FstClass *ReadFromString(const string &fst_string);
+
+ int64 Start() const override { return impl_->Start(); }
+
+ bool ValidStateId(int64 s) const override { return impl_->ValidStateId(s); }
+
+ const string &WeightType() const override { return impl_->WeightType(); }
+
+ // Helper that logs an ERROR if the weight type of an FST and a WeightClass
+ // don't match.
+
+ bool WeightTypesMatch(const WeightClass &weight, const string &op_name) const;
+
+ bool Write(const string &fname) const override { return impl_->Write(fname); }
+
+ bool Write(std::ostream &ostr, const FstWriteOptions &opts) const override {
+ return impl_->Write(ostr, opts);
+ }
+
+ const string WriteToString() const;
+
+ ~FstClass() override {}
+
+ // These methods are required by IO registration.
+
+ template <class Arc>
+ static FstClassImplBase *Convert(const FstClass &other) {
+ FSTERROR() << "Doesn't make sense to convert any class to type FstClass";
+ return nullptr;
+ }
+
+ template <class Arc>
+ static FstClassImplBase *Create() {
+ FSTERROR() << "Doesn't make sense to create an FstClass with a "
+ << "particular arc type";
+ return nullptr;
+ }
+
+ template <class Arc>
+ const Fst<Arc> *GetFst() const {
+ if (Arc::Type() != ArcType()) {
+ return nullptr;
+ } else {
+ FstClassImpl<Arc> *typed_impl =
+ static_cast<FstClassImpl<Arc> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+ }
+
+ template <class Arc>
+ 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<MutableFstClass, MutableFst<Arc>>(stream, opts);
+ } else {
+ return ReadTypedFst<FstClass, Fst<Arc>>(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 <class FstClassT, class UnderlyingT>
+ static FstClassT *ReadTypedFst(std::istream &stream,
+ const FstReadOptions &opts) {
+ std::unique_ptr<UnderlyingT> u(UnderlyingT::Read(stream, opts));
+ return u ? new FstClassT(*u) : nullptr;
+ }
+
+ private:
+ std::unique_ptr<FstClassImplBase> impl_;
+};
+
+// Specific types of FstClass with special properties
+
+class MutableFstClass : public FstClass {
+ public:
+ bool AddArc(int64 s, const ArcClass &ac) {
+ if (!WeightTypesMatch(ac.weight, "AddArc")) return false;
+ return GetImpl()->AddArc(s, ac);
+ }
+
+ int64 AddState() { return GetImpl()->AddState(); }
+
+ bool DeleteArcs(int64 s, size_t n) { return GetImpl()->DeleteArcs(s, n); }
+
+ bool DeleteArcs(int64 s) { return GetImpl()->DeleteArcs(s); }
+
+ bool DeleteStates(const std::vector<int64> &dstates) {
+ return GetImpl()->DeleteStates(dstates);
+ }
+
+ void DeleteStates() { GetImpl()->DeleteStates(); }
+
+ SymbolTable *MutableInputSymbols() {
+ return GetImpl()->MutableInputSymbols();
+ }
+
+ SymbolTable *MutableOutputSymbols() {
+ return GetImpl()->MutableOutputSymbols();
+ }
+
+ int64 NumStates() const { return GetImpl()->NumStates(); }
+
+ bool ReserveArcs(int64 s, size_t n) { return GetImpl()->ReserveArcs(s, n); }
+
+ void ReserveStates(int64 s) { GetImpl()->ReserveStates(s); }
+
+ static MutableFstClass *Read(const string &fname, bool convert = false);
+
+ void SetInputSymbols(SymbolTable *isyms) {
+ GetImpl()->SetInputSymbols(isyms);
+ }
+
+ bool SetFinal(int64 s, const WeightClass &weight) {
+ if (!WeightTypesMatch(weight, "SetFinal")) return false;
+ return GetImpl()->SetFinal(s, weight);
+ }
+
+ void SetOutputSymbols(SymbolTable *osyms) {
+ GetImpl()->SetOutputSymbols(osyms);
+ }
+
+ void SetProperties(uint64 props, uint64 mask) {
+ GetImpl()->SetProperties(props, mask);
+ }
+
+ bool SetStart(int64 s) { return GetImpl()->SetStart(s); }
+
+ bool ValidStateId(int64 s) const override {
+ return GetImpl()->ValidStateId(s);
+ }
+
+ bool Write(std::ostream &ostr, const FstWriteOptions &opts) const override {
+ return GetImpl()->Write(ostr, opts);
+ }
+
+ bool Write(const string &fname) const override {
+ return GetImpl()->Write(fname);
+ }
+
+ template <class Arc>
+ explicit MutableFstClass(const MutableFst<Arc> &fst) : FstClass(fst) {}
+
+ // These methods are required by IO registration.
+
+ template <class Arc>
+ static FstClassImplBase *Convert(const FstClass &other) {
+ FSTERROR() << "Doesn't make sense to convert any class to type "
+ << "MutableFstClass";
+ return nullptr;
+ }
+
+ template <class Arc>
+ static FstClassImplBase *Create() {
+ FSTERROR() << "Doesn't make sense to create a MutableFstClass with a "
+ << "particular arc type";
+ return nullptr;
+ }
+
+ template <class Arc>
+ MutableFst<Arc> *GetMutableFst() {
+ Fst<Arc> *fst = const_cast<Fst<Arc> *>(this->GetFst<Arc>());
+ MutableFst<Arc> *mfst = static_cast<MutableFst<Arc> *>(fst);
+ return mfst;
+ }
+
+ template <class Arc>
+ static MutableFstClass *Read(std::istream &stream,
+ const FstReadOptions &opts) {
+ std::unique_ptr<MutableFst<Arc>> mfst(MutableFst<Arc>::Read(stream, opts));
+ return mfst ? new MutableFstClass(*mfst) : nullptr;
+ }
+
+ protected:
+ explicit MutableFstClass(FstClassImplBase *impl) : FstClass(impl) {}
+};
+
+class VectorFstClass : public MutableFstClass {
+ public:
+ explicit VectorFstClass(FstClassImplBase *impl) : MutableFstClass(impl) {}
+
+ explicit VectorFstClass(const FstClass &other);
+
+ explicit VectorFstClass(const string &arc_type);
+
+ static VectorFstClass *Read(const string &fname);
+
+ template <class Arc>
+ static VectorFstClass *Read(std::istream &stream,
+ const FstReadOptions &opts) {
+ std::unique_ptr<VectorFst<Arc>> mfst(VectorFst<Arc>::Read(stream, opts));
+ return mfst ? new VectorFstClass(*mfst) : nullptr;
+ }
+
+ template <class Arc>
+ explicit VectorFstClass(const VectorFst<Arc> &fst) : MutableFstClass(fst) {}
+
+ template <class Arc>
+ static FstClassImplBase *Convert(const FstClass &other) {
+ return new FstClassImpl<Arc>(new VectorFst<Arc>(*other.GetFst<Arc>()),
+ true);
+ }
+
+ template <class Arc>
+ static FstClassImplBase *Create() {
+ return new FstClassImpl<Arc>(new VectorFst<Arc>(), true);
+ }
+};
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_FST_CLASS_H_
--- /dev/null
+// 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 <fst/fst-decl.h>
+
+namespace fst {
+namespace script {
+
+class ArcClass;
+
+class ArcIteratorClass;
+class MutableArcIteratorClass;
+
+class FstClass;
+class MutableFstClass;
+class VectorFstClass;
+
+class StateIteratorClass;
+
+class WeightClass;
+
+} // namespace script
+} // namespace fst;
+
+#endif // FST_SCRIPT_FSTSCRIPT_DECL_H_
--- /dev/null
+// 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 <fst/script/arciterator-class.h>
+#include <fst/script/encodemapper-class.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/stateiterator-class.h>
+#include <fst/script/text-io.h>
+#include <fst/script/weight-class.h>
+
+// Flag-to-enum parsers.
+#include <fst/script/getters.h>
+// Templates like Operation<> and Apply<>.
+#include <fst/script/script-impl.h>
+
+// Operations.
+#include <fst/script/arcsort.h>
+#include <fst/script/closure.h>
+#include <fst/script/compile.h>
+#include <fst/script/compose.h>
+#include <fst/script/concat.h>
+#include <fst/script/connect.h>
+#include <fst/script/convert.h>
+#include <fst/script/decode.h>
+#include <fst/script/determinize.h>
+#include <fst/script/difference.h>
+#include <fst/script/disambiguate.h>
+#include <fst/script/draw.h>
+#include <fst/script/encode.h>
+#include <fst/script/epsnormalize.h>
+#include <fst/script/equal.h>
+#include <fst/script/equivalent.h>
+#include <fst/script/info.h>
+#include <fst/script/intersect.h>
+#include <fst/script/invert.h>
+#include <fst/script/isomorphic.h>
+#include <fst/script/map.h>
+#include <fst/script/minimize.h>
+#include <fst/script/print.h>
+#include <fst/script/project.h>
+#include <fst/script/prune.h>
+#include <fst/script/push.h>
+#include <fst/script/randequivalent.h>
+#include <fst/script/randgen.h>
+#include <fst/script/relabel.h>
+#include <fst/script/replace.h>
+#include <fst/script/reverse.h>
+#include <fst/script/reweight.h>
+#include <fst/script/rmepsilon.h>
+#include <fst/script/shortest-distance.h>
+#include <fst/script/shortest-path.h>
+#include <fst/script/synchronize.h>
+#include <fst/script/topsort.h>
+#include <fst/script/union.h>
+#include <fst/script/verify.h>
+
+// 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 Arc>
+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, ComposeArgs1);
+ REGISTER_FST_OPERATION(Compose, Arc, ComposeArgs2);
+ REGISTER_FST_OPERATION(Concat, Arc, ConcatArgs1);
+ REGISTER_FST_OPERATION(Concat, Arc, ConcatArgs2);
+ REGISTER_FST_OPERATION(Connect, Arc, MutableFstClass);
+ REGISTER_FST_OPERATION(Convert, Arc, ConvertArgs);
+ REGISTER_FST_OPERATION(Decode, Arc, DecodeArgs1);
+ REGISTER_FST_OPERATION(Decode, Arc, DecodeArgs2);
+ REGISTER_FST_OPERATION(Determinize, Arc, DeterminizeArgs1);
+ REGISTER_FST_OPERATION(Determinize, Arc, DeterminizeArgs2);
+ REGISTER_FST_OPERATION(Difference, Arc, DifferenceArgs1);
+ REGISTER_FST_OPERATION(Difference, Arc, DifferenceArgs2);
+ REGISTER_FST_OPERATION(Disambiguate, Arc, DisambiguateArgs1);
+ REGISTER_FST_OPERATION(Disambiguate, Arc, DisambiguateArgs2);
+ REGISTER_FST_OPERATION(DrawFst, Arc, FstDrawerArgs);
+ REGISTER_FST_OPERATION(Encode, Arc, EncodeArgs1);
+ REGISTER_FST_OPERATION(Encode, Arc, EncodeArgs2);
+ REGISTER_FST_OPERATION(EpsNormalize, Arc, EpsNormalizeArgs);
+ REGISTER_FST_OPERATION(Equal, Arc, EqualArgs);
+ REGISTER_FST_OPERATION(Equivalent, Arc, EquivalentArgs);
+ REGISTER_FST_OPERATION(PrintFstInfo, Arc, InfoArgs);
+ REGISTER_FST_OPERATION(InitArcIteratorClass, Arc,
+ InitArcIteratorClassArgs);
+ REGISTER_FST_OPERATION(InitEncodeMapperClass, Arc,
+ InitEncodeMapperClassArgs);
+ REGISTER_FST_OPERATION(InitMutableArcIteratorClass, Arc,
+ InitMutableArcIteratorClassArgs);
+ REGISTER_FST_OPERATION(InitStateIteratorClass, Arc,
+ InitStateIteratorClassArgs);
+ }
+
+ void RegisterBatch2() {
+ REGISTER_FST_OPERATION(Intersect, Arc, IntersectArgs1);
+ REGISTER_FST_OPERATION(Intersect, Arc, IntersectArgs2);
+ REGISTER_FST_OPERATION(Invert, Arc, MutableFstClass);
+ REGISTER_FST_OPERATION(Map, Arc, MapArgs);
+ REGISTER_FST_OPERATION(Minimize, Arc, MinimizeArgs);
+ REGISTER_FST_OPERATION(PrintFst, Arc, FstPrinterArgs);
+ REGISTER_FST_OPERATION(Project, Arc, ProjectArgs);
+ REGISTER_FST_OPERATION(Prune, Arc, PruneArgs1);
+ REGISTER_FST_OPERATION(Prune, Arc, PruneArgs2);
+ REGISTER_FST_OPERATION(Prune, Arc, PruneArgs3);
+ REGISTER_FST_OPERATION(Prune, Arc, PruneArgs4);
+ REGISTER_FST_OPERATION(Push, Arc, PushArgs1);
+ REGISTER_FST_OPERATION(Push, Arc, PushArgs2);
+ REGISTER_FST_OPERATION(RandEquivalent, Arc, RandEquivalentArgs1);
+ REGISTER_FST_OPERATION(RandEquivalent, Arc, RandEquivalentArgs2);
+ REGISTER_FST_OPERATION(RandGen, Arc, RandGenArgs);
+ REGISTER_FST_OPERATION(Relabel, Arc, RelabelArgs1);
+ REGISTER_FST_OPERATION(Relabel, Arc, RelabelArgs2);
+ REGISTER_FST_OPERATION(Relabel, Arc, RelabelArgs3);
+ REGISTER_FST_OPERATION(Replace, Arc, ReplaceArgs);
+ REGISTER_FST_OPERATION(Reverse, Arc, ReverseArgs);
+ REGISTER_FST_OPERATION(Reweight, Arc, ReweightArgs);
+ REGISTER_FST_OPERATION(RmEpsilon, Arc, RmEpsilonArgs1);
+ REGISTER_FST_OPERATION(RmEpsilon, Arc, RmEpsilonArgs2);
+ REGISTER_FST_OPERATION(RmEpsilon, Arc, RmEpsilonArgs3);
+ REGISTER_FST_OPERATION(ShortestDistance, Arc, ShortestDistanceArgs1);
+ REGISTER_FST_OPERATION(ShortestDistance, Arc, ShortestDistanceArgs2);
+ REGISTER_FST_OPERATION(ShortestPath, Arc, ShortestPathArgs1);
+ REGISTER_FST_OPERATION(ShortestPath, Arc, ShortestPathArgs2);
+ REGISTER_FST_OPERATION(Synchronize, Arc, SynchronizeArgs);
+ REGISTER_FST_OPERATION(TopSort, Arc, TopSortArgs);
+ REGISTER_FST_OPERATION(Union, Arc, UnionArgs);
+ REGISTER_FST_OPERATION(Verify, Arc, VerifyArgs);
+ }
+};
+} // namespace script
+} // namespace fst
+
+#define REGISTER_FST_OPERATIONS(Arc) \
+ AllFstOperationsRegisterer<Arc> register_all_fst_operations##Arc;
+
+#endif // FST_SCRIPT_FSTSCRIPT_H_
--- /dev/null
+// 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 <string>
+
+#include <fst/compose.h> // For ComposeFilter.
+#include <fst/determinize.h> // For DeterminizeType.
+#include <fst/encode.h> // For kEncodeLabels (etc.).
+#include <fst/epsnormalize.h> // For EpsNormalizeType.
+#include <fst/project.h> // For ProjectType.
+#include <fst/push.h> // For kPushWeights (etc.).
+#include <fst/queue.h> // For QueueType.
+#include <fst/rational.h> // For ClosureType.
+#include <fst/script/arcsort.h> // For ArcSortType.
+#include <fst/script/map.h> // For MapType.
+#include <fst/script/script-impl.h> // For RandArcSelection.
+
+#include <fst/types.h>
+
+namespace fst {
+namespace script {
+
+bool GetArcSortType(const string &str, ArcSortType *sort_type);
+
+inline ClosureType GetClosureType(bool closure_plus) {
+ return closure_plus ? CLOSURE_PLUS : CLOSURE_STAR;
+}
+
+bool GetComposeFilter(const string &str, ComposeFilter *compose_filter);
+
+bool GetDeterminizeType(const string &str, DeterminizeType *det_type);
+
+inline uint32 GetEncodeFlags(bool encode_labels, bool encode_weights) {
+ return (encode_labels ? kEncodeLabels : 0) |
+ (encode_weights ? kEncodeWeights : 0);
+}
+
+inline EpsNormalizeType GetEpsNormalizeType(bool eps_norm_output) {
+ return eps_norm_output ? EPS_NORM_OUTPUT : EPS_NORM_INPUT;
+}
+
+bool GetMapType(const string &str, MapType *map_type);
+
+inline ProjectType GetProjectType(bool project_output) {
+ return project_output ? PROJECT_OUTPUT : PROJECT_INPUT;
+}
+
+inline uint32 GetPushFlags(bool push_weights, bool push_labels,
+ bool remove_total_weight, bool remove_common_affix) {
+ return ((push_weights ? kPushWeights : 0) |
+ (push_labels ? kPushLabels : 0) |
+ (remove_total_weight ? kPushRemoveTotalWeight : 0) |
+ (remove_common_affix ? kPushRemoveCommonAffix : 0));
+}
+
+bool GetQueueType(const string &str, QueueType *queue_type);
+
+bool GetRandArcSelection(const string &str, RandArcSelection *ras);
+
+bool GetReplaceLabelType(const string &str, bool epsilon_on_replace,
+ ReplaceLabelType *rlt);
+
+inline ReweightType GetReweightType(bool to_final) {
+ return to_final ? REWEIGHT_TO_FINAL : REWEIGHT_TO_INITIAL;
+}
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_GETTERS_H_
--- /dev/null
+// 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 <map>
+#include <string>
+#include <vector>
+
+#include <fst/connect.h>
+#include <fst/dfs-visit.h>
+#include <fst/fst.h>
+#include <fst/lookahead-matcher.h>
+#include <fst/matcher.h>
+#include <fst/queue.h>
+#include <fst/test-properties.h>
+#include <fst/verify.h>
+#include <fst/visit.h>
+
+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<Arc>::NumStates,
+// Fst<Arc>::NumArcs, TestProperties, etc.
+template <class Arc>
+class FstInfo {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ // When info_type is "short" (or "auto" and not an ExpandedFst) then only
+ // minimal info is computed and can be requested.
+ FstInfo(const Fst<Arc> &fst, bool test_properties,
+ const string &arc_filter_type = "any", 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) {
+ 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<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ ++nstates_;
+ const auto s = siter.Value();
+ if (fst.Final(s) != Weight::Zero()) ++nfinal_;
+ std::map<Label, size_t> ilabel_count;
+ std::map<Label, size_t> olabel_count;
+ for (ArcIterator<Fst<Arc>> 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<StateId> cc;
+ CcVisitor<Arc> cc_visitor(&cc);
+ FifoQueue<StateId> 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<Arc>());
+ } else if (arc_filter_type == "iepsilon") {
+ Visit(fst, &cc_visitor, &fifo_queue, InputEpsilonArcFilter<Arc>());
+ } else if (arc_filter_type == "oepsilon") {
+ Visit(fst, &cc_visitor, &fifo_queue, OutputEpsilonArcFilter<Arc>());
+ } 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<StateId> scc;
+ std::vector<bool> access, coaccess;
+ uint64 props = 0;
+ SccVisitor<Arc> 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<Arc>());
+ } else if (arc_filter_type == "iepsilon") {
+ DfsVisit(fst, &scc_visitor, InputEpsilonArcFilter<Arc>());
+ } else if (arc_filter_type == "oepsilon") {
+ DfsVisit(fst, &scc_visitor, OutputEpsilonArcFilter<Arc>());
+ } 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<Fst<Arc>> imatcher(fst, MATCH_INPUT);
+ input_match_type_ = imatcher.Type(test_properties);
+ input_lookahead_ = imatcher.Flags() & kInputLookAheadMatcher;
+ LookAheadMatcher<Fst<Arc>> omatcher(fst, MATCH_OUTPUT);
+ output_match_type_ = omatcher.Type(test_properties);
+ output_lookahead_ = omatcher.Flags() & kOutputLookAheadMatcher;
+ }
+
+ // Short info.
+
+ const string &FstType() const { return fst_type_; }
+
+ const string &ArcType() const { return Arc::Type(); }
+
+ const string &InputSymbols() const { return input_symbols_; }
+
+ const string &OutputSymbols() const { return output_symbols_; }
+
+ bool LongInfo() const { return long_info_; }
+
+ const string &ArcFilterType() const { return arc_filter_type_; }
+
+ // Long info.
+
+ MatchType InputMatchType() const {
+ CheckLong();
+ return input_match_type_;
+ }
+
+ MatchType OutputMatchType() const {
+ CheckLong();
+ return output_match_type_;
+ }
+
+ bool InputLookAhead() const {
+ CheckLong();
+ return input_lookahead_;
+ }
+
+ bool OutputLookAhead() const {
+ CheckLong();
+ return output_lookahead_;
+ }
+
+ StateId NumStates() const {
+ CheckLong();
+ return nstates_;
+ }
+
+ size_t NumArcs() const {
+ CheckLong();
+ return narcs_;
+ }
+
+ StateId Start() const {
+ CheckLong();
+ return start_;
+ }
+
+ size_t NumFinal() const {
+ CheckLong();
+ return nfinal_;
+ }
+
+ size_t NumEpsilons() const {
+ CheckLong();
+ return nepsilons_;
+ }
+
+ size_t NumInputEpsilons() const {
+ CheckLong();
+ return niepsilons_;
+ }
+
+ size_t NumOutputEpsilons() const {
+ CheckLong();
+ return noepsilons_;
+ }
+
+ double InputLabelMultiplicity() const {
+ CheckLong();
+ return ilabel_mult_;
+ }
+
+ double OutputLabelMultiplicity() const {
+ CheckLong();
+ return olabel_mult_;
+ }
+
+ size_t NumAccessible() const {
+ CheckLong();
+ return naccess_;
+ }
+
+ size_t NumCoAccessible() const {
+ CheckLong();
+ return ncoaccess_;
+ }
+
+ size_t NumConnected() const {
+ CheckLong();
+ return nconnect_;
+ }
+
+ size_t NumCc() const {
+ CheckLong();
+ return ncc_;
+ }
+
+ size_t NumScc() const {
+ CheckLong();
+ return nscc_;
+ }
+
+ uint64 Properties() const {
+ CheckLong();
+ return properties_;
+ }
+
+ private:
+ void CheckLong() const {
+ if (!long_info_)
+ FSTERROR() << "FstInfo: Method only available with long info signature";
+ }
+
+ string fst_type_;
+ string input_symbols_;
+ string output_symbols_;
+ StateId nstates_;
+ size_t narcs_;
+ StateId start_;
+ size_t nfinal_;
+ size_t nepsilons_;
+ size_t niepsilons_;
+ size_t noepsilons_;
+ double ilabel_mult_;
+ double olabel_mult_;
+ size_t naccess_;
+ size_t ncoaccess_;
+ size_t nconnect_;
+ size_t ncc_;
+ size_t nscc_;
+ MatchType input_match_type_;
+ MatchType output_match_type_;
+ bool input_lookahead_;
+ bool output_lookahead_;
+ uint64 properties_;
+ string arc_filter_type_;
+ bool long_info_;
+};
+
+template <class Arc>
+void PrintFstInfo(const FstInfo<Arc> &fstinfo, bool pipe = false) {
+ std::ostream &ostrm = pipe ? std::cerr : std::cout;
+ const auto old = ostrm.setf(std::ios::left);
+ ostrm.width(50);
+ ostrm << "fst type" << fstinfo.FstType() << std::endl;
+ ostrm.width(50);
+ ostrm << "arc type" << fstinfo.ArcType() << std::endl;
+ ostrm.width(50);
+ ostrm << "input symbol table" << fstinfo.InputSymbols() << std::endl;
+ ostrm.width(50);
+ ostrm << "output symbol table" << fstinfo.OutputSymbols() << std::endl;
+ if (!fstinfo.LongInfo()) {
+ ostrm.setf(old);
+ return;
+ }
+ ostrm.width(50);
+ ostrm << "# of states" << fstinfo.NumStates() << std::endl;
+ ostrm.width(50);
+ ostrm << "# of arcs" << fstinfo.NumArcs() << std::endl;
+ ostrm.width(50);
+ ostrm << "initial state" << fstinfo.Start() << std::endl;
+ ostrm.width(50);
+ ostrm << "# of final states" << fstinfo.NumFinal() << std::endl;
+ ostrm.width(50);
+ ostrm << "# of input/output epsilons" << fstinfo.NumEpsilons() << std::endl;
+ ostrm.width(50);
+ ostrm << "# of input epsilons" << fstinfo.NumInputEpsilons() << std::endl;
+ ostrm.width(50);
+ ostrm << "# of output epsilons" << fstinfo.NumOutputEpsilons() << std::endl;
+ ostrm.width(50);
+ ostrm << "input label multiplicity" << fstinfo.InputLabelMultiplicity()
+ << std::endl;
+ ostrm.width(50);
+ ostrm << "output label multiplicity" << fstinfo.OutputLabelMultiplicity()
+ << std::endl;
+ ostrm.width(50);
+ string arc_type = "";
+ if (fstinfo.ArcFilterType() == "epsilon")
+ arc_type = "epsilon ";
+ else if (fstinfo.ArcFilterType() == "iepsilon")
+ arc_type = "input-epsilon ";
+ else if (fstinfo.ArcFilterType() == "oepsilon")
+ arc_type = "output-epsilon ";
+ const auto accessible_label = "# of " + arc_type + "accessible states";
+ ostrm.width(50);
+ ostrm << accessible_label << fstinfo.NumAccessible() << std::endl;
+ const auto coaccessible_label = "# of " + arc_type + "coaccessible states";
+ ostrm.width(50);
+ ostrm << coaccessible_label << fstinfo.NumCoAccessible() << std::endl;
+ const auto connected_label = "# of " + arc_type + "connected states";
+ ostrm.width(50);
+ ostrm << connected_label << fstinfo.NumConnected() << std::endl;
+ const auto numcc_label = "# of " + arc_type + "connected components";
+ ostrm.width(50);
+ ostrm << numcc_label << fstinfo.NumCc() << std::endl;
+ const auto numscc_label = "# of " + arc_type + "strongly conn components";
+ ostrm.width(50);
+ ostrm << numscc_label << fstinfo.NumScc() << std::endl;
+ ostrm.width(50);
+ ostrm << "input matcher"
+ << (fstinfo.InputMatchType() == MATCH_INPUT
+ ? 'y'
+ : fstinfo.InputMatchType() == MATCH_NONE ? 'n' : '?')
+ << std::endl;
+ ostrm.width(50);
+ ostrm << "output matcher"
+ << (fstinfo.OutputMatchType() == MATCH_OUTPUT
+ ? 'y'
+ : fstinfo.OutputMatchType() == MATCH_NONE ? 'n' : '?')
+ << std::endl;
+ ostrm.width(50);
+ ostrm << "input lookahead" << (fstinfo.InputLookAhead() ? 'y' : 'n')
+ << std::endl;
+ ostrm.width(50);
+ ostrm << "output lookahead" << (fstinfo.OutputLookAhead() ? 'y' : 'n')
+ << std::endl;
+ uint64 prop = 1;
+ for (auto i = 0; i < 64; ++i, prop <<= 1) {
+ if (prop & kBinaryProperties) {
+ char value = 'n';
+ if (fstinfo.Properties() & prop) value = 'y';
+ ostrm.width(50);
+ ostrm << PropertyNames[i] << value << std::endl;
+ } else if (prop & kPosTrinaryProperties) {
+ char value = '?';
+ if (fstinfo.Properties() & prop)
+ value = 'y';
+ else if (fstinfo.Properties() & prop << 1)
+ value = 'n';
+ ostrm.width(50);
+ ostrm << PropertyNames[i] << value << std::endl;
+ }
+ }
+ ostrm.setf(old);
+}
+
+} // namespace fst
+
+#endif // FST_SCRIPT_INFO_IMPL_H_
--- /dev/null
+// 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 <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/info-impl.h>
+
+namespace fst {
+namespace script {
+
+using InfoArgs = args::Package<const FstClass &, bool, const string &,
+ const string &, bool, bool>;
+
+template <class Arc>
+void PrintFstInfo(InfoArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ FstInfo<Arc> fstinfo(fst, args->arg2, args->arg3, args->arg4, args->arg5);
+ PrintFstInfo(fstinfo, args->arg6);
+ if (args->arg6) fst.Write("");
+}
+
+void PrintFstInfo(const FstClass &f, bool test_properties,
+ const string &arc_filter, const string &info_type, bool pipe,
+ bool verify);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_INFO_H_
--- /dev/null
+// 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 <fst/intersect.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/compose.h> // for ComposeOptions, ComposeFilter
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using IntersectArgs1 = args::Package<const FstClass &, const FstClass &,
+ MutableFstClass *, ComposeFilter>;
+
+template <class Arc>
+void Intersect(IntersectArgs1 *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ Intersect(ifst1, ifst2, ofst, ComposeOptions(args->arg4));
+}
+
+using IntersectArgs2 = args::Package<const FstClass &, const FstClass &,
+ MutableFstClass *, const ComposeOptions &>;
+
+template <class Arc>
+void Intersect(IntersectArgs2 *args) {
+ const Fst<Arc> &ifst1 = *(args->arg1.GetFst<Arc>());
+ const Fst<Arc> &ifst2 = *(args->arg2.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg3->GetMutableFst<Arc>();
+ Intersect(ifst1, ifst2, ofst, ComposeOptions(args->arg4));
+}
+
+void Intersect(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, ComposeFilter compose_filter);
+
+void Intersect(const FstClass &ifst, const FstClass &ifst2,
+ MutableFstClass *ofst,
+ const ComposeOptions &opts = fst::script::ComposeOptions());
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_INTERSECT_H_
--- /dev/null
+// 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 <fst/invert.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+template <class Arc>
+void Invert(MutableFstClass *fst) {
+ MutableFst<Arc> *typed_fst = fst->GetMutableFst<Arc>();
+ Invert(typed_fst);
+}
+
+void Invert(MutableFstClass *fst);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_INVERT_H_
--- /dev/null
+// 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 <fst/isomorphic.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using IsomorphicInnerArgs =
+ args::Package<const FstClass &, const FstClass &, float>;
+
+using IsomorphicArgs = args::WithReturnValue<bool, IsomorphicInnerArgs>;
+
+template <class Arc>
+void Isomorphic(IsomorphicArgs *args) {
+ const Fst<Arc> &fst1 = *(args->args.arg1.GetFst<Arc>());
+ const Fst<Arc> &fst2 = *(args->args.arg2.GetFst<Arc>());
+ args->retval = Isomorphic(fst1, fst2, args->args.arg3);
+}
+
+bool Isomorphic(const FstClass &fst1, const FstClass &fst2,
+ float delta = kDelta);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_ISOMORPHIC_H_
--- /dev/null
+// 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 <memory>
+
+#include <fst/arc-map.h>
+#include <fst/state-map.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+template <class M>
+Fst<typename M::ToArc> *ArcMap(const Fst<typename M::FromArc> &fst,
+ const M &mapper) {
+ using ToArc = typename M::ToArc;
+ auto *ofst = new VectorFst<ToArc>;
+ ArcMap(fst, ofst, mapper);
+ return ofst;
+}
+
+template <class M>
+Fst<typename M::ToArc> *StateMap(const Fst<typename M::FromArc> &fst,
+ const M &mapper) {
+ using ToArc = typename M::ToArc;
+ auto *ofst = new VectorFst<ToArc>;
+ 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,
+ QUANTIZE_MAPPER,
+ RMWEIGHT_MAPPER,
+ SUPERFINAL_MAPPER,
+ TIMES_MAPPER,
+ TO_LOG_MAPPER,
+ TO_LOG64_MAPPER,
+ TO_STD_MAPPER
+};
+
+using MapInnerArgs =
+ args::Package<const FstClass &, MapType, float, const WeightClass &>;
+
+using MapArgs = args::WithReturnValue<FstClass *, MapInnerArgs>;
+
+template <class Arc>
+void Map(MapArgs *args) {
+ const Fst<Arc> &ifst = *(args->args.arg1.GetFst<Arc>());
+ MapType map_type = args->args.arg2;
+ float delta = args->args.arg3;
+ const auto weight = *(args->args.arg4.GetWeight<typename Arc::Weight>());
+ std::unique_ptr<Fst<Arc>> fst;
+ std::unique_ptr<Fst<LogArc>> lfst;
+ std::unique_ptr<Fst<Log64Arc>> l64fst;
+ std::unique_ptr<Fst<StdArc>> sfst;
+ if (map_type == ARC_SUM_MAPPER) {
+ fst.reset(script::StateMap(ifst, ArcSumMapper<Arc>(ifst)));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == ARC_UNIQUE_MAPPER) {
+ fst.reset(script::StateMap(ifst, ArcUniqueMapper<Arc>(ifst)));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == IDENTITY_MAPPER) {
+ fst.reset(script::ArcMap(ifst, IdentityArcMapper<Arc>()));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == INPUT_EPSILON_MAPPER) {
+ fst.reset(script::ArcMap(ifst, InputEpsilonMapper<Arc>()));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == INVERT_MAPPER) {
+ fst.reset(script::ArcMap(ifst, InvertWeightMapper<Arc>()));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == OUTPUT_EPSILON_MAPPER) {
+ fst.reset(script::ArcMap(ifst, OutputEpsilonMapper<Arc>()));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == PLUS_MAPPER) {
+ fst.reset(script::ArcMap(ifst, PlusMapper<Arc>(weight)));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == QUANTIZE_MAPPER) {
+ fst.reset(script::ArcMap(ifst, QuantizeMapper<Arc>(delta)));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == RMWEIGHT_MAPPER) {
+ fst.reset(script::ArcMap(ifst, RmWeightMapper<Arc>()));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == SUPERFINAL_MAPPER) {
+ fst.reset(script::ArcMap(ifst, SuperFinalMapper<Arc>()));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == TIMES_MAPPER) {
+ fst.reset(script::ArcMap(ifst, TimesMapper<Arc>(weight)));
+ args->retval = new FstClass(*fst);
+ } else if (map_type == TO_LOG_MAPPER) {
+ lfst.reset(script::ArcMap(ifst, WeightConvertMapper<Arc, LogArc>()));
+ args->retval = new FstClass(*lfst);
+ } else if (map_type == TO_LOG64_MAPPER) {
+ l64fst.reset(script::ArcMap(ifst, WeightConvertMapper<Arc, Log64Arc>()));
+ args->retval = new FstClass(*l64fst);
+ } else if (map_type == TO_STD_MAPPER) {
+ sfst.reset(script::ArcMap(ifst, WeightConvertMapper<Arc, StdArc>()));
+ args->retval = new FstClass(*sfst);
+ } else {
+ FSTERROR() << "Unknown mapper type: " << map_type;
+ VectorFst<Arc> *ofst = new VectorFst<Arc>;
+ ofst->SetProperties(kError, kError);
+ args->retval = new FstClass(*ofst);
+ }
+}
+
+FstClass *Map(const FstClass &fst, MapType map_type, float delta,
+ const WeightClass &weight);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_MAP_H_
--- /dev/null
+// 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 <fst/minimize.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using MinimizeArgs =
+ args::Package<MutableFstClass *, MutableFstClass *, float, bool>;
+
+template <class Arc>
+void Minimize(MinimizeArgs *args) {
+ MutableFst<Arc> *ofst1 = args->arg1->GetMutableFst<Arc>();
+ MutableFst<Arc> *ofst2 = args->arg2 ?
+ args->arg2->GetMutableFst<Arc>() : nullptr;
+ Minimize(ofst1, ofst2, args->arg3, args->arg4);
+}
+
+void Minimize(MutableFstClass *ofst1, MutableFstClass *ofst2 = nullptr,
+ float delta = kDelta, bool allow_nondet = false);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_MINIMIZE_H_
--- /dev/null
+// 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 <ostream>
+#include <sstream>
+#include <string>
+
+#include <fst/fstlib.h>
+#include <fst/util.h>
+
+DECLARE_string(fst_field_separator);
+
+namespace fst {
+
+// Print a binary FST in textual format (helper class for fstprint.cc).
+// WARNING: Stand-alone use of this class not recommended, most code should
+// read/write using the binary format which is much more efficient.
+template <class Arc>
+class FstPrinter {
+ public:
+ using StateId = typename Arc::StateId;
+ using Label = typename Arc::Label;
+ using Weight = typename Arc::Weight;
+
+ FstPrinter(const Fst<Arc> &fst, const SymbolTable *isyms,
+ const SymbolTable *osyms, const SymbolTable *ssyms, bool accep,
+ bool show_weight_one, const string &field_separator,
+ const string &missing_symbol = "")
+ : fst_(fst),
+ isyms_(isyms),
+ osyms_(osyms),
+ ssyms_(ssyms),
+ accep_(accep && fst.Properties(kAcceptor, true)),
+ ostrm_(nullptr),
+ show_weight_one_(show_weight_one),
+ sep_(field_separator),
+ missing_symbol_(missing_symbol) {}
+
+ // Prints FST to an output stream.
+ void Print(std::ostream *ostrm, const string &dest) {
+ ostrm_ = ostrm;
+ dest_ = dest;
+ const auto start = fst_.Start();
+ if (start == kNoStateId) return;
+ // Initial state first.
+ PrintState(start);
+ for (StateIterator<Fst<Arc>> siter(fst_); !siter.Done(); siter.Next()) {
+ const auto s = siter.Value();
+ if (s != start) PrintState(s);
+ }
+ }
+
+ private:
+ void PrintId(StateId id, const SymbolTable *syms, const char *name) const {
+ if (syms) {
+ string symbol = syms->Find(id);
+ if (symbol == "") {
+ if (missing_symbol_ == "") {
+ 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<Fst<Arc>> aiter(fst_, s); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ PrintStateId(s);
+ *ostrm_ << sep_;
+ PrintStateId(arc.nextstate);
+ *ostrm_ << sep_;
+ PrintILabel(arc.ilabel);
+ if (!accep_) {
+ *ostrm_ << sep_;
+ PrintOLabel(arc.olabel);
+ }
+ if (show_weight_one_ || arc.weight != Weight::One())
+ *ostrm_ << sep_ << arc.weight;
+ *ostrm_ << "\n";
+ output = true;
+ }
+ const auto weight = fst_.Final(s);
+ if (weight != Weight::Zero() || !output) {
+ PrintStateId(s);
+ if (show_weight_one_ || weight != Weight::One()) {
+ *ostrm_ << sep_ << weight;
+ }
+ *ostrm_ << "\n";
+ }
+ }
+
+ const Fst<Arc> &fst_;
+ const SymbolTable *isyms_; // ilabel symbol table.
+ const SymbolTable *osyms_; // olabel symbol table.
+ const SymbolTable *ssyms_; // slabel symbol table.
+ bool accep_; // Print as acceptor when possible?
+ std::ostream *ostrm_; // Text FST destination.
+ string dest_; // Text FST destination name.
+ bool show_weight_one_; // Print weights equal to Weight::One()?
+ string sep_; // Separator character between fields.
+ string missing_symbol_; // Symbol to print when lookup fails (default
+ // "" means raise error).
+ //
+ FstPrinter(const FstPrinter &) = delete;
+ FstPrinter &operator=(const FstPrinter &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_SCRIPT_PRINT_IMPL_H_
--- /dev/null
+// 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 <ostream>
+
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/print-impl.h>
+
+DECLARE_string(fst_field_separator);
+
+namespace fst {
+namespace script {
+
+// Note: it is safe to pass these strings as references because
+// this struct is only used to pass them deeper in the call graph.
+// Be sure you understand why this is so before using this struct
+// for anything else!
+struct FstPrinterArgs {
+ const FstClass &fst;
+ const SymbolTable *isyms;
+ const SymbolTable *osyms;
+ const SymbolTable *ssyms;
+ const bool accept;
+ const bool show_weight_one;
+ std::ostream *ostrm;
+ const string &dest;
+ const string &sep; // NOLINT
+ const string &missing_symbol;
+
+ FstPrinterArgs(const FstClass &fst, const SymbolTable *isyms,
+ const SymbolTable *osyms, const SymbolTable *ssyms,
+ bool accept, bool show_weight_one, std::ostream *ostrm,
+ const string &dest, const string &sep,
+ const string &missing_sym = "")
+ : fst(fst),
+ isyms(isyms),
+ osyms(osyms),
+ ssyms(ssyms),
+ accept(accept),
+ show_weight_one(show_weight_one),
+ ostrm(ostrm),
+ dest(dest),
+ sep(sep),
+ missing_symbol(missing_sym) {}
+};
+
+template <class Arc>
+void PrintFst(FstPrinterArgs *args) {
+ const Fst<Arc> &fst = *(args->fst.GetFst<Arc>());
+ fst::FstPrinter<Arc> fstprinter(
+ fst, args->isyms, args->osyms, args->ssyms, args->accept,
+ args->show_weight_one, args->sep, args->missing_symbol);
+ fstprinter.Print(args->ostrm, args->dest);
+}
+
+void PrintFst(const FstClass &fst, std::ostream &ostrm, const string &dest,
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ const SymbolTable *ssyms, bool accept, bool show_weight_one,
+ const string &missing_sym = "");
+
+// Below are two printing methods with useful defaults for a few of
+// the fst printer arguments.
+template <class Arc>
+void PrintFst(const Fst<Arc> &fst, std::ostream &os, const string& dest = "",
+ const SymbolTable *isyms = nullptr,
+ const SymbolTable *osyms = nullptr,
+ const SymbolTable *ssyms = nullptr) {
+ string sep = FLAGS_fst_field_separator.substr(0, 1);
+ fst::FstPrinter<Arc> fstprinter(fst, isyms, osyms, ssyms, true, true,
+ sep);
+ fstprinter.Print(&os, dest);
+}
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_PRINT_H_
--- /dev/null
+// 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 <fst/project.h> // for ProjectType
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using ProjectArgs = args::Package<MutableFstClass *, ProjectType>;
+
+template <class Arc>
+void Project(ProjectArgs *args) {
+ MutableFst<Arc> *ofst = args->arg1->GetMutableFst<Arc>();
+ Project(ofst, args->arg2);
+}
+
+void Project(MutableFstClass *ofst, ProjectType project_type);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_PROJECT_H_
--- /dev/null
+// 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 <memory>
+#include <vector>
+
+#include <fst/arcfilter.h>
+#include <fst/prune.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+struct PruneOptions {
+ const WeightClass &weight_threshold;
+ int64 state_threshold;
+ std::unique_ptr<const std::vector<WeightClass>> distance;
+ float delta;
+
+ PruneOptions(const WeightClass &w, int64 s,
+ std::vector<WeightClass> *d = nullptr, float e = kDelta)
+ : weight_threshold(w), state_threshold(s), distance(d), delta(e) {}
+
+ private:
+ PruneOptions(); // Forbids this.
+};
+
+// This function transforms a script-land PruneOptions into a lib-land
+// PruneOptions. If the original opts.distance is not null, a new distance will
+// be created with new; the client is responsible for deleting this.
+
+template <class Arc>
+fst::PruneOptions<Arc, AnyArcFilter<Arc>> ConvertPruneOptions(
+ const PruneOptions &opts) {
+ using Weight = typename Arc::Weight;
+ const auto weight_threshold = *(opts.weight_threshold.GetWeight<Weight>());
+ std::unique_ptr<std::vector<Weight>> distance;
+ if (opts.distance) {
+ distance.reset(new std::vector<Weight>(opts.distance->size()));
+ for (auto i = 0; i < opts.distance->size(); ++i)
+ (*distance)[i] = *((*opts.distance)[i].GetWeight<Weight>());
+ }
+ return fst::PruneOptions<Arc, AnyArcFilter<Arc>>(
+ weight_threshold, opts.state_threshold, AnyArcFilter<Arc>(),
+ distance.get(), opts.delta);
+}
+
+// 1
+using PruneArgs1 = args::Package<MutableFstClass *, const PruneOptions &>;
+
+template <class Arc>
+void Prune(PruneArgs1 *args) {
+ MutableFst<Arc> *ofst = args->arg1->GetMutableFst<Arc>();
+ fst::PruneOptions<Arc, AnyArcFilter<Arc>> opts =
+ ConvertPruneOptions<Arc>(args->arg2);
+ Prune(ofst, opts);
+}
+
+// 2
+using PruneArgs2 =
+ args::Package<const FstClass &, MutableFstClass *, const PruneOptions &>;
+
+template <class Arc>
+void Prune(PruneArgs2 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ fst::PruneOptions<Arc, AnyArcFilter<Arc>> opts =
+ ConvertPruneOptions<Arc>(args->arg3);
+ Prune(ifst, ofst, opts);
+}
+
+// 3
+using PruneArgs3 = args::Package<const FstClass &, MutableFstClass *,
+ const WeightClass &, int64, float>;
+
+template <class Arc>
+void Prune(PruneArgs3 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ typename Arc::Weight weight_threshold =
+ *(args->arg3.GetWeight<typename Arc::Weight>());
+ Prune(ifst, ofst, weight_threshold, args->arg4, args->arg5);
+}
+
+// 4
+using PruneArgs4 =
+ args::Package<MutableFstClass *, const WeightClass &, int64, float>;
+
+template <class Arc>
+void Prune(PruneArgs4 *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ typename Arc::Weight weight_threshold =
+ *(args->arg2.GetWeight<typename Arc::Weight>());
+ Prune(fst, weight_threshold, args->arg3, args->arg4);
+}
+
+// 1
+void Prune(MutableFstClass *fst, const PruneOptions &opts);
+
+// 2
+void Prune(const FstClass &ifst, MutableFstClass *fst,
+ const PruneOptions &opts);
+
+// 3
+void Prune(const FstClass &ifst, MutableFstClass *ofst,
+ const WeightClass &weight_threshold,
+ int64 state_threshold = kNoStateId,
+ float delta = kDelta);
+
+// 4
+void Prune(MutableFstClass *fst, const WeightClass &weight_threshold,
+ int64 state_threshold, float delta);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_PRUNE_H_
--- /dev/null
+// 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 <fst/push.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+// 1
+using PushArgs1 = args::Package<MutableFstClass *, ReweightType, float, bool>;
+
+template <class Arc>
+void Push(PushArgs1 *args) {
+ MutableFst<Arc> *ofst = args->arg1->GetMutableFst<Arc>();
+ if (args->arg2 == REWEIGHT_TO_FINAL)
+ fst::Push(ofst, REWEIGHT_TO_FINAL, args->arg3, args->arg4);
+ else
+ fst::Push(ofst, REWEIGHT_TO_INITIAL, args->arg3, args->arg4);
+}
+
+// 2
+using PushArgs2 = args::Package<const FstClass &, MutableFstClass *, uint32,
+ ReweightType, float>;
+
+template <class Arc>
+void Push(PushArgs2 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ if (args->arg4 == REWEIGHT_TO_FINAL)
+ fst::Push<Arc, REWEIGHT_TO_FINAL>(ifst, ofst, args->arg3, args->arg5);
+ else
+ fst::Push<Arc, REWEIGHT_TO_INITIAL>(ifst, ofst, args->arg3, args->arg5);
+}
+
+// 1
+void Push(MutableFstClass *ofst, ReweightType type, float delta = kDelta,
+ bool remove_total_weight = false);
+
+// 2
+void Push(const FstClass &ifst, MutableFstClass *ofst, uint32 flags,
+ ReweightType dir, float delta);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_PUSH_H_
--- /dev/null
+// 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 <climits>
+#include <ctime>
+
+#include <fst/randequivalent.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+using RandEquivalentInnerArgs1 =
+ args::Package<const FstClass &, const FstClass &, int32, float, time_t,
+ const RandGenOptions<RandArcSelection> &, bool *>;
+
+using RandEquivalentArgs1 =
+ args::WithReturnValue<bool, RandEquivalentInnerArgs1>;
+
+template <class Arc>
+void RandEquivalent(RandEquivalentArgs1 *args) {
+ const Fst<Arc> &fst1 = *(args->args.arg1.GetFst<Arc>());
+ const Fst<Arc> &fst2 = *(args->args.arg2.GetFst<Arc>());
+ const auto seed = args->args.arg5;
+ const auto &opts = args->args.arg6;
+ if (opts.selector == UNIFORM_ARC_SELECTOR) {
+ const UniformArcSelector<Arc> selector(seed);
+ const RandGenOptions<UniformArcSelector<Arc>> ropts(selector,
+ opts.max_length);
+ args->retval = RandEquivalent(fst1, fst2, args->args.arg3, args->args.arg4,
+ ropts, args->args.arg7);
+ } else if (opts.selector == FAST_LOG_PROB_ARC_SELECTOR) {
+ const FastLogProbArcSelector<Arc> selector(seed);
+ const RandGenOptions<FastLogProbArcSelector<Arc>> ropts(selector,
+ opts.max_length);
+ args->retval = RandEquivalent(fst1, fst2, args->args.arg3, args->args.arg4,
+ ropts, args->args.arg7);
+ } else {
+ const LogProbArcSelector<Arc> selector(seed);
+ const RandGenOptions<LogProbArcSelector<Arc>> ropts(selector,
+ opts.max_length);
+ args->retval = RandEquivalent(fst1, fst2, args->args.arg3, args->args.arg4,
+ ropts, args->args.arg7);
+ }
+}
+
+// 2
+using RandEquivalentInnerArgs2 =
+ args::Package<const FstClass &, const FstClass &, int32, float, time_t,
+ int32, bool *>;
+
+using RandEquivalentArgs2 =
+ args::WithReturnValue<bool, RandEquivalentInnerArgs2>;
+
+template <class Arc>
+void RandEquivalent(RandEquivalentArgs2 *args) {
+ const Fst<Arc> &fst1 = *(args->args.arg1.GetFst<Arc>());
+ const Fst<Arc> &fst2 = *(args->args.arg2.GetFst<Arc>());
+ args->retval = fst::RandEquivalent(fst1, fst2, args->args.arg3,
+ args->args.arg4, args->args.arg5,
+ args->args.arg6, args->args.arg7);
+}
+
+// 1
+bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath = 1,
+ float delta = kDelta, time_t seed = time(nullptr),
+ const RandGenOptions<RandArcSelection> &opts =
+ RandGenOptions<RandArcSelection>(UNIFORM_ARC_SELECTOR),
+ bool *error = nullptr);
+
+// 2
+bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath = 1,
+ float delta = kDelta, time_t seed = time(nullptr),
+ int32 max_length = INT32_MAX, bool *error = nullptr);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_RANDEQUIVALENT_H_
--- /dev/null
+// 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 <ctime>
+
+#include <fst/randgen.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+using RandGenArgs = args::Package<const FstClass &, MutableFstClass *, time_t,
+ const RandGenOptions<RandArcSelection> &>;
+
+template <class Arc>
+void RandGen(RandGenArgs *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ time_t seed = args->arg3;
+ const RandGenOptions<RandArcSelection> &opts = args->arg4;
+ if (opts.selector == UNIFORM_ARC_SELECTOR) {
+ const UniformArcSelector<Arc> selector(seed);
+ const RandGenOptions<UniformArcSelector<Arc>> ropts(
+ selector, opts.max_length, opts.npath, opts.weighted,
+ opts.remove_total_weight);
+ RandGen(ifst, ofst, ropts);
+ } else if (opts.selector == FAST_LOG_PROB_ARC_SELECTOR) {
+ const FastLogProbArcSelector<Arc> selector(seed);
+ const RandGenOptions<FastLogProbArcSelector<Arc>> ropts(
+ selector, opts.max_length, opts.npath, opts.weighted,
+ opts.remove_total_weight);
+ RandGen(ifst, ofst, ropts);
+ } else {
+ const LogProbArcSelector<Arc> selector(seed);
+ const RandGenOptions<LogProbArcSelector<Arc>> ropts(
+ selector, opts.max_length, opts.npath, opts.weighted,
+ opts.remove_total_weight);
+ RandGen(ifst, ofst, ropts);
+ }
+}
+
+void RandGen(const FstClass &ifst, MutableFstClass *ofst,
+ time_t seed = time(nullptr),
+ const RandGenOptions<RandArcSelection> &opts =
+ RandGenOptions<RandArcSelection>(UNIFORM_ARC_SELECTOR));
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_RANDGEN_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_SCRIPT_REGISTER_H_
+#define FST_SCRIPT_REGISTER_H_
+
+#include <istream>
+#include <string>
+
+#include <fst/generic-register.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/weight-class.h>
+
+// Holds methods and classes responsible for maintaining
+// the register for FstClass arc types.
+
+namespace fst {
+namespace script {
+
+// Registers for reading and converting various kinds of FST classes.
+
+// This class definition is to avoid a nested class definition inside
+// the IORegistration struct.
+
+template <class Reader, class Creator, class Converter>
+struct FstClassRegEntry {
+ Reader reader;
+ Creator creator;
+ Converter converter;
+
+ FstClassRegEntry(Reader r, Creator cr, Converter co)
+ : reader(r), creator(cr), converter(co) {}
+
+ FstClassRegEntry()
+ : reader(NullReader), creator(NullCreator), converter(NullConverter) {}
+
+ // Null-returning reader, creator, and converter, used when registry lookup
+ // fails.
+
+ template <class FstClassType>
+ static FstClassType *NullReader(std::istream &strm,
+ const FstReadOptions &opts) {
+ return nullptr;
+ }
+
+ static FstClassImplBase *NullCreator() { return nullptr; }
+
+ static FstClassImplBase *NullConverter(const FstClass &other) {
+ return nullptr;
+ }
+};
+
+template <class Reader, class Creator, class Converter>
+class FstClassIORegister
+ : public GenericRegister<string,
+ FstClassRegEntry<Reader, Creator, Converter>,
+ FstClassIORegister<Reader, Creator, Converter>> {
+ public:
+ Reader GetReader(const string &arc_type) const {
+ return this->GetEntry(arc_type).reader;
+ }
+
+ Creator GetCreator(const string &arc_type) const {
+ return this->GetEntry(arc_type).creator;
+ }
+
+ Converter GetConverter(const string &arc_type) const {
+ return this->GetEntry(arc_type).converter;
+ }
+
+ protected:
+ string ConvertKeyToSoFilename(const string &key) const override {
+ 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 <class FstClassType>
+struct IORegistration {
+ using Reader = FstClassType *(*)(std::istream &stream,
+ const FstReadOptions &opts);
+
+ using Creator = FstClassImplBase *(*)();
+
+ using Converter = FstClassImplBase *(*)(const FstClass &other);
+
+ using Entry = FstClassRegEntry<Reader, Creator, Converter>;
+
+ // FST class Register.
+ using Register = FstClassIORegister<Reader, Creator, Converter>;
+
+ // FST class Register-er.
+ using Registerer =
+ GenericRegisterer<FstClassIORegister<Reader, Creator, Converter>>;
+};
+
+#define REGISTER_FST_CLASS(Class, Arc) \
+ static IORegistration<Class>::Registerer Class##_##Arc##_registerer( \
+ Arc::Type(), \
+ IORegistration<Class>::Entry(Class::Read<Arc>, Class::Create<Arc>, \
+ Class::Convert<Arc>))
+
+#define REGISTER_FST_CLASSES(Arc) \
+ REGISTER_FST_CLASS(FstClass, Arc); \
+ REGISTER_FST_CLASS(MutableFstClass, Arc); \
+ REGISTER_FST_CLASS(VectorFstClass, Arc);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_REGISTER_H_
--- /dev/null
+// 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 <algorithm>
+#include <utility>
+#include <vector>
+
+#include <fst/relabel.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+// 1
+using RelabelArgs1 =
+ args::Package<MutableFstClass *, const SymbolTable *, const SymbolTable *,
+ bool, const SymbolTable *, const SymbolTable *, bool>;
+
+template <class Arc>
+void Relabel(RelabelArgs1 *args) {
+ MutableFst<Arc> *ofst = args->arg1->GetMutableFst<Arc>();
+ Relabel(ofst, args->arg2, args->arg3, args->arg4, args->arg5, args->arg6,
+ args->arg7);
+}
+
+using LabelPair = std::pair<int64, int64>;
+
+// 2
+using RelabelArgs2 =
+ args::Package<MutableFstClass *, const std::vector<LabelPair> &,
+ const std::vector<LabelPair> &>;
+
+template <class Arc>
+void Relabel(RelabelArgs2 *args) {
+ MutableFst<Arc> *ofst = args->arg1->GetMutableFst<Arc>();
+ using LabelPair = std::pair<typename Arc::Label, typename Arc::Label>;
+ // In case the MutableFstClass::Label is not the same as Arc::Label,
+ // make a copy.
+ std::vector<LabelPair> typed_ipairs(args->arg2.size());
+ std::copy(args->arg2.begin(), args->arg2.end(), typed_ipairs.begin());
+ std::vector<LabelPair> typed_opairs(args->arg3.size());
+ std::copy(args->arg3.begin(), args->arg3.end(), typed_opairs.begin());
+ Relabel(ofst, typed_ipairs, typed_opairs);
+}
+
+// 3
+using RelabelArgs3 =
+ args::Package<MutableFstClass *, const SymbolTable *, const SymbolTable *>;
+template <class Arc>
+void Relabel(args::Package<MutableFstClass *, const SymbolTable *,
+ const SymbolTable *> *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ Relabel(fst, args->arg2, args->arg3);
+}
+
+// 1
+void Relabel(MutableFstClass *ofst, const SymbolTable *old_isymbols,
+ const SymbolTable *new_isymbols, bool attach_new_isymbols,
+ const SymbolTable *old_osymbols, const SymbolTable *new_osymbols,
+ bool attach_new_osymbols);
+
+// 2
+void Relabel(MutableFstClass *ofst, const std::vector<LabelPair> &ipairs,
+ const std::vector<LabelPair> &opairs);
+
+// 3
+void Relabel(MutableFstClass *fst, const SymbolTable *new_isymbols,
+ const SymbolTable *new_osymbols);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_RELABEL_H_
--- /dev/null
+// 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 <utility>
+#include <vector>
+
+#include <fst/replace.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+struct ReplaceOptions {
+ int64 root; // Root rule for expansion.
+ fst::ReplaceLabelType call_label_type; // How to label call arc.
+ fst::ReplaceLabelType return_label_type; // How to label return arc.
+ int64 return_label; // Specifies return arc label.
+
+ explicit ReplaceOptions(int64 r,
+ fst::ReplaceLabelType c = fst::REPLACE_LABEL_INPUT,
+ fst::ReplaceLabelType t = fst::REPLACE_LABEL_NEITHER,
+ int64 l = 0)
+ : root(r), call_label_type(c), return_label_type(t), return_label(l) {}
+};
+
+using LabelFstClassPair = std::pair<int64, const FstClass *>;
+
+using ReplaceArgs = args::Package<const std::vector<LabelFstClassPair> &,
+ MutableFstClass *, const ReplaceOptions &>;
+
+template <class Arc>
+void Replace(ReplaceArgs *args) {
+ using LabelFstPair = std::pair<typename Arc::Label, const Fst<Arc> *>;
+ // Now that we know the arc type, we construct a vector of
+ // std::pair<real label, real fst> that the real Replace will use.
+ const std::vector<LabelFstClassPair> &untyped_pairs = args->arg1;
+ auto size = untyped_pairs.size();
+ std::vector<LabelFstPair> typed_pairs(size);
+ for (auto i = 0; i < size; ++i) {
+ typed_pairs[i].first = untyped_pairs[i].first; // Converts label.
+ typed_pairs[i].second = untyped_pairs[i].second->GetFst<Arc>();
+ }
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ const ReplaceOptions &opts = args->arg3;
+ ReplaceFstOptions<Arc> typed_opts(opts.root, opts.call_label_type,
+ opts.return_label_type, opts.return_label);
+ ReplaceFst<Arc> rfst(typed_pairs, typed_opts);
+ // Checks for cyclic dependencies before attempting expansino.
+ 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<LabelFstClassPair> &pairs,
+ MutableFstClass *ofst, const ReplaceOptions &opts);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_REPLACE_H_
--- /dev/null
+// 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 <fst/reverse.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using ReverseArgs = args::Package<const FstClass &, MutableFstClass *, bool>;
+
+template <class Arc>
+void Reverse(ReverseArgs *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ bool require_superinitial = args->arg3;
+ Reverse(ifst, ofst, require_superinitial);
+}
+
+void Reverse(const FstClass &ifst, MutableFstClass *ofst,
+ bool require_superinitial = true);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_REVERSE_H_
--- /dev/null
+// 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 <vector>
+
+#include <fst/reweight.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+using ReweightArgs =
+ args::Package<MutableFstClass *, const std::vector<WeightClass> &,
+ ReweightType>;
+
+template <class Arc>
+void Reweight(ReweightArgs *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ using Weight = typename Arc::Weight;
+ std::vector<Weight> potentials(args->arg2.size());
+ for (auto i = 0; i < args->arg2.size(); ++i)
+ potentials[i] = *(args->arg2[i].GetWeight<Weight>());
+ Reweight(fst, potentials, args->arg3);
+}
+
+void Reweight(MutableFstClass *fst, const std::vector<WeightClass> &potential,
+ ReweightType reweight_type);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_REWEIGHT_H_
--- /dev/null
+// 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 <vector>
+
+#include <fst/queue.h>
+#include <fst/rmepsilon.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/shortest-distance.h> // for ShortestDistanceOptions
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+struct RmEpsilonOptions : public fst::script::ShortestDistanceOptions {
+ bool connect;
+ const WeightClass &weight_threshold;
+ int64 state_threshold;
+
+ RmEpsilonOptions(QueueType qt, float d, bool c, const WeightClass &w,
+ int64 n = kNoStateId)
+ : ShortestDistanceOptions(qt, EPSILON_ARC_FILTER, kNoStateId, d),
+ connect(c), weight_threshold(w), state_threshold(n) {}
+};
+
+// This function transforms a script-land RmEpsilonOptions into a lib-land
+// RmEpsilonOptions, and then calls the operation.
+template <class Arc>
+void RmEpsilonHelper(MutableFst<Arc> *fst,
+ std::vector<typename Arc::Weight> *distance,
+ const RmEpsilonOptions &opts) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ const Weight weight_threshold = *(opts.weight_threshold.GetWeight<Weight>());
+ switch (opts.queue_type) {
+ case AUTO_QUEUE: {
+ AutoQueue<StateId> queue(*fst, distance, EpsilonArcFilter<Arc>());
+ fst::RmEpsilonOptions<Arc, AutoQueue<StateId>> ropts(
+ &queue, opts.delta, opts.connect, weight_threshold,
+ opts.state_threshold);
+ RmEpsilon(fst, distance, ropts);
+ break;
+ }
+ case FIFO_QUEUE: {
+ FifoQueue<StateId> queue;
+ fst::RmEpsilonOptions<Arc, FifoQueue<StateId>> ropts(
+ &queue, opts.delta, opts.connect, weight_threshold,
+ opts.state_threshold);
+ RmEpsilon(fst, distance, ropts);
+ break;
+ }
+ case LIFO_QUEUE: {
+ LifoQueue<StateId> queue;
+ fst::RmEpsilonOptions<Arc, LifoQueue<StateId>> ropts(
+ &queue, opts.delta, opts.connect, weight_threshold,
+ opts.state_threshold);
+ RmEpsilon(fst, distance, ropts);
+ break;
+ }
+ case SHORTEST_FIRST_QUEUE: {
+ NaturalShortestFirstQueue<StateId, Weight> queue(*distance);
+ fst::RmEpsilonOptions<Arc, NaturalShortestFirstQueue<StateId, Weight>>
+ ropts(&queue, opts.delta, opts.connect, weight_threshold,
+ opts.state_threshold);
+ RmEpsilon(fst, distance, ropts);
+ break;
+ }
+ case STATE_ORDER_QUEUE: {
+ StateOrderQueue<StateId> queue;
+ fst::RmEpsilonOptions<Arc, StateOrderQueue<StateId>> ropts(
+ &queue, opts.delta, opts.connect, weight_threshold,
+ opts.state_threshold);
+ RmEpsilon(fst, distance, ropts);
+ break;
+ }
+ case TOP_ORDER_QUEUE: {
+ TopOrderQueue<StateId> queue(*fst, EpsilonArcFilter<Arc>());
+ fst::RmEpsilonOptions<Arc, TopOrderQueue<StateId>> ropts(
+ &queue, opts.delta, opts.connect, weight_threshold,
+ opts.state_threshold);
+ RmEpsilon(fst, distance, ropts);
+ break;
+ }
+ default:
+ FSTERROR() << "Unknown queue type: " << opts.queue_type;
+ fst->SetProperties(kError, kError);
+ }
+}
+
+// 1: Full signature with RmEpsilonOptions.
+using RmEpsilonArgs1 = args::Package<const FstClass &, MutableFstClass *, bool,
+ const RmEpsilonOptions &>;
+
+template <class Arc>
+void RmEpsilon(RmEpsilonArgs1 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ std::vector<typename Arc::Weight> distance;
+ if (args->arg3) {
+ VectorFst<Arc> rfst;
+ Reverse(ifst, &rfst, false);
+ RmEpsilonHelper(&rfst, &distance, args->arg4);
+ Reverse(rfst, ofst, false);
+ if (rfst.NumStates() != ofst->NumStates())
+ RmEpsilonHelper(ofst, &distance, args->arg4);
+ } else {
+ *ofst = ifst;
+ RmEpsilonHelper(ofst, &distance, args->arg4);
+ }
+}
+
+// 2: Full signature with flat arguments.
+using RmEpsilonArgs2 =
+ args::Package<MutableFstClass *, bool, const WeightClass, int64, float>;
+
+template <class Arc>
+void RmEpsilon(RmEpsilonArgs2 *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ typename Arc::Weight weight = *(args->arg3.GetWeight<typename Arc::Weight>());
+ RmEpsilon(fst, args->arg2, weight, args->arg4, args->arg5);
+}
+
+// 3: Full signature with RmEpsilonOptions and weight vector.
+using RmEpsilonArgs3 =
+ args::Package<MutableFstClass *, std::vector<WeightClass> *,
+ const RmEpsilonOptions &>;
+
+template <class Arc>
+void RmEpsilon(RmEpsilonArgs3 *args) {
+ MutableFst<Arc> *fst = args->arg1->GetMutableFst<Arc>();
+ const RmEpsilonOptions &opts = args->arg3;
+ std::vector<typename Arc::Weight> weights;
+ RmEpsilonHelper(fst, &weights, opts);
+ // Copy the weights back....
+ args->arg2->resize(weights.size());
+ for (auto i = 0; i < weights.size(); ++i) {
+ (*args->arg2)[i] = WeightClass(weights[i]);
+ }
+}
+
+// 1
+void RmEpsilon(const FstClass &ifst, MutableFstClass *ofst, bool reverse,
+ const RmEpsilonOptions &opts);
+
+// 2
+void RmEpsilon(MutableFstClass *fst, bool connect,
+ const WeightClass &weight_threshold,
+ int64 state_threshold = fst::kNoStateId,
+ float delta = fst::kDelta);
+
+// #2 signature with default WeightClass argument.
+void RmEpsilon(MutableFstClass *fst, bool connect,
+ int64 state_threshold = fst::kNoStateId,
+ float delta = fst::kDelta);
+
+// 3
+void RmEpsilon(MutableFstClass *fst, std::vector<WeightClass> *distance,
+ const RmEpsilonOptions &opts);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_RMEPSILON_H_
--- /dev/null
+// 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 = args::Package<const FstClass &, MutableFstClass *>;
+//
+// 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<class Arc>
+// void Foo(FooArgs *args) {
+// // Pulls out the actual, arc-templated FSTs.
+// const Fst<Arc> &ifst = args->arg1.GetFst<Arc>();
+// MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+// // 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<Operation<FooArgs>>("Foo", ifst->ArcType(), &args);
+// }
+//
+// The Apply<> function template takes care of the link between 2 and 3,
+// provided you also have:
+//
+// 4) A registration for your new operation, on the arc types you care about.
+// This can be provided easily by the REGISTER_FST_OPERATION macro in
+// operations.h:
+//
+// REGISTER_FST_OPERATION(Foo, StdArc, FooArgs);
+// REGISTER_FST_OPERATION(Foo, MyArc, FooArgs);
+// // .. etc
+//
+//
+// That's it! Now when you call Foo(const FstClass &, MutableFstClass *),
+// it dispatches (in #3) via the Apply<> function to the correct
+// instantiation of the template function in #2.
+//
+
+#ifndef FST_SCRIPT_SCRIPT_IMPL_H_
+#define FST_SCRIPT_SCRIPT_IMPL_H_
+
+//
+// This file contains general-purpose templates which are used in the
+// implementation of the operations.
+//
+
+#include <string>
+#include <utility>
+
+#include <fst/generic-register.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+#include <fst/types.h>
+
+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<string, string> is understood to be the operation name and arc
+// type; subclasses (or typedefs) need only provide the operation signature.
+
+template <class OperationSignature>
+class GenericOperationRegister
+ : public GenericRegister<std::pair<string, string>, OperationSignature,
+ GenericOperationRegister<OperationSignature>> {
+ public:
+ void RegisterOperation(const string &operation_name, const string &arc_type,
+ OperationSignature op) {
+ this->SetEntry(std::make_pair(operation_name, arc_type), op);
+ }
+
+ OperationSignature GetOperation(const string &operation_name,
+ const string &arc_type) {
+ return this->GetEntry(std::make_pair(operation_name, arc_type));
+ }
+
+ protected:
+ string ConvertKeyToSoFilename(
+ const std::pair<string, string> &key) const override {
+ // Uses the old-style FST for now.
+ string legal_type(key.second); // The arc type.
+ ConvertToLegalCSymbol(&legal_type);
+ return legal_type + "-arc.so";
+ }
+};
+
+// Operation package: everything you need to register a new type of operation.
+// The ArgPack should be the type that's passed into each wrapped function;
+// for instance, it might be a struct containing all the args. It's always
+// passed by pointer, so const members should be used to enforce constness where
+// it's needed. Return values should be implemented as a member of ArgPack as
+// well.
+
+template <class Args>
+struct Operation {
+ using ArgPack = Args;
+
+ using OpType = void (*)(ArgPack *args);
+
+ // The register (hash) type.
+ using Register = GenericOperationRegister<OpType>;
+
+ // The register-er type
+ using Registerer = GenericRegisterer<Register>;
+};
+
+// Macro for registering new types of operations.
+
+#define REGISTER_FST_OPERATION(Op, Arc, ArgPack) \
+ static fst::script::Operation<ArgPack>::Registerer \
+ arc_dispatched_operation_##ArgPack##Op##Arc##_registerer \
+ (std::make_pair(#Op, Arc::Type()), Op<Arc>)
+
+// Template function to apply an operation by name.
+
+template <class OpReg>
+void Apply(const string &op_name, const string &arc_type,
+ typename OpReg::ArgPack *args) {
+ typename OpReg::Register *reg = OpReg::Register::GetRegister();
+ typename OpReg::OpType op = reg->GetOperation(op_name, arc_type);
+ if (!op) {
+ FSTERROR() << "No operation found for " << op_name << " on "
+ << "arc type " << arc_type;
+ return;
+ }
+ op(args);
+}
+
+// Helper that logs to ERROR if the arc types of m and n don't match. The
+// op_name is used to construct the error message.
+template <class M, class N>
+bool ArcTypesMatch(const M &m, const N &n, const string &op_name) {
+ if (m.ArcType() != n.ArcType()) {
+ FSTERROR() << "Arguments with non-matching arc types passed to "
+ << op_name << ":\t" << m.ArcType() << " and " << n.ArcType();
+ return false;
+ }
+ return true;
+}
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_SCRIPT_IMPL_H_
--- /dev/null
+// 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 <vector>
+
+#include <fst/queue.h> // for QueueType
+#include <fst/shortest-distance.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/prune.h> // for ArcFilterType
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+enum ArcFilterType {
+ ANY_ARC_FILTER,
+ EPSILON_ARC_FILTER,
+ INPUT_EPSILON_ARC_FILTER,
+ OUTPUT_EPSILON_ARC_FILTER
+};
+
+// See nlp/fst/lib/shortest-distance.h for the template options class
+// that this one shadows
+struct ShortestDistanceOptions {
+ const QueueType queue_type;
+ const ArcFilterType arc_filter_type;
+ const int64 source;
+ const float delta;
+ const bool first_path;
+
+ ShortestDistanceOptions(QueueType qt, ArcFilterType aft, int64 s, float d)
+ : queue_type(qt), arc_filter_type(aft), source(s), delta(d),
+ first_path(false) {}
+};
+
+// 1
+using ShortestDistanceArgs1 =
+ args::Package<const FstClass &, std::vector<WeightClass> *,
+ const ShortestDistanceOptions &>;
+
+template <class Queue, class Arc, class ArcFilter>
+struct QueueConstructor {
+ static Queue *Construct(const Fst<Arc> &,
+ const std::vector<typename Arc::Weight> *) {
+ return new Queue();
+ }
+};
+
+// Specializations to deal with AutoQueue, NaturalShortestFirstQueue,
+// and TopOrderQueue's different constructors
+template <class Arc, class ArcFilter>
+struct QueueConstructor<AutoQueue<typename Arc::StateId>, Arc, ArcFilter> {
+ // template<class Arc, class ArcFilter>
+ static AutoQueue<typename Arc::StateId> *Construct(
+ const Fst<Arc> &fst, const std::vector<typename Arc::Weight> *distance) {
+ return new AutoQueue<typename Arc::StateId>(fst, distance, ArcFilter());
+ }
+};
+
+template <class Arc, class ArcFilter>
+struct QueueConstructor<
+ NaturalShortestFirstQueue<typename Arc::StateId, typename Arc::Weight>, Arc,
+ ArcFilter> {
+ // template<class Arc, class ArcFilter>
+ static NaturalShortestFirstQueue<typename Arc::StateId, typename Arc::Weight>
+ *Construct(const Fst<Arc> &fst,
+ const std::vector<typename Arc::Weight> *distance) {
+ return new NaturalShortestFirstQueue<typename Arc::StateId,
+ typename Arc::Weight>(*distance);
+ }
+};
+
+template <class Arc, class ArcFilter>
+struct QueueConstructor<TopOrderQueue<typename Arc::StateId>, Arc, ArcFilter> {
+ // template<class Arc, class ArcFilter>
+ static TopOrderQueue<typename Arc::StateId> *Construct(
+ const Fst<Arc> &fst, const std::vector<typename Arc::Weight> *weights) {
+ return new TopOrderQueue<typename Arc::StateId>(fst, ArcFilter());
+ }
+};
+
+template <class Arc, class Queue>
+void ShortestDistanceHelper(ShortestDistanceArgs1 *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ const ShortestDistanceOptions &opts = args->arg3;
+ std::vector<typename Arc::Weight> weights;
+ switch (opts.arc_filter_type) {
+ case ANY_ARC_FILTER: {
+ std::unique_ptr<Queue> queue(QueueConstructor<Queue, Arc,
+ AnyArcFilter<Arc>>::Construct(fst, &weights));
+ fst::ShortestDistanceOptions<Arc, Queue, AnyArcFilter<Arc>> sdopts(
+ queue.get(), AnyArcFilter<Arc>(), opts.source, opts.delta);
+ ShortestDistance(fst, &weights, sdopts);
+ break;
+ }
+ case EPSILON_ARC_FILTER: {
+ std::unique_ptr<Queue> queue(QueueConstructor<Queue, Arc,
+ AnyArcFilter<Arc>>::Construct(fst, &weights));
+ fst::ShortestDistanceOptions<Arc, Queue, EpsilonArcFilter<Arc>>
+ sdopts(queue.get(), EpsilonArcFilter<Arc>(), opts.source, opts.delta);
+ ShortestDistance(fst, &weights, sdopts);
+ break;
+ }
+ case INPUT_EPSILON_ARC_FILTER: {
+ std::unique_ptr<Queue> queue(QueueConstructor<Queue, Arc,
+ InputEpsilonArcFilter<Arc>>::Construct(fst, &weights));
+ fst::ShortestDistanceOptions<Arc, Queue, InputEpsilonArcFilter<Arc>>
+ sdopts(queue.get(), InputEpsilonArcFilter<Arc>(), opts.source,
+ opts.delta);
+ ShortestDistance(fst, &weights, sdopts);
+ break;
+ }
+ case OUTPUT_EPSILON_ARC_FILTER: {
+ std::unique_ptr<Queue> queue(QueueConstructor<Queue, Arc,
+ OutputEpsilonArcFilter<Arc>>::Construct(fst, &weights));
+ fst::ShortestDistanceOptions<Arc, Queue, OutputEpsilonArcFilter<Arc>>
+ sdopts(queue.get(), OutputEpsilonArcFilter<Arc>(), opts.source,
+ opts.delta);
+ ShortestDistance(fst, &weights, sdopts);
+ break;
+ }
+ }
+ // Copies the weights back.
+ args->arg2->resize(weights.size());
+ for (auto i = 0; i < weights.size(); ++i) {
+ (*args->arg2)[i] = WeightClass(weights[i]);
+ }
+}
+
+template <class Arc>
+void ShortestDistance(ShortestDistanceArgs1 *args) {
+ const ShortestDistanceOptions &opts = args->arg3;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ // Must consider (opts.queue_type x opts.filter_type) options.
+ switch (opts.queue_type) {
+ default:
+ FSTERROR() << "Unknown queue type: " << opts.queue_type;
+ case AUTO_QUEUE:
+ ShortestDistanceHelper<Arc, AutoQueue<StateId>>(args);
+ return;
+ case FIFO_QUEUE:
+ ShortestDistanceHelper<Arc, FifoQueue<StateId>>(args);
+ return;
+ case LIFO_QUEUE:
+ ShortestDistanceHelper<Arc, LifoQueue<StateId>>(args);
+ return;
+ case SHORTEST_FIRST_QUEUE:
+ ShortestDistanceHelper<Arc, NaturalShortestFirstQueue<StateId, Weight>>(
+ args);
+ return;
+ case STATE_ORDER_QUEUE:
+ ShortestDistanceHelper<Arc, StateOrderQueue<StateId>>(args);
+ return;
+ case TOP_ORDER_QUEUE:
+ ShortestDistanceHelper<Arc, TopOrderQueue<StateId>>(args);
+ return;
+ }
+}
+
+// 2
+using ShortestDistanceArgs2 =
+ args::Package<const FstClass &, std::vector<WeightClass> *, bool, double>;
+
+template <class Arc>
+void ShortestDistance(ShortestDistanceArgs2 *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ std::vector<typename Arc::Weight> distance;
+ ShortestDistance(fst, &distance, args->arg3, args->arg4);
+ // Converts the typed weights back to WeightClass instances.
+ std::vector<WeightClass> *retval = args->arg2;
+ retval->resize(distance.size());
+ for (size_t i = 0; i < distance.size(); ++i)
+ (*retval)[i] = WeightClass(distance[i]);
+}
+
+// 1
+void ShortestDistance(const FstClass &fst, std::vector<WeightClass> *distance,
+ const ShortestDistanceOptions &opts);
+
+// 2
+void ShortestDistance(const FstClass &ifst, std::vector<WeightClass> *distance,
+ bool reverse = false, double delta = fst::kDelta);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_SHORTEST_DISTANCE_H_
--- /dev/null
+// 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 <memory>
+#include <vector>
+
+#include <fst/shortest-path.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/shortest-distance.h> // for ShortestDistanceOptions
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+struct ShortestPathOptions : public fst::script::ShortestDistanceOptions {
+ const int32 nshortest;
+ const bool unique;
+ const bool has_distance;
+ const bool first_path;
+ const WeightClass &weight_threshold;
+ const int64 state_threshold;
+
+ ShortestPathOptions(QueueType qt, int32 n, bool u, bool hasdist, float d,
+ bool fp, const WeightClass &w,
+ int64 s = fst::kNoStateId)
+ : ShortestDistanceOptions(qt, ANY_ARC_FILTER, kNoStateId, d),
+ nshortest(n), unique(u), has_distance(hasdist), first_path(fp),
+ weight_threshold(w), state_threshold(s) {}
+};
+
+// 1
+using ShortestPathArgs1 =
+ args::Package<const FstClass &, MutableFstClass *,
+ std::vector<WeightClass> *, const ShortestPathOptions &>;
+
+template <class Arc>
+void ShortestPath(ShortestPathArgs1 *args) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ const ShortestPathOptions &opts = args->arg4;
+ using ArcFilter = AnyArcFilter<Arc>;
+ std::vector<Weight> weights;
+ const Weight &weight_threshold = *opts.weight_threshold.GetWeight<Weight>();
+ switch (opts.queue_type) {
+ case AUTO_QUEUE: {
+ using Queue = AutoQueue<StateId>;
+ std::unique_ptr<Queue> queue(
+ QueueConstructor<Queue, Arc, ArcFilter>::Construct(ifst, &weights));
+ fst::ShortestPathOptions<Arc, Queue, ArcFilter> spopts(
+ queue.get(), ArcFilter(), opts.nshortest, opts.unique,
+ opts.has_distance, opts.delta, opts.first_path, weight_threshold,
+ opts.state_threshold);
+ ShortestPath(ifst, ofst, &weights, spopts);
+ return;
+ }
+ case FIFO_QUEUE: {
+ using Queue = FifoQueue<StateId>;
+ std::unique_ptr<Queue> queue(
+ QueueConstructor<Queue, Arc, ArcFilter>::Construct(ifst, &weights));
+ fst::ShortestPathOptions<Arc, Queue, ArcFilter> spopts(
+ queue.get(), ArcFilter(), opts.nshortest, opts.unique,
+ opts.has_distance, opts.delta, opts.first_path, weight_threshold,
+ opts.state_threshold);
+ ShortestPath(ifst, ofst, &weights, spopts);
+ return;
+ }
+ case LIFO_QUEUE: {
+ using Queue = LifoQueue<StateId>;
+ std::unique_ptr<Queue> queue(
+ QueueConstructor<Queue, Arc, ArcFilter>::Construct(ifst, &weights));
+ fst::ShortestPathOptions<Arc, Queue, ArcFilter> spopts(
+ queue.get(), ArcFilter(), opts.nshortest, opts.unique,
+ opts.has_distance, opts.delta, opts.first_path, weight_threshold,
+ opts.state_threshold);
+ ShortestPath(ifst, ofst, &weights, spopts);
+ return;
+ }
+ case SHORTEST_FIRST_QUEUE: {
+ using Queue = NaturalShortestFirstQueue<StateId, Weight>;
+ std::unique_ptr<Queue> queue(
+ QueueConstructor<Queue, Arc, ArcFilter>::Construct(ifst, &weights));
+ fst::ShortestPathOptions<Arc, Queue, ArcFilter> spopts(
+ queue.get(), ArcFilter(), opts.nshortest, opts.unique,
+ opts.has_distance, opts.delta, opts.first_path, weight_threshold,
+ opts.state_threshold);
+ ShortestPath(ifst, ofst, &weights, spopts);
+ return;
+ }
+ case STATE_ORDER_QUEUE: {
+ using Queue = StateOrderQueue<StateId>;
+ std::unique_ptr<Queue> queue(
+ QueueConstructor<Queue, Arc, ArcFilter>::Construct(ifst, &weights));
+ fst::ShortestPathOptions<Arc, Queue, ArcFilter> spopts(
+ queue.get(), ArcFilter(), opts.nshortest, opts.unique,
+ opts.has_distance, opts.delta, opts.first_path, weight_threshold,
+ opts.state_threshold);
+ ShortestPath(ifst, ofst, &weights, spopts);
+ return;
+ }
+ case TOP_ORDER_QUEUE: {
+ using Queue = TopOrderQueue<StateId>;
+ std::unique_ptr<Queue> queue(
+ QueueConstructor<Queue, Arc, ArcFilter>::Construct(ifst, &weights));
+ fst::ShortestPathOptions<Arc, Queue, ArcFilter> spopts(
+ queue.get(), ArcFilter(), opts.nshortest, opts.unique,
+ opts.has_distance, opts.delta, opts.first_path, weight_threshold,
+ opts.state_threshold);
+ ShortestPath(ifst, ofst, &weights, spopts);
+ return;
+ }
+ default:
+ FSTERROR() << "Unknown queue type: " << opts.queue_type;
+ ofst->SetProperties(kError, kError);
+ }
+ // Copies the weights back.
+ args->arg3->resize(weights.size());
+ for (auto i = 0; i < weights.size(); ++i) {
+ (*args->arg3)[i] = WeightClass(weights[i]);
+ }
+}
+
+// 2
+using ShortestPathArgs2 =
+ args::Package<const FstClass &, MutableFstClass *, int32, bool, bool,
+ const WeightClass &, int64>;
+
+template <class Arc>
+void ShortestPath(ShortestPathArgs2 *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ const typename Arc::Weight &weight_threshold =
+ *args->arg6.GetWeight<typename Arc::Weight>();
+ ShortestPath(ifst, ofst, args->arg3, args->arg4, args->arg5,
+ weight_threshold, args->arg7);
+}
+
+// 1
+void ShortestPath(const FstClass &ifst, MutableFstClass *ofst,
+ std::vector<WeightClass> *distance,
+ const ShortestPathOptions &opts);
+
+// 2
+void ShortestPath(const FstClass &ifst, MutableFstClass *ofst, int32 n,
+ bool unique, bool first_path, const WeightClass &weight_threshold,
+ int64 state_threshold = fst::kNoStateId);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_SHORTEST_PATH_H_
--- /dev/null
+// 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 <memory>
+
+#include <fst/fstlib.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+// Scripting API support for StateIterator.
+
+namespace fst {
+namespace script {
+
+// Virtual interface implemented by each concrete StateIteratorImpl<F>.
+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 Arc>
+class StateIteratorClassImpl : public StateIteratorImplBase {
+ public:
+ explicit StateIteratorClassImpl(const Fst<Arc> &fst) : siter_(fst) {}
+
+ bool Done() const override { return siter_.Done(); }
+
+ int64 Value() const override { return siter_.Value(); }
+
+ void Next() override { siter_.Next(); }
+
+ void Reset() override { siter_.Reset(); }
+
+ ~StateIteratorClassImpl() override {}
+
+ private:
+ StateIterator<Fst<Arc>> siter_;
+};
+
+class StateIteratorClass;
+
+using InitStateIteratorClassArgs =
+ args::Package<const FstClass &, StateIteratorClass *>;
+
+// Untemplated user-facing class holding a templated pimpl.
+class StateIteratorClass {
+ public:
+ explicit StateIteratorClass(const FstClass &fst);
+
+ template <class Arc>
+ explicit StateIteratorClass(const Fst<Arc> &fst)
+ : impl_(new StateIteratorClassImpl<Arc>(fst)) {}
+
+ bool Done() const { return impl_->Done(); }
+
+ int64 Value() const { return impl_->Value(); }
+
+ void Next() { impl_->Next(); }
+
+ void Reset() { impl_->Reset(); }
+
+ template <class Arc>
+ friend void InitStateIteratorClass(InitStateIteratorClassArgs *args);
+
+ private:
+ std::unique_ptr<StateIteratorImplBase> impl_;
+};
+
+template <class Arc>
+void InitStateIteratorClass(InitStateIteratorClassArgs *args) {
+ const Fst<Arc> &fst = *(args->arg1.GetFst<Arc>());
+ args->arg2->impl_.reset(new StateIteratorClassImpl<Arc>(fst));
+}
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_STATEITERATOR_CLASS_H_
--- /dev/null
+// 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 <fst/synchronize.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using SynchronizeArgs = args::Package<const FstClass &, MutableFstClass *>;
+
+template <class Arc>
+void Synchronize(SynchronizeArgs *args) {
+ const Fst<Arc> &ifst = *(args->arg1.GetFst<Arc>());
+ MutableFst<Arc> *ofst = args->arg2->GetMutableFst<Arc>();
+ Synchronize(ifst, ofst);
+}
+
+void Synchronize(const FstClass &ifst, MutableFstClass *ofst);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_SYNCHRONIZE_H_
--- /dev/null
+// 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 <string>
+#include <vector>
+
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+bool ReadPotentials(const string &weight_type, const string &filename,
+ std::vector<WeightClass> *potentials);
+
+bool WritePotentials(const string &filename,
+ const std::vector<WeightClass> &potentials);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_TEXT_IO_H__
--- /dev/null
+// 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 <fst/topsort.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using TopSortArgs = args::WithReturnValue<bool, MutableFstClass *>;
+
+template <class Arc>
+void TopSort(TopSortArgs *args) {
+ MutableFst<Arc> *fst = args->args->GetMutableFst<Arc>();
+ args->retval = TopSort(fst);
+}
+
+bool TopSort(MutableFstClass *fst);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_TOPSORT_H_
--- /dev/null
+// 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 <fst/union.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using UnionArgs = args::Package<MutableFstClass *, const FstClass &>;
+
+template <class Arc>
+void Union(UnionArgs *args) {
+ MutableFst<Arc> *fst1 = args->arg1->GetMutableFst<Arc>();
+ const Fst<Arc> &fst2 = *(args->arg2.GetFst<Arc>());
+ Union(fst1, fst2);
+}
+
+void Union(MutableFstClass *fst1, const FstClass &fst2);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_UNION_H_
--- /dev/null
+// 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 <fst/verify.h>
+#include <fst/script/arg-packs.h>
+#include <fst/script/fst-class.h>
+
+namespace fst {
+namespace script {
+
+using VerifyArgs = args::WithReturnValue<bool, const FstClass &>;
+
+template <class Arc>
+void Verify(VerifyArgs *args) {
+ const Fst<Arc> &fst = *(args->args.GetFst<Arc>());
+ args->retval = Verify(fst);
+}
+
+bool Verify(const FstClass &fst);
+
+} // namespace script
+} // namespace fst
+
+#endif // FST_SCRIPT_VERIFY_H_
--- /dev/null
+// 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 <memory>
+#include <ostream>
+#include <string>
+
+#include <fst/arc.h>
+#include <fst/generic-register.h>
+#include <fst/util.h>
+#include <fst/weight.h>
+
+namespace fst {
+namespace script {
+
+class WeightImplBase {
+ public:
+ virtual WeightImplBase *Copy() const = 0;
+ virtual void Print(std::ostream *o) const = 0;
+ virtual const string &Type() const = 0;
+ virtual string ToString() const = 0;
+ virtual bool operator==(const WeightImplBase &other) const = 0;
+ virtual bool operator!=(const WeightImplBase &other) const = 0;
+ virtual WeightImplBase &PlusEq(const WeightImplBase &other) = 0;
+ virtual WeightImplBase &TimesEq(const WeightImplBase &other) = 0;
+ virtual WeightImplBase &DivideEq(const WeightImplBase &other) = 0;
+ virtual WeightImplBase &PowerEq(size_t n) = 0;
+ virtual ~WeightImplBase() {}
+};
+
+template <class W>
+class WeightClassImpl : public WeightImplBase {
+ public:
+ explicit WeightClassImpl(const W &weight) : weight_(weight) {}
+
+ WeightClassImpl<W> *Copy() const override {
+ return new WeightClassImpl<W>(weight_);
+ }
+
+ const string &Type() const override { return W::Type(); }
+
+ void Print(std::ostream *ostrm) const override { *ostrm << weight_; }
+
+ string ToString() const override {
+ string str;
+ WeightToStr(weight_, &str);
+ return str;
+ }
+
+ bool operator==(const WeightImplBase &other) const override {
+ const auto *typed_other = static_cast<const WeightClassImpl<W> *>(&other);
+ return weight_ == typed_other->weight_;
+ }
+
+ bool operator!=(const WeightImplBase &other) const override {
+ return !(*this == other);
+ }
+
+ WeightClassImpl<W> &PlusEq(const WeightImplBase &other) override {
+ const auto *typed_other = static_cast<const WeightClassImpl<W> *>(&other);
+ weight_ = Plus(weight_, typed_other->weight_);
+ return *this;
+ }
+
+ WeightClassImpl<W> &TimesEq(const WeightImplBase &other) override {
+ const auto *typed_other = static_cast<const WeightClassImpl<W> *>(&other);
+ weight_ = Times(weight_, typed_other->weight_);
+ return *this;
+ }
+
+ WeightClassImpl<W> &DivideEq(const WeightImplBase &other) override {
+ const auto *typed_other = static_cast<const WeightClassImpl<W> *>(&other);
+ weight_ = Divide(weight_, typed_other->weight_);
+ return *this;
+ }
+
+ WeightClassImpl<W> &PowerEq(size_t n) override {
+ weight_ = Power(weight_, n);
+ return *this;
+ }
+
+ W *GetImpl() { return &weight_; }
+
+ private:
+ W weight_;
+};
+
+
+class WeightClass {
+ public:
+ WeightClass() = default;
+
+ template <class W>
+ explicit WeightClass(const W &weight)
+ : impl_(new WeightClassImpl<W>(weight)) {}
+
+ template <class W>
+ explicit WeightClass(const WeightClassImpl<W> &impl)
+ : impl_(new WeightClassImpl<W>(impl)) {}
+
+ WeightClass(const string &weight_type, const string &weight_str);
+
+ WeightClass(const WeightClass &other)
+ : impl_(other.impl_ ? other.impl_->Copy() : nullptr) {}
+
+ WeightClass &operator=(const WeightClass &other) {
+ impl_.reset(other.impl_ ? other.impl_->Copy() : nullptr);
+ return *this;
+ }
+
+ static constexpr const char *__ZERO__ = "__ZERO__"; // NOLINT
+
+ static WeightClass Zero(const string &weight_type);
+
+ static constexpr const char *__ONE__ = "__ONE__"; // NOLINT
+
+ static WeightClass One(const string &weight_type);
+
+ static constexpr const char *__NOWEIGHT__ = "__NOWEIGHT__"; // NOLINT
+
+ static WeightClass NoWeight(const string &weight_type);
+
+ template <class W>
+ const W *GetWeight() const {
+ if (W::Type() != impl_->Type()) {
+ return nullptr;
+ } else {
+ auto *typed_impl = static_cast<WeightClassImpl<W> *>(impl_.get());
+ return typed_impl->GetImpl();
+ }
+ }
+
+ string ToString() const { return (impl_) ? impl_->ToString() : "none"; }
+
+ const string &Type() const {
+ if (impl_) return impl_->Type();
+ static const string no_type = "none";
+ return no_type;
+ }
+
+ bool WeightTypesMatch(const WeightClass &other, const string &op_name) const;
+
+ friend bool operator==(const WeightClass &lhs, const WeightClass &rhs);
+
+ friend WeightClass Plus(const WeightClass &lhs, const WeightClass &rhs);
+
+ friend WeightClass Times(const WeightClass &lhs, const WeightClass &rhs);
+
+ friend WeightClass Divide(const WeightClass &lhs, const WeightClass &rhs);
+
+ friend WeightClass Power(const WeightClass &w, size_t n);
+
+ private:
+ const WeightImplBase *GetImpl() const { return impl_.get(); }
+
+ WeightImplBase *GetImpl() { return impl_.get(); }
+
+ std::unique_ptr<WeightImplBase> impl_;
+
+ friend std::ostream &operator<<(std::ostream &o, const WeightClass &c);
+};
+
+bool operator==(const WeightClass &lhs, const WeightClass &rhs);
+
+bool operator!=(const WeightClass &lhs, const WeightClass &rhs);
+
+WeightClass Plus(const WeightClass &lhs, const WeightClass &rhs);
+
+WeightClass Times(const WeightClass &lhs, const WeightClass &rhs);
+
+WeightClass Divide(const WeightClass &lhs, const WeightClass &rhs);
+
+WeightClass Power(const WeightClass &w, size_t n);
+
+std::ostream &operator<<(std::ostream &o, const WeightClass &c);
+
+// Registration for generic weight types.
+
+using StrToWeightImplBaseT = WeightImplBase *(*)(const string &str,
+ const string &src,
+ size_t nline);
+
+template <class W>
+WeightImplBase *StrToWeightImplBase(const string &str, const string &src,
+ size_t nline) {
+ if (str == WeightClass::__ZERO__)
+ return new WeightClassImpl<W>(W::Zero());
+ else if (str == WeightClass::__ONE__)
+ return new WeightClassImpl<W>(W::One());
+ else if (str == WeightClass::__NOWEIGHT__)
+ return new WeightClassImpl<W>(W::NoWeight());
+ return new WeightClassImpl<W>(StrToWeight<W>(str, src, nline));
+}
+
+class WeightClassRegister : public GenericRegister<string, StrToWeightImplBaseT,
+ WeightClassRegister> {
+ protected:
+ string ConvertKeyToSoFilename(const string &key) const override {
+ string legal_type(key);
+ ConvertToLegalCSymbol(&legal_type);
+ return legal_type + ".so";
+ }
+};
+
+using WeightClassRegisterer = GenericRegisterer<WeightClassRegister>;
+
+// 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<Weight>)
+
+// 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_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes to find shortest distance in an FST.
+
+#ifndef FST_LIB_SHORTEST_DISTANCE_H_
+#define FST_LIB_SHORTEST_DISTANCE_H_
+
+#include <deque>
+#include <vector>
+
+#include <fst/arcfilter.h>
+#include <fst/cache.h>
+#include <fst/queue.h>
+#include <fst/reverse.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+template <class Arc, class Queue, class ArcFilter>
+struct ShortestDistanceOptions {
+ using StateId = typename Arc::StateId;
+
+ Queue *state_queue; // Queue discipline used; owned by caller.
+ ArcFilter arc_filter; // Arc filter (e.g., limit to only epsilon graph).
+ StateId source; // If kNoStateId, use the FST's initial state.
+ float delta; // Determines the degree of convergence required
+ bool first_path; // For a semiring with the path property (o.w.
+ // undefined), compute the shortest-distances along
+ // along the first path to a final state found
+ // by the algorithm. That path is the shortest-path
+ // only if the FST has a unique final state (or all
+ // the final states have the same final weight), the
+ // queue discipline is shortest-first and all the
+ // weights in the FST are between One() and Zero()
+ // according to NaturalLess.
+
+ ShortestDistanceOptions(Queue *state_queue, ArcFilter arc_filter,
+ StateId source = kNoStateId, float delta = kDelta)
+ : state_queue(state_queue),
+ arc_filter(arc_filter),
+ source(source),
+ delta(delta),
+ first_path(false) {}
+};
+
+namespace internal {
+
+// Computation state of the shortest-distance algorithm. Reusable information
+// is maintained across calls to member function ShortestDistance(source) when
+// retain is true for improved efficiency when calling multiple times from
+// different source states (e.g., in epsilon removal). Contrary to the usual
+// conventions, fst may not be freed before this class. Vector distance
+// should not be modified by the user between these calls. The Error() method
+// returns true iff an error was encountered.
+template <class Arc, class Queue, class ArcFilter>
+class ShortestDistanceState {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ ShortestDistanceState(
+ const Fst<Arc> &fst, std::vector<Weight> *distance,
+ const ShortestDistanceOptions<Arc, Queue, ArcFilter> &opts, bool retain)
+ : fst_(fst),
+ distance_(distance),
+ state_queue_(opts.state_queue),
+ arc_filter_(opts.arc_filter),
+ delta_(opts.delta),
+ first_path_(opts.first_path),
+ retain_(retain),
+ source_id_(0),
+ error_(false) {
+ distance_->clear();
+ }
+
+ void ShortestDistance(StateId source);
+
+ bool Error() const { return error_; }
+
+ private:
+ const Fst<Arc> &fst_;
+ std::vector<Weight> *distance_;
+ Queue *state_queue_;
+ ArcFilter arc_filter_;
+ const float delta_;
+ const bool first_path_;
+ const bool retain_; // Retain and reuse information across calls.
+
+ std::vector<Weight> rdistance_; // Relaxation distance.
+ std::vector<bool> enqueued_; // Is state enqueued?
+ std::vector<StateId> sources_; // Source ID for ith state in distance_,
+ // rdistance_, and enqueued_ if retained.
+ StateId source_id_; // Unique ID characterizing each call.
+ bool error_;
+};
+
+// Compute the shortest distance; if source is kNoStateId, uses the initial
+// state of the FST.
+template <class Arc, class Queue, class ArcFilter>
+void ShortestDistanceState<Arc, Queue, ArcFilter>::ShortestDistance(
+ StateId source) {
+ if (fst_.Start() == kNoStateId) {
+ if (fst_.Properties(kError, false)) error_ = true;
+ return;
+ }
+ if (!(Weight::Properties() & kRightSemiring)) {
+ FSTERROR() << "ShortestDistance: Weight needs to be right distributive: "
+ << Weight::Type();
+ error_ = true;
+ return;
+ }
+ if (first_path_ && !(Weight::Properties() & kPath)) {
+ FSTERROR() << "ShortestDistance: The first_path option is disallowed when "
+ << "Weight does not have the path property: " << Weight::Type();
+ error_ = true;
+ return;
+ }
+ state_queue_->Clear();
+ if (!retain_) {
+ distance_->clear();
+ rdistance_.clear();
+ enqueued_.clear();
+ }
+ if (source == kNoStateId) source = fst_.Start();
+ while (distance_->size() <= source) {
+ distance_->push_back(Weight::Zero());
+ rdistance_.push_back(Weight::Zero());
+ enqueued_.push_back(false);
+ }
+ if (retain_) {
+ while (sources_.size() <= source) sources_.push_back(kNoStateId);
+ sources_[source] = source_id_;
+ }
+ (*distance_)[source] = Weight::One();
+ rdistance_[source] = Weight::One();
+ enqueued_[source] = true;
+ state_queue_->Enqueue(source);
+ while (!state_queue_->Empty()) {
+ const auto state = state_queue_->Head();
+ state_queue_->Dequeue();
+ while (distance_->size() <= state) {
+ distance_->push_back(Weight::Zero());
+ rdistance_.push_back(Weight::Zero());
+ enqueued_.push_back(false);
+ }
+ if (first_path_ && (fst_.Final(state) != Weight::Zero())) break;
+ enqueued_[state] = false;
+ const auto r = rdistance_[state];
+ rdistance_[state] = Weight::Zero();
+ for (ArcIterator<Fst<Arc>> aiter(fst_, state); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ if (!arc_filter_(arc)) continue;
+ while (distance_->size() <= arc.nextstate) {
+ distance_->push_back(Weight::Zero());
+ rdistance_.push_back(Weight::Zero());
+ enqueued_.push_back(false);
+ }
+ if (retain_) {
+ while (sources_.size() <= arc.nextstate) sources_.push_back(kNoStateId);
+ if (sources_[arc.nextstate] != source_id_) {
+ (*distance_)[arc.nextstate] = Weight::Zero();
+ rdistance_[arc.nextstate] = Weight::Zero();
+ enqueued_[arc.nextstate] = false;
+ sources_[arc.nextstate] = source_id_;
+ }
+ }
+ auto &nd = (*distance_)[arc.nextstate];
+ auto &nr = rdistance_[arc.nextstate];
+ auto weight = Times(r, arc.weight);
+ if (!ApproxEqual(nd, Plus(nd, weight), delta_)) {
+ nd = Plus(nd, weight);
+ nr = Plus(nr, weight);
+ if (!nd.Member() || !nr.Member()) {
+ error_ = true;
+ return;
+ }
+ if (!enqueued_[arc.nextstate]) {
+ state_queue_->Enqueue(arc.nextstate);
+ enqueued_[arc.nextstate] = true;
+ } else {
+ state_queue_->Update(arc.nextstate);
+ }
+ }
+ }
+ }
+ ++source_id_;
+ if (fst_.Properties(kError, false)) error_ = true;
+}
+
+} // namespace internal
+
+// Shortest-distance algorithm: this version allows fine control
+// via the options argument. See below for a simpler interface.
+//
+// This computes the shortest distance from the opts.source state to each
+// visited state S and stores the value in the distance vector. An
+// nvisited state S has distance Zero(), which will be stored in the
+// distance vector if S is less than the maximum visited state. The state
+// queue discipline, arc filter, and convergence delta are taken in the
+// options argument. The distance vector will contain a unique element for
+// which Member() is false if an error was encountered.
+//
+// The weights must must be right distributive and k-closed (i.e., 1 +
+// x + x^2 + ... + x^(k +1) = 1 + x + x^2 + ... + x^k).
+//
+// Complexity:
+//
+// Depends on properties of the semiring and the queue discipline.
+//
+// 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.
+template <class Arc, class Queue, class ArcFilter>
+void ShortestDistance(
+ const Fst<Arc> &fst, std::vector<typename Arc::Weight> *distance,
+ const ShortestDistanceOptions<Arc, Queue, ArcFilter> &opts) {
+ internal::ShortestDistanceState<Arc, Queue, ArcFilter> sd_state(fst, distance,
+ opts, false);
+ sd_state.ShortestDistance(opts.source);
+ if (sd_state.Error()) {
+ distance->clear();
+ distance->resize(1, Arc::Weight::NoWeight());
+ }
+}
+
+// Shortest-distance algorithm: simplified interface. See above for a version
+// that permits finer control.
+//
+// If reverse is false, this computes the shortest distance from the initial
+// state to each state S and stores the value in the distance vector. If
+// reverse is true, this computes the shortest distance from each state to the
+// final states. An unvisited state S has distance Zero(), which will be stored
+// in the distance vector if S is less than the maximum visited state. The
+// state queue discipline is automatically-selected. The distance vector will
+// contain a unique element for which Member() is false if an error was
+// encountered.
+//
+// The weights must must be right (left) distributive if reverse is false (true)
+// and k-closed (i.e., 1 + x + x^2 + ... + x^(k +1) = 1 + x + x^2 + ... + x^k).
+//
+// Arc weights must satisfy the property that the sum of the weights of one or
+// more paths from some state S to T is never Zero(). In particular, arc weights
+// are never Zero().
+//
+// Complexity:
+//
+// Depends on properties of the semiring and the queue discipline.
+//
+// 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.
+template <class Arc>
+void ShortestDistance(const Fst<Arc> &fst,
+ std::vector<typename Arc::Weight> *distance,
+ bool reverse = false, float delta = kDelta) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ if (!reverse) {
+ AnyArcFilter<Arc> arc_filter;
+ AutoQueue<StateId> state_queue(fst, distance, arc_filter);
+ const ShortestDistanceOptions<Arc, AutoQueue<StateId>, AnyArcFilter<Arc>>
+ opts(&state_queue, arc_filter, kNoStateId, delta);
+ ShortestDistance(fst, distance, opts);
+ } else {
+ using ReverseArc = ReverseArc<Arc>;
+ using ReverseWeight = typename ReverseArc::Weight;
+ AnyArcFilter<ReverseArc> rarc_filter;
+ VectorFst<ReverseArc> rfst;
+ Reverse(fst, &rfst);
+ std::vector<ReverseWeight> rdistance;
+ AutoQueue<StateId> state_queue(rfst, &rdistance, rarc_filter);
+ const ShortestDistanceOptions<ReverseArc, AutoQueue<StateId>,
+ AnyArcFilter<ReverseArc>>
+ ropts(&state_queue, rarc_filter, kNoStateId, delta);
+ ShortestDistance(rfst, &rdistance, ropts);
+ distance->clear();
+ if (rdistance.size() == 1 && !rdistance[0].Member()) {
+ distance->resize(1, Arc::Weight::NoWeight());
+ return;
+ }
+ while (distance->size() < rdistance.size() - 1) {
+ distance->push_back(rdistance[distance->size() + 1].Reverse());
+ }
+ }
+}
+
+// Return the sum of the weight of all successful paths in an FST, i.e., the
+// shortest-distance from the initial state to the final states. Returns a
+// weight such that Member() is false if an error was encountered.
+template <class Arc>
+typename Arc::Weight ShortestDistance(const Fst<Arc> &fst,
+ float delta = kDelta) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ std::vector<Weight> distance;
+ if (Weight::Properties() & kRightSemiring) {
+ ShortestDistance(fst, &distance, false, delta);
+ if (distance.size() == 1 && !distance[0].Member()) {
+ return Arc::Weight::NoWeight();
+ }
+ auto sum = Weight::Zero();
+ for (StateId state = 0; state < distance.size(); ++state) {
+ sum = Plus(sum, Times(distance[state], fst.Final(state)));
+ }
+ return sum;
+ } else {
+ ShortestDistance(fst, &distance, true, delta);
+ const auto state = fst.Start();
+ if (distance.size() == 1 && !distance[0].Member()) {
+ return Arc::Weight::NoWeight();
+ }
+ return state != kNoStateId && state < distance.size() ? distance[state]
+ : Weight::Zero();
+ }
+}
+
+} // namespace fst
+
+#endif // FST_LIB_SHORTEST_DISTANCE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions to find shortest paths in an FST.
+
+#ifndef FST_LIB_SHORTEST_PATH_H_
+#define FST_LIB_SHORTEST_PATH_H_
+
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/determinize.h>
+#include <fst/queue.h>
+#include <fst/shortest-distance.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+template <class Arc, class Queue, class ArcFilter>
+struct ShortestPathOptions
+ : public ShortestDistanceOptions<Arc, Queue, ArcFilter> {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ int32 nshortest; // Returns n-shortest paths.
+ bool unique; // Only returns paths with distinct input strings.
+ bool has_distance; // Distance vector already contains the
+ // shortest distance from the initial state.
+ bool first_path; // Single shortest path stops after finding the first
+ // path to a final state; that path is the shortest path
+ // only when using the ShortestFirstQueue and
+ // only when all the weights in the FST are between
+ // One() and Zero() according to NaturalLess.
+ Weight weight_threshold; // Pruning weight threshold.
+ StateId state_threshold; // Pruning state threshold.
+
+ ShortestPathOptions(Queue *queue, ArcFilter filter, int32 nshortest = 1,
+ bool unique = false, bool has_distance = false,
+ float delta = kDelta, bool first_path = false,
+ Weight weight_threshold = Weight::Zero(),
+ StateId state_threshold = kNoStateId)
+ : ShortestDistanceOptions<Arc, Queue, ArcFilter>(queue, filter,
+ kNoStateId, delta),
+ nshortest(nshortest),
+ unique(unique),
+ has_distance(has_distance),
+ first_path(first_path),
+ weight_threshold(std::move(weight_threshold)),
+ state_threshold(state_threshold) {}
+};
+
+namespace internal {
+
+constexpr size_t kNoArc = -1;
+
+// Helper function for SingleShortestPath building the shortest path as a left-
+// to-right machine backwards from the best final state. It takes the input
+// FST passed to SingleShortestPath and the parent vector and f_parent returned
+// by that function, and builds the result into the provided output mutable FS
+// This is not normally called by users; see ShortestPath instead.
+template <class Arc>
+void SingleShortestPathBacktrace(
+ const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ const std::vector<std::pair<typename Arc::StateId, size_t>> &parent,
+ typename Arc::StateId f_parent) {
+ using StateId = typename Arc::StateId;
+ ofst->DeleteStates();
+ ofst->SetInputSymbols(ifst.InputSymbols());
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ StateId s_p = kNoStateId;
+ StateId d_p = kNoStateId;
+ for (auto state = f_parent, d = kNoStateId; state != kNoStateId;
+ d = state, state = parent[state].first) {
+ d_p = s_p;
+ s_p = ofst->AddState();
+ if (d == kNoStateId) {
+ ofst->SetFinal(s_p, ifst.Final(f_parent));
+ } else {
+ ArcIterator<Fst<Arc>> aiter(ifst, state);
+ aiter.Seek(parent[d].second);
+ auto arc = aiter.Value();
+ arc.nextstate = d_p;
+ ofst->AddArc(s_p, arc);
+ }
+ }
+ ofst->SetStart(s_p);
+ if (ifst.Properties(kError, false)) ofst->SetProperties(kError, kError);
+ ofst->SetProperties(
+ ShortestPathProperties(ofst->Properties(kFstProperties, false), true),
+ kFstProperties);
+}
+
+// Helper function for SingleShortestPath building a tree of shortest paths to
+// every final state in the input FST. It takes the input FST and parent values
+// computed by SingleShortestPath and builds into the output mutable FST the
+// subtree of ifst that consists only of the best paths to all final states.
+// This is not normally called by users; see ShortestPath instead.
+template <class Arc>
+void SingleShortestTree(
+ const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ const std::vector<std::pair<typename Arc::StateId, size_t>> &parent) {
+ ofst->DeleteStates();
+ ofst->SetInputSymbols(ifst.InputSymbols());
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ ofst->SetStart(ifst.Start());
+ for (StateIterator<Fst<Arc>> siter(ifst); !siter.Done(); siter.Next()) {
+ ofst->AddState();
+ ofst->SetFinal(siter.Value(), ifst.Final(siter.Value()));
+ }
+ for (const auto &pair : parent) {
+ if (pair.first != kNoStateId && pair.second != kNoArc) {
+ ArcIterator<Fst<Arc>> aiter(ifst, pair.first);
+ aiter.Seek(pair.second);
+ ofst->AddArc(pair.first, aiter.Value());
+ }
+ }
+ if (ifst.Properties(kError, false)) ofst->SetProperties(kError, kError);
+ ofst->SetProperties(
+ ShortestPathProperties(ofst->Properties(kFstProperties, false), true),
+ kFstProperties);
+}
+
+// Shortest-path algorithm. It builds the output mutable FST so that it contains
+// the shortest path in the input FST; distance returns the shortest distances
+// from the source state to each state in the input FST, and the options struct
+// is
+// used to specify options such as the queue discipline, the arc filter and
+// delta. The super_final option is an output parameter indicating the final
+// state, and the parent argument is used for the storage of the backtrace path
+// for each state 1 to n, (i.e., the best previous state and the arc that
+// transition to state n.) The shortest path is the lowest weight path w.r.t.
+// the natural semiring order. The weights need to be right distributive and
+// have the path (kPath) property. False is returned if an error is encountered.
+//
+// This is not normally called by users; see ShortestPath instead (with n = 1).
+template <class Arc, class Queue, class ArcFilter>
+bool SingleShortestPath(
+ const Fst<Arc> &ifst, std::vector<typename Arc::Weight> *distance,
+ const ShortestPathOptions<Arc, Queue, ArcFilter> &opts,
+ typename Arc::StateId *f_parent,
+ std::vector<std::pair<typename Arc::StateId, size_t>> *parent) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ parent->clear();
+ *f_parent = kNoStateId;
+ if (ifst.Start() == kNoStateId) return true;
+ std::vector<bool> enqueued;
+ auto state_queue = opts.state_queue;
+ const auto source = (opts.source == kNoStateId) ? ifst.Start() : opts.source;
+ bool final_seen = false;
+ auto f_distance = Weight::Zero();
+ distance->clear();
+ state_queue->Clear();
+ if ((Weight::Properties() & (kPath | kRightSemiring)) !=
+ (kPath | kRightSemiring)) {
+ FSTERROR() << "SingleShortestPath: Weight needs to have the path"
+ << " property and be right distributive: " << Weight::Type();
+ return false;
+ }
+ while (distance->size() < source) {
+ distance->push_back(Weight::Zero());
+ enqueued.push_back(false);
+ parent->push_back(std::make_pair(kNoStateId, kNoArc));
+ }
+ distance->push_back(Weight::One());
+ parent->push_back(std::make_pair(kNoStateId, kNoArc));
+ state_queue->Enqueue(source);
+ enqueued.push_back(true);
+ while (!state_queue->Empty()) {
+ const auto s = state_queue->Head();
+ state_queue->Dequeue();
+ enqueued[s] = false;
+ const auto sd = (*distance)[s];
+ // If we are using a shortest queue, no other path is going to be shorter
+ // than f_distance at this point.
+ if (opts.first_path && final_seen && f_distance == Plus(f_distance, sd)) {
+ break;
+ }
+ if (ifst.Final(s) != Weight::Zero()) {
+ const auto plus = Plus(f_distance, Times(sd, ifst.Final(s)));
+ if (f_distance != plus) {
+ f_distance = plus;
+ *f_parent = s;
+ }
+ if (!f_distance.Member()) return false;
+ final_seen = true;
+ }
+ for (ArcIterator<Fst<Arc>> aiter(ifst, s); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ while (distance->size() <= arc.nextstate) {
+ distance->push_back(Weight::Zero());
+ enqueued.push_back(false);
+ parent->push_back(std::make_pair(kNoStateId, kNoArc));
+ }
+ auto &nd = (*distance)[arc.nextstate];
+ const auto weight = Times(sd, arc.weight);
+ if (nd != Plus(nd, weight)) {
+ nd = Plus(nd, weight);
+ if (!nd.Member()) return false;
+ (*parent)[arc.nextstate] = std::make_pair(s, aiter.Position());
+ if (!enqueued[arc.nextstate]) {
+ state_queue->Enqueue(arc.nextstate);
+ enqueued[arc.nextstate] = true;
+ } else {
+ state_queue->Update(arc.nextstate);
+ }
+ }
+ }
+ }
+ return true;
+}
+
+template <class StateId, class Weight>
+class ShortestPathCompare {
+ public:
+ ShortestPathCompare(const std::vector<std::pair<StateId, Weight>> &pairs,
+ const std::vector<Weight> &distance, StateId superfinal,
+ float delta)
+ : pairs_(pairs),
+ distance_(distance),
+ superfinal_(superfinal),
+ delta_(delta) {}
+
+ bool operator()(const StateId x, const StateId y) const {
+ const auto &px = pairs_[x];
+ const auto &py = pairs_[y];
+ const auto wx = Times(PWeight(px.first), px.second);
+ const auto wy = Times(PWeight(py.first), py.second);
+ // Penalize complete paths to ensure correct results with inexact weights.
+ // This forms a strict weak order so long as ApproxEqual(a, b) =>
+ // ApproxEqual(a, c) for all c s.t. less_(a, c) && less_(c, b).
+ if (px.first == superfinal_ && py.first != superfinal_) {
+ return less_(wy, wx) || ApproxEqual(wx, wy, delta_);
+ } else if (py.first == superfinal_ && px.first != superfinal_) {
+ return less_(wy, wx) && !ApproxEqual(wx, wy, delta_);
+ } else {
+ return less_(wy, wx);
+ }
+ }
+
+ private:
+ Weight PWeight(StateId state) const {
+ return (state == superfinal_)
+ ? Weight::One()
+ : (state < distance_.size()) ? distance_[state] : Weight::Zero();
+ }
+
+ const std::vector<std::pair<StateId, Weight>> &pairs_;
+ const std::vector<Weight> &distance_;
+ const StateId superfinal_;
+ const float delta_;
+ NaturalLess<Weight> less_;
+};
+
+// N-Shortest-path algorithm: implements the core n-shortest path algorithm.
+// The output is built reversed. See below for versions with more options and
+// *not reversed*.
+//
+// The output mutable FST contains the REVERSE of n'shortest paths in the input
+// FST; distance must contain the shortest distance from each state to a final
+// state in the input FST; delta is the convergence delta.
+//
+// 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 the input FST is the ith
+// shortest path. Disregarding the initial state and initial transitions, the
+// n-shortest paths, in fact, form a tree rooted at the single final state.
+//
+// The weights need to be left and right distributive (kSemiring) and have the
+// path (kPath) property.
+//
+// Arc weights must satisfy the property that the sum of the weights of one or
+// more paths from some state S to T is never Zero(). In particular, arc weights
+// are never Zero().
+//
+// For more information, see:
+//
+// Mohri, M, and Riley, M. 2002. An efficient algorithm for the n-best-strings
+// problem. In Proc. ICSLP.
+//
+// The algorithm relies on the shortest-distance algorithm. There are some
+// issues with the pseudo-code as written in the paper (viz., line 11).
+//
+// IMPLEMENTATION NOTE: The input FST can be a delayed FST and and at any state
+// in its expansion the values of distance vector need only be defined at that
+// time for the states that are known to exist.
+template <class Arc, class RevArc>
+void NShortestPath(const Fst<RevArc> &ifst, MutableFst<Arc> *ofst,
+ const std::vector<typename Arc::Weight> &distance,
+ int32 nshortest, float delta = kDelta,
+ typename Arc::Weight weight_threshold = Arc::Weight::Zero(),
+ typename Arc::StateId state_threshold = kNoStateId) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using Pair = std::pair<StateId, Weight>;
+ if (nshortest <= 0) return;
+ // TODO(kbg): Make this a compile-time static_assert once:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this operation for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ if ((Weight::Properties() & (kPath | kSemiring)) != (kPath | kSemiring)) {
+ FSTERROR() << "NShortestPath: Weight needs to have the "
+ << "path property and be distributive: " << Weight::Type();
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ofst->DeleteStates();
+ ofst->SetInputSymbols(ifst.InputSymbols());
+ ofst->SetOutputSymbols(ifst.OutputSymbols());
+ // Each state in ofst corresponds to a path with weight w from the initial
+ // state of ifst to a state s in ifst, that can be characterized by a pair
+ // (s, w). The vector pairs maps each state in ofst to the corresponding
+ // pair maps states in ofst to the corresponding pair (s, w).
+ std::vector<Pair> pairs;
+ // The supefinal state is denoted by kNoStateId. The distance from the
+ // superfinal state to the final state is semiring One, so
+ // `distance[kNoStateId]` is not needed.
+ const ShortestPathCompare<StateId, Weight> compare(pairs, distance,
+ kNoStateId, delta);
+ const NaturalLess<Weight> less;
+ if (ifst.Start() == kNoStateId || distance.size() <= ifst.Start() ||
+ distance[ifst.Start()] == Weight::Zero() ||
+ less(weight_threshold, Weight::One()) || state_threshold == 0) {
+ if (ifst.Properties(kError, false)) ofst->SetProperties(kError, kError);
+ return;
+ }
+ ofst->SetStart(ofst->AddState());
+ const auto final_state = ofst->AddState();
+ ofst->SetFinal(final_state, Weight::One());
+ while (pairs.size() <= final_state) {
+ pairs.push_back(std::make_pair(kNoStateId, Weight::Zero()));
+ }
+ pairs[final_state] = std::make_pair(ifst.Start(), Weight::One());
+ std::vector<StateId> heap;
+ heap.push_back(final_state);
+ const auto limit = Times(distance[ifst.Start()], weight_threshold);
+ // r[s + 1], s state in fst, is the number of states in ofst which
+ // corresponding pair contains s, i.e., it is number of paths computed so far
+ // to s. Valid for s == kNoStateId (the superfinal state).
+ std::vector<int> r;
+ while (!heap.empty()) {
+ std::pop_heap(heap.begin(), heap.end(), compare);
+ const auto state = heap.back();
+ const auto p = pairs[state];
+ heap.pop_back();
+ const auto d =
+ (p.first == kNoStateId)
+ ? Weight::One()
+ : (p.first < distance.size()) ? distance[p.first] : Weight::Zero();
+ if (less(limit, Times(d, p.second)) ||
+ (state_threshold != kNoStateId &&
+ ofst->NumStates() >= state_threshold)) {
+ continue;
+ }
+ while (r.size() <= p.first + 1) r.push_back(0);
+ ++r[p.first + 1];
+ if (p.first == kNoStateId) {
+ ofst->AddArc(ofst->Start(), Arc(0, 0, Weight::One(), state));
+ }
+ if ((p.first == kNoStateId) && (r[p.first + 1] == nshortest)) break;
+ if (r[p.first + 1] > nshortest) continue;
+ if (p.first == kNoStateId) continue;
+ for (ArcIterator<Fst<RevArc>> aiter(ifst, p.first); !aiter.Done();
+ aiter.Next()) {
+ const auto &rarc = aiter.Value();
+ Arc arc(rarc.ilabel, rarc.olabel, rarc.weight.Reverse(), rarc.nextstate);
+ const auto weight = Times(p.second, arc.weight);
+ const auto next = ofst->AddState();
+ pairs.push_back(std::make_pair(arc.nextstate, weight));
+ arc.nextstate = state;
+ ofst->AddArc(next, arc);
+ heap.push_back(next);
+ std::push_heap(heap.begin(), heap.end(), compare);
+ }
+ const auto final_weight = ifst.Final(p.first).Reverse();
+ if (final_weight != Weight::Zero()) {
+ const auto weight = Times(p.second, final_weight);
+ const auto next = ofst->AddState();
+ pairs.push_back(std::make_pair(kNoStateId, weight));
+ ofst->AddArc(next, Arc(0, 0, final_weight, state));
+ heap.push_back(next);
+ std::push_heap(heap.begin(), heap.end(), compare);
+ }
+ }
+ Connect(ofst);
+ if (ifst.Properties(kError, false)) ofst->SetProperties(kError, kError);
+ ofst->SetProperties(
+ ShortestPathProperties(ofst->Properties(kFstProperties, false)),
+ kFstProperties);
+}
+
+} // namespace internal
+
+// N-Shortest-path algorithm: this version allows finer control via the options
+// argument. See below for a simpler interface. The output mutable FST contains
+// the n-shortest paths in the input FST; the distance argument is used to
+// return the shortest distances from the source state to each state in the
+// input FST, and the options struct is used to specify the number of paths to
+// return, whether they need to have distinct input strings, the queue
+// discipline, the arc filter and the convergence delta.
+//
+// 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 output FST is the ith shortest
+// path.
+// Disregarding the initial state and initial transitions, The n-shortest paths,
+// in fact, form a tree rooted at the single final state.
+//
+// The weights need to be right distributive and have the path (kPath) property.
+// They need to be left distributive as well for nshortest > 1.
+//
+// For more information, see:
+//
+// Mohri, M, and Riley, M. 2002. An efficient algorithm for the n-best-strings
+// problem. In Proc. ICSLP.
+//
+// The algorithm relies on the shortest-distance algorithm. There are some
+// issues with the pseudo-code as written in the paper (viz., line 11).
+template <class Arc, class Queue, class ArcFilter>
+void ShortestPath(const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ std::vector<typename Arc::Weight> *distance,
+ const ShortestPathOptions<Arc, Queue, ArcFilter> &opts) {
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using RevArc = ReverseArc<Arc>;
+ if (opts.nshortest == 1) {
+ std::vector<std::pair<StateId, size_t>> parent;
+ StateId f_parent;
+ if (internal::SingleShortestPath(ifst, distance, opts, &f_parent,
+ &parent)) {
+ internal::SingleShortestPathBacktrace(ifst, ofst, parent, f_parent);
+ } else {
+ ofst->SetProperties(kError, kError);
+ }
+ return;
+ }
+ if (opts.nshortest <= 0) return;
+ // TODO(kbg): Make this a compile-time static_assert once:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this operation for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ if ((Weight::Properties() & (kPath | kSemiring)) != (kPath | kSemiring)) {
+ FSTERROR() << "ShortestPath: Weight needs to have the "
+ << "path property and be distributive: " << Weight::Type();
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ if (!opts.has_distance) {
+ ShortestDistance(ifst, distance, opts);
+ if (distance->size() == 1 && !(*distance)[0].Member()) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ }
+ // Algorithm works on the reverse of 'fst'; 'distance' is the distance to the
+ // final state in 'rfst', 'ofst' is built as the reverse of the tree of
+ // n-shortest path in 'rfst'.
+ VectorFst<RevArc> rfst;
+ Reverse(ifst, &rfst);
+ auto d = Weight::Zero();
+ for (ArcIterator<VectorFst<RevArc>> aiter(rfst, 0); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ const auto state = arc.nextstate - 1;
+ if (state < distance->size()) {
+ d = Plus(d, Times(arc.weight.Reverse(), (*distance)[state]));
+ }
+ }
+ // TODO(kbg): Avoid this expensive vector operation.
+ distance->insert(distance->begin(), d);
+ if (!opts.unique) {
+ internal::NShortestPath(rfst, ofst, *distance, opts.nshortest, opts.delta,
+ opts.weight_threshold, opts.state_threshold);
+ } else {
+ std::vector<Weight> ddistance;
+ DeterminizeFstOptions<RevArc> dopts(opts.delta);
+ DeterminizeFst<RevArc> dfst(rfst, distance, &ddistance, dopts);
+ internal::NShortestPath(dfst, ofst, ddistance, opts.nshortest, opts.delta,
+ opts.weight_threshold, opts.state_threshold);
+ }
+ // TODO(kbg): Avoid this expensive vector operation.
+ distance->erase(distance->begin());
+}
+
+// Shortest-path algorithm: simplified interface. See above for a version that
+// allows finer control. The output mutable FST contains the n-shortest paths
+// in the input FST. The queue discipline is automatically selected. When unique
+// is true, only paths with distinct input label sequences are returned.
+//
+// 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 ouput FST is the ith best path.
+// The weights need to be right distributive and have the path (kPath) property.
+template <class Arc>
+void ShortestPath(const Fst<Arc> &ifst, MutableFst<Arc> *ofst,
+ int32 nshortest = 1, bool unique = false,
+ bool first_path = false,
+ typename Arc::Weight weight_threshold = Arc::Weight::Zero(),
+ typename Arc::StateId state_threshold = kNoStateId) {
+ using StateId = typename Arc::StateId;
+ std::vector<typename Arc::Weight> distance;
+ AnyArcFilter<Arc> arc_filter;
+ AutoQueue<StateId> state_queue(ifst, &distance, arc_filter);
+ const ShortestPathOptions<Arc, AutoQueue<StateId>, AnyArcFilter<Arc>> opts(
+ &state_queue, arc_filter, nshortest, unique, false, kDelta, first_path,
+ weight_threshold, state_threshold);
+ ShortestPath(ifst, ofst, &distance, opts);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_SHORTEST_PATH_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// LogWeight along with sign information that represents the value X in the
+// linear domain as <sign(X), -ln(|X|)>
+//
+// The sign is a TropicalWeight:
+// positive, TropicalWeight.Value() > 0.0, recommended value 1.0
+// negative, TropicalWeight.Value() <= 0.0, recommended value -1.0
+
+#ifndef FST_LIB_SIGNED_LOG_WEIGHT_H_
+#define FST_LIB_SIGNED_LOG_WEIGHT_H_
+
+#include <cstdlib>
+
+#include <fst/float-weight.h>
+#include <fst/pair-weight.h>
+#include <fst/product-weight.h>
+
+
+namespace fst {
+template <class T>
+class SignedLogWeightTpl : public PairWeight<TropicalWeight, LogWeightTpl<T>> {
+ public:
+ using X1 = TropicalWeight;
+ using X2 = LogWeightTpl<T>;
+ using ReverseWeight = SignedLogWeightTpl;
+
+ using PairWeight<X1, X2>::Value1;
+ using PairWeight<X1, X2>::Value2;
+
+ SignedLogWeightTpl() : PairWeight<X1, X2>() {}
+
+ SignedLogWeightTpl(const SignedLogWeightTpl &w) : PairWeight<X1, X2>(w) {}
+
+ explicit SignedLogWeightTpl(const PairWeight<X1, X2> &w)
+ : PairWeight<X1, X2>(w) {}
+
+ SignedLogWeightTpl(const X1 &x1, const X2 &x2) : PairWeight<X1, X2>(x1, x2) {}
+
+ static const SignedLogWeightTpl &Zero() {
+ static const SignedLogWeightTpl zero(X1(1.0), X2::Zero());
+ return zero;
+ }
+
+ static const SignedLogWeightTpl &One() {
+ static const SignedLogWeightTpl one(X1(1.0), X2::One());
+ return one;
+ }
+
+ static const SignedLogWeightTpl &NoWeight() {
+ static const SignedLogWeightTpl no_weight(X1(1.0), X2::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type = "signed_log_" + X1::Type() + "_" + X2::Type();
+ return type;
+ }
+
+ SignedLogWeightTpl Quantize(float delta = kDelta) const {
+ return SignedLogWeightTpl(PairWeight<X1, X2>::Quantize(delta));
+ }
+
+ ReverseWeight Reverse() const {
+ return SignedLogWeightTpl(PairWeight<X1, X2>::Reverse());
+ }
+
+ bool Member() const { return PairWeight<X1, X2>::Member(); }
+
+ // Neither idempotent nor path.
+ static constexpr uint64 Properties() {
+ return kLeftSemiring | kRightSemiring | kCommutative;
+ }
+
+ size_t Hash() const {
+ size_t h1;
+ if (Value2() == X2::Zero() || Value1().Value() > 0.0) {
+ h1 = TropicalWeight(1.0).Hash();
+ } else {
+ h1 = TropicalWeight(-1.0).Hash();
+ }
+ size_t h2 = Value2().Hash();
+ static constexpr int lshift = 5;
+ static constexpr int rshift = CHAR_BIT * sizeof(size_t) - 5;
+ return h1 << lshift ^ h1 >> rshift ^ h2;
+ }
+};
+
+template <class T>
+inline SignedLogWeightTpl<T> Plus(const SignedLogWeightTpl<T> &w1,
+ const SignedLogWeightTpl<T> &w2) {
+ using X1 = TropicalWeight;
+ using X2 = LogWeightTpl<T>;
+ if (!w1.Member() || !w2.Member()) return SignedLogWeightTpl<T>::NoWeight();
+ const auto s1 = w1.Value1().Value() > 0.0;
+ const auto s2 = w2.Value1().Value() > 0.0;
+ const bool equal = (s1 == s2);
+ const auto f1 = w1.Value2().Value();
+ const auto f2 = w2.Value2().Value();
+ if (f1 == FloatLimits<T>::PosInfinity()) {
+ return w2;
+ } else if (f2 == FloatLimits<T>::PosInfinity()) {
+ return w1;
+ } else if (f1 == f2) {
+ if (equal) {
+ return SignedLogWeightTpl<T>(X1(w1.Value1()), X2(f2 - log(2.0F)));
+ } else {
+ return SignedLogWeightTpl<T>::Zero();
+ }
+ } else if (f1 > f2) {
+ if (equal) {
+ return SignedLogWeightTpl<T>(X1(w1.Value1()),
+ X2(f2 - log(1.0F + exp(f2 - f1))));
+ } else {
+ return SignedLogWeightTpl<T>(X1(w2.Value1()),
+ X2((f2 - log(1.0F - exp(f2 - f1)))));
+ }
+ } else {
+ if (equal) {
+ return SignedLogWeightTpl<T>(X1(w2.Value1()),
+ X2((f1 - log(1.0F + exp(f1 - f2)))));
+ } else {
+ return SignedLogWeightTpl<T>(X1(w1.Value1()),
+ X2((f1 - log(1.0F - exp(f1 - f2)))));
+ }
+ }
+}
+
+template <class T>
+inline SignedLogWeightTpl<T> Minus(const SignedLogWeightTpl<T> &w1,
+ const SignedLogWeightTpl<T> &w2) {
+ SignedLogWeightTpl<T> minus_w2(-w2.Value1().Value(), w2.Value2());
+ return Plus(w1, minus_w2);
+}
+
+template <class T>
+inline SignedLogWeightTpl<T> Times(const SignedLogWeightTpl<T> &w1,
+ const SignedLogWeightTpl<T> &w2) {
+ using X2 = LogWeightTpl<T>;
+ if (!w1.Member() || !w2.Member()) return SignedLogWeightTpl<T>::NoWeight();
+ const auto s1 = w1.Value1().Value() > 0.0;
+ const auto s2 = w2.Value1().Value() > 0.0;
+ const auto f1 = w1.Value2().Value();
+ const auto f2 = w2.Value2().Value();
+ if (s1 == s2) {
+ return SignedLogWeightTpl<T>(TropicalWeight(1.0), X2(f1 + f2));
+ } else {
+ return SignedLogWeightTpl<T>(TropicalWeight(-1.0), X2(f1 + f2));
+ }
+}
+
+template <class T>
+inline SignedLogWeightTpl<T> Divide(const SignedLogWeightTpl<T> &w1,
+ const SignedLogWeightTpl<T> &w2,
+ DivideType typ = DIVIDE_ANY) {
+ using X2 = LogWeightTpl<T>;
+ if (!w1.Member() || !w2.Member()) return SignedLogWeightTpl<T>::NoWeight();
+ const auto s1 = w1.Value1().Value() > 0.0;
+ const auto s2 = w2.Value1().Value() > 0.0;
+ const auto f1 = w1.Value2().Value();
+ const auto f2 = w2.Value2().Value();
+ if (f2 == FloatLimits<T>::PosInfinity()) {
+ return SignedLogWeightTpl<T>(TropicalWeight(1.0),
+ X2(FloatLimits<T>::NumberBad()));
+ } else if (f1 == FloatLimits<T>::PosInfinity()) {
+ return SignedLogWeightTpl<T>(TropicalWeight(1.0),
+ X2(FloatLimits<T>::PosInfinity()));
+ } else if (s1 == s2) {
+ return SignedLogWeightTpl<T>(TropicalWeight(1.0), X2(f1 - f2));
+ } else {
+ return SignedLogWeightTpl<T>(TropicalWeight(-1.0), X2(f1 - f2));
+ }
+}
+
+template <class T>
+inline bool ApproxEqual(const SignedLogWeightTpl<T> &w1,
+ const SignedLogWeightTpl<T> &w2, float delta = kDelta) {
+ const auto s1 = w1.Value1().Value() > 0.0;
+ const auto s2 = w2.Value1().Value() > 0.0;
+ if (s1 == s2) {
+ return ApproxEqual(w1.Value2(), w2.Value2(), delta);
+ } else {
+ return w1.Value2() == LogWeightTpl<T>::Zero() &&
+ w2.Value2() == LogWeightTpl<T>::Zero();
+ }
+}
+
+template <class T>
+inline bool operator==(const SignedLogWeightTpl<T> &w1,
+ const SignedLogWeightTpl<T> &w2) {
+ const auto s1 = w1.Value1().Value() > 0.0;
+ const auto s2 = w2.Value1().Value() > 0.0;
+ if (s1 == s2) {
+ return w1.Value2() == w2.Value2();
+ } else {
+ return (w1.Value2() == LogWeightTpl<T>::Zero()) &&
+ (w2.Value2() == LogWeightTpl<T>::Zero());
+ }
+}
+
+// Single-precision signed-log weight.
+using SignedLogWeight = SignedLogWeightTpl<float>;
+
+// Double-precision signed-log weight.
+using SignedLog64Weight = SignedLogWeightTpl<double>;
+
+template <class W1, class W2>
+bool SignedLogConvertCheck(W1 weight) {
+ if (weight.Value1().Value() < 0.0) {
+ FSTERROR() << "WeightConvert: Can't convert weight from " << W1::Type()
+ << " to " << W2::Type();
+ return false;
+ }
+ return true;
+}
+
+// Converts to tropical.
+template <>
+struct WeightConvert<SignedLogWeight, TropicalWeight> {
+ TropicalWeight operator()(const SignedLogWeight &weight) const {
+ if (!SignedLogConvertCheck<SignedLogWeight, TropicalWeight>(weight)) {
+ return TropicalWeight::NoWeight();
+ }
+ return TropicalWeight(weight.Value2().Value());
+ }
+};
+
+template <>
+struct WeightConvert<SignedLog64Weight, TropicalWeight> {
+ TropicalWeight operator()(const SignedLog64Weight &weight) const {
+ if (!SignedLogConvertCheck<SignedLog64Weight, TropicalWeight>(weight)) {
+ return TropicalWeight::NoWeight();
+ }
+ return TropicalWeight(weight.Value2().Value());
+ }
+};
+
+// Converts to log.
+template <>
+struct WeightConvert<SignedLogWeight, LogWeight> {
+ LogWeight operator()(const SignedLogWeight &weight) const {
+ if (!SignedLogConvertCheck<SignedLogWeight, LogWeight>(weight)) {
+ return LogWeight::NoWeight();
+ }
+ return LogWeight(weight.Value2().Value());
+ }
+};
+
+template <>
+struct WeightConvert<SignedLog64Weight, LogWeight> {
+ LogWeight operator()(const SignedLog64Weight &weight) const {
+ if (!SignedLogConvertCheck<SignedLog64Weight, LogWeight>(weight)) {
+ return LogWeight::NoWeight();
+ }
+ return LogWeight(weight.Value2().Value());
+ }
+};
+
+// Converts to log64.
+template <>
+struct WeightConvert<SignedLogWeight, Log64Weight> {
+ Log64Weight operator()(const SignedLogWeight &weight) const {
+ if (!SignedLogConvertCheck<SignedLogWeight, Log64Weight>(weight)) {
+ return Log64Weight::NoWeight();
+ }
+ return Log64Weight(weight.Value2().Value());
+ }
+};
+
+template <>
+struct WeightConvert<SignedLog64Weight, Log64Weight> {
+ Log64Weight operator()(const SignedLog64Weight &weight) const {
+ if (!SignedLogConvertCheck<SignedLog64Weight, Log64Weight>(weight)) {
+ return Log64Weight::NoWeight();
+ }
+ return Log64Weight(weight.Value2().Value());
+ }
+};
+
+// Converts to signed log.
+template <>
+struct WeightConvert<TropicalWeight, SignedLogWeight> {
+ SignedLogWeight operator()(const TropicalWeight &weight) const {
+ return SignedLogWeight(1.0, weight.Value());
+ }
+};
+
+template <>
+struct WeightConvert<LogWeight, SignedLogWeight> {
+ SignedLogWeight operator()(const LogWeight &weight) const {
+ return SignedLogWeight(1.0, weight.Value());
+ }
+};
+
+template <>
+struct WeightConvert<Log64Weight, SignedLogWeight> {
+ SignedLogWeight operator()(const Log64Weight &weight) const {
+ return SignedLogWeight(1.0, weight.Value());
+ }
+};
+
+template <>
+struct WeightConvert<SignedLog64Weight, SignedLogWeight> {
+ SignedLogWeight operator()(const SignedLog64Weight &weight) const {
+ return SignedLogWeight(weight.Value1(), weight.Value2().Value());
+ }
+};
+
+// Converts to signed log64.
+template <>
+struct WeightConvert<TropicalWeight, SignedLog64Weight> {
+ SignedLog64Weight operator()(const TropicalWeight &weight) const {
+ return SignedLog64Weight(1.0, weight.Value());
+ }
+};
+
+template <>
+struct WeightConvert<LogWeight, SignedLog64Weight> {
+ SignedLog64Weight operator()(const LogWeight &weight) const {
+ return SignedLog64Weight(1.0, weight.Value());
+ }
+};
+
+template <>
+struct WeightConvert<Log64Weight, SignedLog64Weight> {
+ SignedLog64Weight operator()(const Log64Weight &weight) const {
+ return SignedLog64Weight(1.0, weight.Value());
+ }
+};
+
+template <>
+struct WeightConvert<SignedLogWeight, SignedLog64Weight> {
+ SignedLog64Weight operator()(const SignedLogWeight &weight) const {
+ return SignedLog64Weight(weight.Value1(), weight.Value2().Value());
+ }
+};
+
+// This function object returns SignedLogWeightTpl<T>'s that are random integers
+// chosen from [0, num_random_weights) times a random sign. This is intended
+// primarily for testing.
+template <class T>
+class WeightGenerate<SignedLogWeightTpl<T>> {
+ public:
+ using Weight = SignedLogWeightTpl<T>;
+ using X1 = typename Weight::X1;
+ using X2 = typename Weight::X2;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t num_random_weights = kNumRandomWeights)
+ : allow_zero_(allow_zero), num_random_weights_(num_random_weights) {}
+
+ Weight operator()() const {
+ static const X1 negative_one(-1.0);
+ static const X1 positive_one(+1.0);
+ const int m = rand() % 2; // NOLINT
+ const int n = rand() % (num_random_weights_ + allow_zero_); // NOLINT
+ return Weight((m == 0) ? negative_one : positive_one,
+ (allow_zero_ && n == num_random_weights_) ?
+ X2::Zero() : X2(n));
+ }
+
+ private:
+ // Permits Zero() and zero divisors.
+ const bool allow_zero_;
+ // Number of alternative random weights.
+ const size_t num_random_weights_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_SIGNED_LOG_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Cartesian power weight semiring operation definitions, using
+// SparseTupleWeight as underlying representation.
+
+#ifndef FST_LIB_SPARSE_POWER_WEIGHT_H_
+#define FST_LIB_SPARSE_POWER_WEIGHT_H_
+
+#include <string>
+
+#include <fst/sparse-tuple-weight.h>
+#include <fst/weight.h>
+
+
+namespace fst {
+
+// Below SparseTupleWeight*Mapper are used in conjunction with
+// SparseTupleWeightMap to compute the respective semiring operations
+template <class W, class K>
+struct SparseTupleWeightPlusMapper {
+ W Map(const K &k, const W &v1, const W &v2) const { return Plus(v1, v2); }
+};
+
+template <class W, class K>
+struct SparseTupleWeightTimesMapper {
+ W Map(const K &k, const W &v1, const W &v2) const { return Times(v1, v2); }
+};
+
+template <class W, class K>
+struct SparseTupleWeightDivideMapper {
+ const DivideType type;
+
+ explicit SparseTupleWeightDivideMapper(DivideType type_) : type(type_) {}
+
+ W Map(const K &k, const W &v1, const W &v2) const {
+ return Divide(v1, v2, type);
+ }
+};
+
+template <class W, class K>
+struct SparseTupleWeightApproxMapper {
+ const float delta;
+
+ explicit SparseTupleWeightApproxMapper(float delta_ = kDelta)
+ : delta(delta_) {}
+
+ W Map(const K &k, const W &v1, const W &v2) const {
+ return ApproxEqual(v1, v2, delta) ? W::One() : W::Zero();
+ }
+};
+
+// Sparse 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.
+//
+// K is the key value type. kNoKey (-1) is reserved for internal use
+template <class W, class K = int>
+class SparsePowerWeight : public SparseTupleWeight<W, K> {
+ public:
+ using ReverseWeight = SparsePowerWeight<typename W::ReverseWeight, K>;
+
+ SparsePowerWeight() {}
+
+ explicit SparsePowerWeight(const SparseTupleWeight<W, K> &weight)
+ : SparseTupleWeight<W, K>(weight) {}
+
+ template <class Iterator>
+ SparsePowerWeight(Iterator begin, Iterator end)
+ : SparseTupleWeight<W, K>(begin, end) {}
+
+ SparsePowerWeight(const K &key, const W &weight)
+ : SparseTupleWeight<W, K>(key, weight) {}
+
+ static const SparsePowerWeight &Zero() {
+ static const SparsePowerWeight zero(SparseTupleWeight<W, K>::Zero());
+ return zero;
+ }
+
+ static const SparsePowerWeight &One() {
+ static const SparsePowerWeight one(SparseTupleWeight<W, K>::One());
+ return one;
+ }
+
+ static const SparsePowerWeight &NoWeight() {
+ static const SparsePowerWeight no_weight(
+ SparseTupleWeight<W, K>::NoWeight());
+ return no_weight;
+ }
+
+ // Overide this: Overwrite the Type method to reflect the key type if using
+ // a non-default key type.
+ static const string &Type() {
+ static string type;
+ if (type.empty()) {
+ type = W::Type() + "_^n";
+ if (sizeof(K) != sizeof(uint32)) {
+ string size;
+ Int64ToStr(8 * sizeof(K), &size);
+ type += "_" + size;
+ }
+ }
+ return type;
+ }
+
+ static constexpr uint64 Properties() {
+ return W::Properties() &
+ (kLeftSemiring | kRightSemiring | kCommutative | kIdempotent);
+ }
+
+ SparsePowerWeight Quantize(float delta = kDelta) const {
+ return SparsePowerWeight(SparseTupleWeight<W, K>::Quantize(delta));
+ }
+
+ ReverseWeight Reverse() const {
+ return ReverseWeight(SparseTupleWeight<W, K>::Reverse());
+ }
+};
+
+// Semimodule plus operation.
+template <class W, class K>
+inline SparsePowerWeight<W, K> Plus(const SparsePowerWeight<W, K> &w1,
+ const SparsePowerWeight<W, K> &w2) {
+ SparsePowerWeight<W, K> result;
+ SparseTupleWeightPlusMapper<W, K> operator_mapper;
+ SparseTupleWeightMap(&result, w1, w2, operator_mapper);
+ return result;
+}
+
+// Semimodule times operation.
+template <class W, class K>
+inline SparsePowerWeight<W, K> Times(const SparsePowerWeight<W, K> &w1,
+ const SparsePowerWeight<W, K> &w2) {
+ SparsePowerWeight<W, K> result;
+ SparseTupleWeightTimesMapper<W, K> operator_mapper;
+ SparseTupleWeightMap(&result, w1, w2, operator_mapper);
+ return result;
+}
+
+// Semimodule divide operation.
+template <class W, class K>
+inline SparsePowerWeight<W, K> Divide(const SparsePowerWeight<W, K> &w1,
+ const SparsePowerWeight<W, K> &w2,
+ DivideType type = DIVIDE_ANY) {
+ SparsePowerWeight<W, K> result;
+ SparseTupleWeightDivideMapper<W, K> operator_mapper(type);
+ SparseTupleWeightMap(&result, w1, w2, operator_mapper);
+ return result;
+}
+
+// Semimodule dot product operation.
+template <class W, class K>
+inline const W &DotProduct(const SparsePowerWeight<W, K> &w1,
+ const SparsePowerWeight<W, K> &w2) {
+ const SparsePowerWeight<W, K> product = Times(w1, w2);
+ W result(W::Zero());
+ for (SparseTupleWeightIterator<W, K> it(product); !it.Done(); it.Next()) {
+ result = Plus(result, it.Value().second);
+ }
+ return result;
+}
+
+template <class W, class K>
+inline bool ApproxEqual(const SparsePowerWeight<W, K> &w1,
+ const SparsePowerWeight<W, K> &w2,
+ float delta = kDelta) {
+ SparseTupleWeight<W, K> result;
+ SparseTupleWeightApproxMapper<W, K> operator_mapper(kDelta);
+ SparseTupleWeightMap(&result, w1, w2, operator_mapper);
+ return result == SparsePowerWeight<W, K>::One();
+}
+
+template <class W, class K>
+inline SparsePowerWeight<W, K> Times(const W &k,
+ const SparsePowerWeight<W, K> &w2) {
+ const SparseTupleWeight<W, K> t2(k);
+ const SparsePowerWeight<W, K> w1(t2);
+ return Times(w1, w2);
+}
+
+template <class W, class K>
+inline SparsePowerWeight<W, K> Times(const SparsePowerWeight<W, K> &w1,
+ const W &k) {
+ const SparseTupleWeight<W, K> t2(k);
+ const SparsePowerWeight<W, K> w2(t2);
+ return Times(w1, w2);
+}
+
+template <class W, class K>
+inline SparsePowerWeight<W, K> Divide(const SparsePowerWeight<W, K> &w1,
+ const W &k,
+ DivideType divide_type = DIVIDE_ANY) {
+ const SparseTupleWeight<W, K> t2(k);
+ const SparsePowerWeight<W, K> w2(t2);
+ return Divide(w1, w2, divide_type);
+}
+
+// This function object generates weights over the Cartesian power of rank
+// n over the underlying weight. This is intended primarily for testing.
+template <class W, class K>
+class WeightGenerate<SparsePowerWeight<W, K>> {
+ public:
+ using Weight = SparsePowerWeight<W, K>;
+ using Generate = WeightGenerate<W>;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t sparse_power_rank = 3)
+ : generate_(allow_zero), sparse_power_rank_(sparse_power_rank) {}
+
+ Weight operator()() const {
+ Weight weight;
+ for (auto i = 1; i <= sparse_power_rank_; ++i) {
+ weight.Push(i, generate_(), true);
+ }
+ return weight;
+ }
+
+ private:
+ const Generate generate_;
+ const size_t sparse_power_rank_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_SPARSE_POWER_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Sparse version of tuple-weight, based on tuple-weight.h.
+// Internally stores sparse key, value pairs in linked list. The default value
+// element is the assumed value of unset keys. Internal singleton
+// implementation that stores first key, value pair as a initialized member
+// variable to avoid unnecessary allocation on heap. Use
+// SparseTupleWeightIterator to iterate through the key,value pairs. Note:
+// this does NOT iterate through the default value.
+//
+// Sparse tuple weight set operation definitions.
+
+#ifndef FST_LIB_SPARSE_TUPLE_WEIGHT_H_
+#define FST_LIB_SPARSE_TUPLE_WEIGHT_H_
+
+#include <list>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+
+#include <fst/weight.h>
+
+
+namespace fst {
+
+template <class W, class K>
+class SparseTupleWeightIterator;
+
+// Arbitrary dimension tuple weight, stored as a sorted linked-list.
+// W is any weight class, and K is the key value type. kNoKey (-1) is reserved
+// for internal use.
+template <class W, class K = int>
+class SparseTupleWeight {
+ public:
+ using ReverseWeight = SparseTupleWeight<typename W::ReverseWeight, K>;
+
+ using Pair = std::pair<K, W>;
+
+ constexpr static K kNoKey = -1;
+
+ SparseTupleWeight() { Init(); }
+
+ template <class Iterator>
+ SparseTupleWeight(Iterator begin, Iterator end) {
+ Init();
+ // Assumes input iterator is sorted.
+ for (auto it = begin; it != end; ++it) Push(*it);
+ }
+
+ SparseTupleWeight(const K &key, const W &weight) {
+ Init();
+ Push(key, weight);
+ }
+
+ explicit SparseTupleWeight(const W &weight) { Init(weight); }
+
+ SparseTupleWeight(const SparseTupleWeight &weight) {
+ Init(weight.DefaultValue());
+ SetDefaultValue(weight.DefaultValue());
+ for (SparseTupleWeightIterator<W, K> it(weight); !it.Done(); it.Next()) {
+ Push(it.Value());
+ }
+ }
+
+ static const SparseTupleWeight &Zero() {
+ static const SparseTupleWeight zero(W::Zero());
+ return zero;
+ }
+
+ static const SparseTupleWeight &One() {
+ static const SparseTupleWeight one(W::One());
+ return one;
+ }
+
+ static const SparseTupleWeight &NoWeight() {
+ static const SparseTupleWeight no_weight(W::NoWeight());
+ return no_weight;
+ }
+
+ std::istream &Read(std::istream &strm) {
+ ReadType(strm, &default_);
+ ReadType(strm, &first_);
+ return ReadType(strm, &rest_);
+ }
+
+ std::ostream &Write(std::ostream &strm) const {
+ WriteType(strm, default_);
+ WriteType(strm, first_);
+ return WriteType(strm, rest_);
+ }
+
+ SparseTupleWeight &operator=(const SparseTupleWeight &weight) {
+ if (this == &weight) return *this; // Checks for identity.
+ Init(weight.DefaultValue());
+ for (SparseTupleWeightIterator<W, K> it(weight); !it.Done(); it.Next()) {
+ Push(it.Value());
+ }
+ return *this;
+ }
+
+ bool Member() const {
+ if (!DefaultValue().Member()) return false;
+ for (SparseTupleWeightIterator<W, K> it(*this); !it.Done(); it.Next()) {
+ if (!it.Value().second.Member()) return false;
+ }
+ return true;
+ }
+
+ // Assumes H() function exists for the hash of the key value.
+ size_t Hash() const {
+ size_t h = 0;
+ static const std::hash<K> H;
+ for (SparseTupleWeightIterator<W, K> it(*this); !it.Done(); it.Next()) {
+ h = 5 * h + H(it.Value().first);
+ h = 13 * h + it.Value().second.Hash();
+ }
+ return h;
+ }
+
+ SparseTupleWeight Quantize(float delta = kDelta) const {
+ SparseTupleWeight weight;
+ for (SparseTupleWeightIterator<W, K> it(*this); !it.Done(); it.Next()) {
+ weight.Push(it.Value().first, it.Value().second.Quantize(delta));
+ }
+ return weight;
+ }
+
+ ReverseWeight Reverse() const {
+ SparseTupleWeight weight;
+ for (SparseTupleWeightIterator<W, K> it(*this); !it.Done(); it.Next()) {
+ weight.Push(it.Value().first, it.Value().second.Reverse());
+ }
+ return ReverseWeight(weight);
+ }
+
+ void Init(const W &default_value = W::Zero()) {
+ first_.first = kNoKey;
+ // Initialized to the reserved key value.
+ default_ = default_value;
+ rest_.clear();
+ }
+
+ size_t Size() const {
+ if (first_.first == kNoKey) {
+ return 0;
+ } else {
+ return rest_.size() + 1;
+ }
+ }
+
+ inline void Push(const K &key, const W &weight,
+ bool default_value_check = true) {
+ Push(std::make_pair(key, weight), default_value_check);
+ }
+
+ inline void Push(const Pair &pair, bool default_value_check = true) {
+ if (default_value_check && pair.second == default_) return;
+ if (first_.first == kNoKey) {
+ first_ = pair;
+ } else {
+ rest_.push_back(pair);
+ }
+ }
+
+ void SetDefaultValue(const W &value) { default_ = value; }
+
+ const W &DefaultValue() const { return default_; }
+
+ private:
+ // Assumed default value of uninitialized keys, by default W::Zero().
+ W default_;
+
+ // Key values pairs are first stored in first_, then fill rest_ this way we
+ // can avoid dynamic allocation in the common case where the weight is a
+ // single key/value pair.
+ Pair first_;
+ std::list<Pair> rest_;
+
+ friend class SparseTupleWeightIterator<W, K>;
+};
+
+template <class W, class K>
+class SparseTupleWeightIterator {
+ public:
+ using Pair = typename SparseTupleWeight<W, K>::Pair;
+ using const_iterator = typename std::list<Pair>::const_iterator;
+ using iterator = typename std::list<Pair>::iterator;
+
+ explicit SparseTupleWeightIterator(const SparseTupleWeight<W, K> &weight)
+ : first_(weight.first_),
+ rest_(weight.rest_),
+ init_(true),
+ iter_(rest_.begin()) {}
+
+ bool Done() const {
+ if (init_) {
+ return first_.first == SparseTupleWeight<W, K>::kNoKey;
+ } else {
+ return iter_ == rest_.end();
+ }
+ }
+
+ const Pair &Value() const { return init_ ? first_ : *iter_; }
+
+ void Next() {
+ if (init_) {
+ init_ = false;
+ } else {
+ ++iter_;
+ }
+ }
+
+ void Reset() {
+ init_ = true;
+ iter_ = rest_.begin();
+ }
+
+ private:
+ const Pair &first_;
+ const std::list<Pair> &rest_;
+ bool init_; // In the initialized state?
+ const_iterator iter_;
+};
+
+template <class W, class K, class M>
+inline void SparseTupleWeightMap(SparseTupleWeight<W, K> *result,
+ const SparseTupleWeight<W, K> &w1,
+ const SparseTupleWeight<W, K> &w2,
+ const M &operator_mapper) {
+ SparseTupleWeightIterator<W, K> w1_it(w1);
+ SparseTupleWeightIterator<W, K> w2_it(w2);
+ const auto &v1_def = w1.DefaultValue();
+ const auto &v2_def = w2.DefaultValue();
+ result->SetDefaultValue(operator_mapper.Map(0, v1_def, v2_def));
+ while (!w1_it.Done() || !w2_it.Done()) {
+ const auto &k1 = (w1_it.Done()) ? w2_it.Value().first : w1_it.Value().first;
+ const auto &k2 = (w2_it.Done()) ? w1_it.Value().first : w2_it.Value().first;
+ const auto &v1 = (w1_it.Done()) ? v1_def : w1_it.Value().second;
+ const auto &v2 = (w2_it.Done()) ? v2_def : w2_it.Value().second;
+ if (k1 == k2) {
+ result->Push(k1, operator_mapper.Map(k1, v1, v2));
+ if (!w1_it.Done()) w1_it.Next();
+ if (!w2_it.Done()) w2_it.Next();
+ } else if (k1 < k2) {
+ result->Push(k1, operator_mapper.Map(k1, v1, v2_def));
+ w1_it.Next();
+ } else {
+ result->Push(k2, operator_mapper.Map(k2, v1_def, v2));
+ w2_it.Next();
+ }
+ }
+}
+
+template <class W, class K>
+inline bool operator==(const SparseTupleWeight<W, K> &w1,
+ const SparseTupleWeight<W, K> &w2) {
+ const auto &v1_def = w1.DefaultValue();
+ const auto &v2_def = w2.DefaultValue();
+ if (v1_def != v2_def) return false;
+ SparseTupleWeightIterator<W, K> w1_it(w1);
+ SparseTupleWeightIterator<W, K> w2_it(w2);
+ while (!w1_it.Done() || !w2_it.Done()) {
+ const auto &k1 = (w1_it.Done()) ? w2_it.Value().first : w1_it.Value().first;
+ const auto &k2 = (w2_it.Done()) ? w1_it.Value().first : w2_it.Value().first;
+ const auto &v1 = (w1_it.Done()) ? v1_def : w1_it.Value().second;
+ const auto &v2 = (w2_it.Done()) ? v2_def : w2_it.Value().second;
+ if (k1 == k2) {
+ if (v1 != v2) return false;
+ if (!w1_it.Done()) w1_it.Next();
+ if (!w2_it.Done()) w2_it.Next();
+ } else if (k1 < k2) {
+ if (v1 != v2_def) return false;
+ w1_it.Next();
+ } else {
+ if (v1_def != v2) return false;
+ w2_it.Next();
+ }
+ }
+ return true;
+}
+
+template <class W, class K>
+inline bool operator!=(const SparseTupleWeight<W, K> &w1,
+ const SparseTupleWeight<W, K> &w2) {
+ return !(w1 == w2);
+}
+
+template <class W, class K>
+inline std::ostream &operator<<(std::ostream &strm,
+ const SparseTupleWeight<W, K> &weight) {
+ CompositeWeightWriter writer(strm);
+ writer.WriteBegin();
+ writer.WriteElement(weight.DefaultValue());
+ for (SparseTupleWeightIterator<W, K> it(weight); !it.Done(); it.Next()) {
+ writer.WriteElement(it.Value().first);
+ writer.WriteElement(it.Value().second);
+ }
+ writer.WriteEnd();
+ return strm;
+}
+
+template <class W, class K>
+inline std::istream &operator>>(std::istream &strm,
+ SparseTupleWeight<W, K> &weight) {
+ CompositeWeightReader reader(strm);
+ reader.ReadBegin();
+ W def;
+ bool more = reader.ReadElement(&def);
+ weight.Init(def);
+ while (more) {
+ K key;
+ reader.ReadElement(&key);
+ W v;
+ more = reader.ReadElement(&v);
+ weight.Push(key, v);
+ }
+ reader.ReadEnd();
+ return strm;
+}
+
+} // namespace fst
+
+#endif // FST_LIB_SPARSE_TUPLE_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Class to map over/transform states e.g., sort transitions.
+//
+// Consider using when operation does not change the number of states.
+
+#ifndef FST_LIB_STATE_MAP_H_
+#define FST_LIB_STATE_MAP_H_
+
+#include <algorithm>
+#include <string>
+#include <utility>
+
+#include <fst/arc-map.h>
+#include <fst/cache.h>
+#include <fst/mutable-fst.h>
+
+
+namespace fst {
+
+// StateMapper Interface. The class determines how states are mapped; useful for
+// implementing operations that do not change the number of states.
+//
+// class StateMapper {
+// public:
+// using FromArc = A;
+// using ToArc = B;
+//
+// // Typical constructor.
+// StateMapper(const Fst<A> &fst);
+//
+// // Required copy constructor that allows updating FST argument;
+// // pass only if relevant and changed.
+// StateMapper(const StateMapper &mapper, const Fst<A> *fst = 0);
+//
+// // Specifies initial state of result.
+// B::StateId Start() const;
+// // Specifies state's final weight in result.
+// B::Weight Final(B::StateId state) const;
+//
+// // These methods iterate through a state's arcs in result.
+//
+// // Specifies state to iterate over.
+// void SetState(B::StateId state);
+//
+// // End of arcs?
+// bool Done() const;
+//
+// // Current arc.
+// const B &Value() const;
+//
+// // Advances to next arc (when !Done)
+// void Next();
+//
+// // Specifies input symbol table action the mapper requires (see above).
+// MapSymbolsAction InputSymbolsAction() const;
+//
+// // Specifies output symbol table action the mapper requires (see above).
+// MapSymbolsAction OutputSymbolsAction() const;
+//
+// // This specifies the known properties of an FST mapped by this
+// // mapper. It takes as argument the input FST's known properties.
+// uint64 Properties(uint64 props) const;
+// };
+//
+// We include a various state map versions below. One dimension of variation is
+// whether the mapping mutates its input, writes to a new result FST, or is an
+// on-the-fly Fst. Another dimension is how we pass the mapper. We allow passing
+// the mapper by pointer for cases that we need to change the state of the
+// user's mapper. We also include map versions that pass the mapper by value or
+// const reference when this suffices.
+
+// Maps an arc type A using a mapper function object C, passed by pointer. This
+// version modifies the input FST.
+template <class A, class C>
+void StateMap(MutableFst<A> *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<Fst<A>> 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 <class A, class C>
+void StateMap(MutableFst<A> *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 <class A, class B, class C>
+void StateMap(const Fst<A> &ifst, MutableFst<B> *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<Fst<A>> siter(ifst); !siter.Done(); siter.Next()) {
+ ofst->AddState();
+ }
+ ofst->SetStart(mapper->Start());
+ for (StateIterator<Fst<A>> 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 <class A, class B, class C>
+void StateMap(const Fst<A> &ifst, MutableFst<B> *ofst, C mapper) {
+ StateMap(ifst, ofst, &mapper);
+}
+
+using StateMapFstOptions = CacheOptions;
+
+template <class A, class B, class C>
+class StateMapFst;
+
+// Facade around StateIteratorBase<A> inheriting from StateIteratorBase<B>.
+template <class A, class B>
+class StateMapStateIteratorBase final : public StateIteratorBase<B> {
+ public:
+ using Arc = B;
+ using StateId = typename Arc::StateId;
+
+ explicit StateMapStateIteratorBase(StateIteratorBase<A> *base)
+ : base_(base) {}
+
+ bool Done() const override { return base_->Done(); }
+
+ StateId Value() const override { return base_->Value(); }
+
+ void Next() override { base_->Next(); }
+
+ void Reset() override { base_->Reset(); }
+
+ private:
+ std::unique_ptr<StateIteratorBase<A>> base_;
+
+ StateMapStateIteratorBase() = delete;
+};
+
+namespace internal {
+
+// Implementation of delayed StateMapFst.
+template <class A, class B, class C>
+class StateMapFstImpl : public CacheImpl<B> {
+ public:
+ using Arc = B;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<B>::SetType;
+ using FstImpl<B>::SetProperties;
+ using FstImpl<B>::SetInputSymbols;
+ using FstImpl<B>::SetOutputSymbols;
+
+ using CacheImpl<B>::PushArc;
+ using CacheImpl<B>::HasArcs;
+ using CacheImpl<B>::HasFinal;
+ using CacheImpl<B>::HasStart;
+ using CacheImpl<B>::SetArcs;
+ using CacheImpl<B>::SetFinal;
+ using CacheImpl<B>::SetStart;
+
+ friend class StateIterator<StateMapFst<A, B, C>>;
+
+ StateMapFstImpl(const Fst<A> &fst, const C &mapper,
+ const StateMapFstOptions &opts)
+ : CacheImpl<B>(opts),
+ fst_(fst.Copy()),
+ mapper_(new C(mapper, fst_.get())),
+ own_mapper_(true) {
+ Init();
+ }
+
+ StateMapFstImpl(const Fst<A> &fst, C *mapper, const StateMapFstOptions &opts)
+ : CacheImpl<B>(opts),
+ fst_(fst.Copy()),
+ mapper_(mapper),
+ own_mapper_(false) {
+ Init();
+ }
+
+ StateMapFstImpl(const StateMapFstImpl<A, B, C> &impl)
+ : CacheImpl<B>(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<B>::Start();
+ }
+
+ Weight Final(StateId state) {
+ if (!HasFinal(state)) SetFinal(state, mapper_->Final(state));
+ return CacheImpl<B>::Final(state);
+ }
+
+ size_t NumArcs(StateId state) {
+ if (!HasArcs(state)) Expand(state);
+ return CacheImpl<B>::NumArcs(state);
+ }
+
+ size_t NumInputEpsilons(StateId state) {
+ if (!HasArcs(state)) Expand(state);
+ return CacheImpl<B>::NumInputEpsilons(state);
+ }
+
+ size_t NumOutputEpsilons(StateId state) {
+ if (!HasArcs(state)) Expand(state);
+ return CacheImpl<B>::NumOutputEpsilons(state);
+ }
+
+ void InitStateIterator(StateIteratorData<B> *datb) const {
+ StateIteratorData<A> data;
+ fst_->InitStateIterator(&data);
+ datb->base = data.base ? new StateMapStateIteratorBase<A, B>(data.base)
+ : nullptr;
+ datb->nstates = data.nstates;
+ }
+
+ void InitArcIterator(StateId state, ArcIteratorData<B> *data) {
+ if (!HasArcs(state)) Expand(state);
+ CacheImpl<B>::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<Arc>::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<A> *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<const Fst<A>> 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 A, class B, class C>
+class StateMapFst : public ImplToFst<internal::StateMapFstImpl<A, B, C>> {
+ public:
+ friend class ArcIterator<StateMapFst<A, B, C>>;
+
+ using Arc = B;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::StateMapFstImpl<A, B, C>;
+
+ StateMapFst(const Fst<A> &fst, const C &mapper,
+ const StateMapFstOptions &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, mapper, opts)) {}
+
+ StateMapFst(const Fst<A> &fst, C *mapper, const StateMapFstOptions &opts)
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, mapper, opts)) {}
+
+ StateMapFst(const Fst<A> &fst, const C &mapper)
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, mapper, StateMapFstOptions())) {}
+
+ StateMapFst(const Fst<A> &fst, C *mapper)
+ : ImplToFst<Impl>(
+ std::make_shared<Impl>(fst, mapper, StateMapFstOptions())) {}
+
+ // See Fst<>::Copy() for doc.
+ StateMapFst(const StateMapFst<A, B, C> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Get a copy of this StateMapFst. See Fst<>::Copy() for further doc.
+ StateMapFst<A, B, C> *Copy(bool safe = false) const override {
+ return new StateMapFst<A, B, C>(*this, safe);
+ }
+
+ void InitStateIterator(StateIteratorData<B> *data) const override {
+ GetImpl()->InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId state, ArcIteratorData<B> *data) const override {
+ GetMutableImpl()->InitArcIterator(state, data);
+ }
+
+ protected:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ private:
+ StateMapFst &operator=(const StateMapFst &) = delete;
+};
+
+// Specialization for StateMapFst.
+template <class A, class B, class C>
+class ArcIterator<StateMapFst<A, B, C>>
+ : public CacheArcIterator<StateMapFst<A, B, C>> {
+ public:
+ using StateId = typename A::StateId;
+
+ ArcIterator(const StateMapFst<A, B, C> &fst, StateId state)
+ : CacheArcIterator<StateMapFst<A, B, C>>(fst.GetMutableImpl(), state) {
+ if (!fst.GetImpl()->HasArcs(state)) fst.GetMutableImpl()->Expand(state);
+ }
+};
+
+// Utility mappers.
+
+// Mapper that returns its input.
+template <class Arc>
+class IdentityStateMapper {
+ public:
+ using FromArc = Arc;
+ using ToArc = Arc;
+
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ explicit IdentityStateMapper(const Fst<Arc> &fst) : fst_(fst) {}
+
+ // Allows updating FST argument; pass only if changed.
+ IdentityStateMapper(const IdentityStateMapper<Arc> &mapper,
+ const Fst<Arc> *fst = nullptr)
+ : fst_(fst ? *fst : mapper.fst_) {}
+
+ StateId Start() const { return fst_.Start(); }
+
+ Weight Final(StateId state) const { return fst_.Final(state); }
+
+ void SetState(StateId state) {
+ aiter_.reset(new ArcIterator<Fst<Arc>>(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<Arc> &fst_;
+ std::unique_ptr<ArcIterator<Fst<Arc>>> aiter_;
+};
+
+template <class Arc>
+class ArcSumMapper {
+ public:
+ using FromArc = Arc;
+ using ToArc = Arc;
+
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ explicit ArcSumMapper(const Fst<Arc> &fst) : fst_(fst), i_(0) {}
+
+ // Allows updating FST argument; pass only if changed.
+ ArcSumMapper(const ArcSumMapper<Arc> &mapper, const Fst<Arc> *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<Fst<Arc>> 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<Arc> &fst_;
+ Compare comp_;
+ Equal equal_;
+ std::vector<Arc> arcs_;
+ ssize_t i_; // Current arc position.
+
+ ArcSumMapper &operator=(const ArcSumMapper &) = delete;
+};
+
+template <class Arc>
+class ArcUniqueMapper {
+ public:
+ using FromArc = Arc;
+ using ToArc = Arc;
+
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ explicit ArcUniqueMapper(const Fst<Arc> &fst) : fst_(fst), i_(0) {}
+
+ // Allows updating FST argument; pass only if changed.
+ ArcUniqueMapper(const ArcUniqueMapper<Arc> &mapper,
+ const Fst<Arc> *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<Fst<Arc>> 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<Arc> &fst_;
+ Compare comp_;
+ Equal equal_;
+ std::vector<Arc> arcs_;
+ size_t i_; // Current arc position.
+
+ ArcUniqueMapper &operator=(const ArcUniqueMapper &) = delete;
+};
+
+// Useful aliases when using StdArc.
+
+using StdArcSumMapper = ArcSumMapper<StdArc>;
+
+using StdArcUniqueMapper = ArcUniqueMapper<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_STATE_MAP_H_
--- /dev/null
+// 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_LIB_STATE_REACHABLE_H_
+#define FST_LIB_STATE_REACHABLE_H_
+
+#include <vector>
+
+#include <fst/connect.h>
+#include <fst/dfs-visit.h>
+#include <fst/fst.h>
+#include <fst/interval-set.h>
+#include <fst/vector-fst.h>
+
+
+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 Arc, class I = typename Arc::StateId, class S = IntervalSet<I>>
+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<Arc> &fst, std::vector<S> *isets,
+ std::vector<Index> *state2index)
+ : fst_(fst),
+ isets_(isets),
+ state2index_(state2index),
+ index_(state2index->empty() ? 1 : -1),
+ error_(false) {
+ isets_->clear();
+ }
+
+ void InitVisit(const Fst<Arc> &) { 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<Arc> &fst_;
+ std::vector<ISet> *isets_;
+ std::vector<Index> *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 Arc, class I = typename Arc::StateId, class S = IntervalSet<I>>
+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<Arc> &fst) : error_(false) {
+ if (fst.Properties(kAcyclic, true)) {
+ AcyclicStateReachable(fst);
+ } else {
+ CyclicStateReachable(fst);
+ }
+ }
+
+ explicit StateReachable(const StateReachable<Arc> &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<Index> &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<ISet> &IntervalSets() { return isets_; }
+
+ bool Error() const { return error_; }
+
+ private:
+ void AcyclicStateReachable(const Fst<Arc> &fst) {
+ IntervalReachVisitor<Arc, StateId, ISet> reach_visitor(fst, &isets_,
+ &state2index_);
+ DfsVisit(fst, &reach_visitor);
+ if (reach_visitor.Error()) error_ = true;
+ }
+
+ void CyclicStateReachable(const Fst<Arc> &fst) {
+ // Finds state reachability on the acyclic condensation FST.
+ VectorFst<Arc> cfst;
+ std::vector<StateId> scc;
+ Condense(fst, &cfst, &scc);
+ StateReachable reachable(cfst);
+ if (reachable.Error()) {
+ error_ = true;
+ return;
+ }
+ // Gets the number of states per SCC.
+ std::vector<size_t> 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<ISet> isets_; // Interval sets per state.
+ std::vector<Index> state2index_; // Finds index for a final state.
+ bool error_;
+
+ StateReachable &operator=(const StateReachable &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_STATE_REACHABLE_H_
--- /dev/null
+// 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_LIB_STATE_TABLE_H_
+#define FST_LIB_STATE_TABLE_H_
+
+#include <deque>
+#include <utility>
+#include <vector>
+
+#include <fst/bi-table.h>
+#include <fst/expanded-fst.h>
+#include <fst/filter-state.h>
+
+
+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 T>
+// 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<StateId> &Tuple(StateId s) const;
+//
+// // # of stored tuples.
+// StateId Size() const;
+// };
+//
+// A state tuple has the form:
+//
+// template <class S>
+// 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 T, class H>
+class HashStateTable : public HashBiTable<typename T::StateId, T, H> {
+ public:
+ using StateTuple = T;
+ using StateId = typename StateTuple::StateId;
+
+ using HashBiTable<StateId, StateTuple, H>::FindId;
+ using HashBiTable<StateId, StateTuple, H>::FindEntry;
+ using HashBiTable<StateId, StateTuple, H>::Size;
+
+ HashStateTable() : HashBiTable<StateId, StateTuple, H>() {}
+
+ explicit HashStateTable(size_t table_size)
+ : HashBiTable<StateId, StateTuple, H>(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 T, class H>
+class CompactHashStateTable
+ : public CompactHashBiTable<typename T::StateId, T, H> {
+ public:
+ using StateTuple = T;
+ using StateId = typename StateTuple::StateId;
+
+ using CompactHashBiTable<StateId, StateTuple, H>::FindId;
+ using CompactHashBiTable<StateId, StateTuple, H>::FindEntry;
+ using CompactHashBiTable<StateId, StateTuple, H>::Size;
+
+ CompactHashStateTable() : CompactHashBiTable<StateId, StateTuple, H>() {}
+
+ explicit CompactHashStateTable(size_t table_size)
+ : CompactHashBiTable<StateId, StateTuple, H>(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
+// objert, in which case the table takes ownership.
+template <class T, class FP>
+class VectorStateTable : public VectorBiTable<typename T::StateId, T, FP> {
+ public:
+ using StateTuple = T;
+ using StateId = typename StateTuple::StateId;
+
+ using VectorBiTable<StateId, StateTuple, FP>::FindId;
+ using VectorBiTable<StateId, StateTuple, FP>::FindEntry;
+ using VectorBiTable<StateId, StateTuple, FP>::Size;
+ using VectorBiTable<StateId, StateTuple, FP>::Fingerprint;
+
+ explicit VectorStateTable(FP *fingerprint = nullptr, size_t table_size = 0)
+ : VectorBiTable<StateId, StateTuple, FP>(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 T, class Select, class FP, class H>
+class VectorHashStateTable
+ : public VectorHashBiTable<typename T::StateId, T, Select, FP, H> {
+ public:
+ using StateTuple = T;
+ using StateId = typename StateTuple::StateId;
+
+ using VectorHashBiTable<StateId, StateTuple, Select, FP, H>::FindId;
+ using VectorHashBiTable<StateId, StateTuple, Select, FP, H>::FindEntry;
+ using VectorHashBiTable<StateId, StateTuple, Select, FP, H>::Size;
+ using VectorHashBiTable<StateId, StateTuple, Select, FP, H>::Selector;
+ using VectorHashBiTable<StateId, StateTuple, Select, FP, H>::Fingerprint;
+ using VectorHashBiTable<StateId, StateTuple, Select, FP, H>::Hash;
+
+ VectorHashStateTable(Select *select, FP *fingerprint, H *hash,
+ size_t vector_size = 0, size_t tuple_size = 0)
+ : VectorHashBiTable<StateId, StateTuple, Select, FP, H>(
+ 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 T, class H>
+class ErasableStateTable : public ErasableBiTable<typename T::StateId, T, H> {
+ public:
+ using StateTuple = T;
+ using StateId = typename StateTuple::StateId;
+
+ using ErasableBiTable<StateId, StateTuple, H>::FindId;
+ using ErasableBiTable<StateId, StateTuple, H>::FindEntry;
+ using ErasableBiTable<StateId, StateTuple, H>::Size;
+ using ErasableBiTable<StateId, StateTuple, H>::Erase;
+
+ ErasableStateTable() : ErasableBiTable<StateId, StateTuple, H>() {}
+
+ 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 Arc, class FilterState>
+// class ComposeStateTable {
+// public:
+// using StateId = typename Arc::StateId;
+//
+// // Required constructors.
+//
+// ComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &fst2);
+// ComposeStateTable(const ComposeStateTable<Arc, FilterState> &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<StateId> &Tuple(StateId s) const;
+//
+// // The number of of stored tuples.
+// StateId Size() const;
+//
+// // Return true if error was encountered.
+// bool Error() const;
+// };
+//
+// The following interface is used to represent the composition state.
+//
+// template <class S, class FS>
+// 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<StateId, StateId> StatePair() const;
+//
+// size_t Hash() const;
+//
+// friend bool operator==(const StateTuple& x, const StateTuple &y);
+// }
+//
+template <typename S, typename FS>
+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<StateId, StateId> &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 StateId1() + StateId2() * 7853 + GetFilterState().Hash() * 7867;
+ }
+
+ private:
+ std::pair<StateId, StateId> state_pair_;
+ FilterState fs_; // State of composition filter.
+};
+
+// Specialization for TrivialFilterState that does not explicitely store the
+// filter state since it is always the unique non-blocking state.
+template <typename S>
+class DefaultComposeStateTuple<S, TrivialFilterState> {
+ 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<StateId, StateId> &StatePair() const { return state_pair_; }
+
+ friend bool operator==(const DefaultComposeStateTuple &x,
+ const DefaultComposeStateTuple &y) {
+ return (&x == &y) || (x.state_pair_ == y.state_pair_);
+ }
+
+ size_t Hash() const { return StateId1() + StateId2() * 7853; }
+
+ private:
+ std::pair<StateId, StateId> state_pair_;
+};
+
+// Hashing of composition state tuples.
+template <typename T>
+class ComposeHash {
+ public:
+ size_t operator()(const T &t) const { return t.Hash(); }
+};
+
+// A HashStateTable over composition tuples.
+template <typename Arc, typename FilterState,
+ typename StateTuple =
+ DefaultComposeStateTuple<typename Arc::StateId, FilterState>,
+ typename StateTable =
+ CompactHashStateTable<StateTuple, ComposeHash<StateTuple>>>
+class GenericComposeStateTable : public StateTable {
+ public:
+ using StateId = typename Arc::StateId;
+
+ GenericComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {}
+
+ GenericComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &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 <typename StateTuple>
+class ComposeFingerprint {
+ public:
+ using StateId = typename StateTuple::StateId;
+
+ // Required but suboptimal constructor.
+ ComposeFingerprint() : mult1_(8192), mult2_(8192) {
+ LOG(WARNING) << "TupleFingerprint: # of FST states should be provided.";
+ }
+
+ // Constructor is provided the sizes of the input FSTs.
+ ComposeFingerprint(StateId nstates1, StateId nstates2)
+ : mult1_(nstates1), mult2_(nstates1 * nstates2) {}
+
+ size_t operator()(const StateTuple &tuple) {
+ return tuple.StateId1() + tuple.StateId2() * mult1_ +
+ tuple.GetFilterState().Hash() * mult2_;
+ }
+
+ private:
+ const ssize_t mult1_;
+ const ssize_t mult2_;
+};
+
+// Useful when the first composition state determines the tuple.
+template <typename StateTuple>
+class ComposeState1Fingerprint {
+ public:
+ size_t operator()(const StateTuple &tuple) { return tuple.StateId1(); }
+};
+
+// Useful when the second composition state determines the tuple.
+template <typename StateTuple>
+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 <typename Arc, typename StateTuple>
+class ProductComposeStateTable
+ : public VectorStateTable<StateTuple, ComposeFingerprint<StateTuple>> {
+ public:
+ using StateId = typename Arc::StateId;
+ using StateTable =
+ VectorStateTable<StateTuple, ComposeFingerprint<StateTuple>>;
+
+ ProductComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ size_t table_size = 0)
+ : StateTable(new ComposeFingerprint<StateTuple>(CountStates(fst1),
+ CountStates(fst2)),
+ table_size) {}
+
+ ProductComposeStateTable(
+ const ProductComposeStateTable<Arc, StateTuple> &table)
+ : StateTable(new ComposeFingerprint<StateTuple>(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 kStringProperties) 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 <typename Arc, typename StateTuple>
+class StringDetComposeStateTable
+ : public VectorStateTable<StateTuple,
+ ComposeState1Fingerprint<StateTuple>> {
+ public:
+ using StateId = typename Arc::StateId;
+ using StateTable =
+ VectorStateTable<StateTuple, ComposeState1Fingerprint<StateTuple>>;
+
+ StringDetComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &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<Arc, StateTuple> &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 <typename Arc, typename StateTuple>
+class DetStringComposeStateTable
+ : public VectorStateTable<StateTuple,
+ ComposeState2Fingerprint<StateTuple>> {
+ public:
+ using StateId = typename Arc::StateId;
+ using StateTable =
+ VectorStateTable<StateTuple, ComposeState2Fingerprint<StateTuple>>;
+
+ DetStringComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &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<Arc, StateTuple> &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 <typename Arc, typename StateTuple>
+class ErasableComposeStateTable
+ : public ErasableStateTable<StateTuple, ComposeHash<StateTuple>> {
+ public:
+ ErasableComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {}
+
+ constexpr bool Error() const { return false; }
+
+ private:
+ ErasableComposeStateTable &operator=(const ErasableComposeStateTable &table) =
+ delete;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_STATE_TABLE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Function to sort states of an FST.
+
+#ifndef FST_LIB_STATESORT_H_
+#define FST_LIB_STATESORT_H_
+
+#include <algorithm>
+#include <vector>
+
+#include <fst/mutable-fst.h>
+
+
+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 <class Arc>
+void StateSort(MutableFst<Arc> *fst,
+ const std::vector<typename Arc::StateId> &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<bool> done(order.size(), false);
+ std::vector<Arc> arcsa;
+ std::vector<Arc> arcsb;
+ fst->SetStart(order[fst->Start()]);
+ for (StateIterator<MutableFst<Arc>> 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<MutableFst<Arc>> 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<MutableFst<Arc>> 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_LIB_STATESORT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// String weight set and associated semiring operation definitions.
+
+#ifndef FST_LIB_STRING_WEIGHT_H_
+#define FST_LIB_STRING_WEIGHT_H_
+
+#include <cstdlib>
+
+#include <list>
+#include <string>
+#include <vector>
+
+#include <fst/product-weight.h>
+#include <fst/union-weight.h>
+#include <fst/weight.h>
+
+
+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 };
+
+#define REVERSE_STRING_TYPE(S) \
+ ((S) == STRING_LEFT ? STRING_RIGHT \
+ : ((S) == STRING_RIGHT ? STRING_LEFT : STRING_RESTRICT))
+
+template <typename Label, StringType S = STRING_LEFT>
+class StringWeight;
+
+template <typename Label, StringType S = STRING_LEFT>
+class StringWeightIterator;
+
+template <typename Label, StringType S = STRING_LEFT>
+class StringWeightReverseIterator;
+
+template <typename Label, StringType S>
+bool operator==(const StringWeight<Label, S> &, const StringWeight<Label, S> &);
+
+// String semiring: (longest_common_prefix/suffix, ., Infinity, Epsilon)
+template <typename Label, StringType S>
+class StringWeight {
+ public:
+ using ReverseWeight = StringWeight<Label, REVERSE_STRING_TYPE(S)>;
+
+ friend class StringWeightIterator<Label, S>;
+ friend class StringWeightReverseIterator<Label, S>;
+ friend bool operator==
+ <>(const StringWeight<Label, S> &, const StringWeight<Label, S> &);
+
+ StringWeight() { Init(); }
+
+ template <typename Iterator>
+ StringWeight(const Iterator &begin, const Iterator &end) {
+ Init();
+ for (auto iter = begin; iter != end; ++iter) PushBack(*iter);
+ }
+
+ explicit StringWeight(Label label) {
+ Init();
+ PushBack(label);
+ }
+
+ static const StringWeight<Label, S> &Zero() {
+ static const StringWeight<Label, S> zero(kStringInfinity);
+ return zero;
+ }
+
+ static const StringWeight<Label, S> &One() {
+ static const StringWeight<Label, S> one;
+ return one;
+ }
+
+ static const StringWeight<Label, S> &NoWeight() {
+ static const StringWeight<Label, S> no_weight(kStringBad);
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type =
+ 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<Label, S> Quantize(float delta = kDelta) const { return *this; }
+
+ ReverseWeight Reverse() const;
+
+ // TODO(kbg): Make this constexpr once C++14 support for conditionals in
+ // constexpr functions hits. As is, it can only be done very awkwardly with
+ // SFINAE enable-if magic.
+ static uint64 Properties() {
+ if (S == STRING_LEFT) {
+ static constexpr auto props = kLeftSemiring | kIdempotent;
+ return props;
+ } else if (S == STRING_RIGHT) {
+ static constexpr auto props = kRightSemiring | kIdempotent;
+ return props;
+ } else {
+ static constexpr auto props =
+ kLeftSemiring | kRightSemiring | kIdempotent;
+ return props;
+ }
+ }
+
+ // These operations combined with the StringWeightIterator and
+ // StringWeightReverseIterator provide the access and mutation of the string
+ // internal elements.
+
+ // Common initializer among constructors.
+ void Init() { first_ = 0; }
+
+ // 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_; // Rirst label in string (0 if empty).
+ std::list<Label> rest_; // Remaining labels in string.
+};
+
+// Traverses string in forward direction.
+template <typename Label, StringType S>
+class StringWeightIterator {
+ public:
+ explicit StringWeightIterator(const StringWeight<Label, S> &w)
+ : first_(w.first_), rest_(w.rest_), init_(true), iter_(rest_.begin()) {}
+
+ bool Done() const {
+ if (init_) {
+ return first_ == 0;
+ } else {
+ return iter_ == rest_.end();
+ }
+ }
+
+ const Label &Value() const { return init_ ? first_ : *iter_; }
+
+ void Next() {
+ if (init_) {
+ init_ = false;
+ } else {
+ ++iter_;
+ }
+ }
+
+ void Reset() {
+ init_ = true;
+ iter_ = rest_.begin();
+ }
+
+ private:
+ const Label &first_;
+ const std::list<Label> &rest_;
+ bool init_; // In the initialized state?
+ typename std::list<Label>::const_iterator iter_;
+};
+
+// Traverses string in backward direction.
+template <typename Label, StringType S>
+class StringWeightReverseIterator {
+ public:
+ explicit StringWeightReverseIterator(const StringWeight<Label, S> &w)
+ : first_(w.first_),
+ rest_(w.rest_),
+ fin_(first_ == 0),
+ iter_(rest_.rbegin()) {}
+
+ bool Done() const { return fin_; }
+
+ const Label &Value() const { return iter_ == rest_.rend() ? first_ : *iter_; }
+
+ void Next() {
+ if (iter_ == rest_.rend()) {
+ fin_ = true;
+ } else {
+ ++iter_;
+ }
+ }
+
+ void Reset() {
+ fin_ = false;
+ iter_ = rest_.rbegin();
+ }
+
+ private:
+ const Label &first_;
+ const std::list<Label> &rest_;
+ bool fin_; // In the final state?
+ typename std::list<Label>::const_reverse_iterator iter_;
+};
+
+// StringWeight member functions follow that require
+// StringWeightIterator or StringWeightReverseIterator.
+
+template <typename Label, StringType S>
+inline std::istream &StringWeight<Label, S>::Read(std::istream &strm) {
+ Clear();
+ int32 size;
+ ReadType(strm, &size);
+ for (int32 i = 0; i < size; ++i) {
+ Label label;
+ ReadType(strm, &label);
+ PushBack(label);
+ }
+ return strm;
+}
+
+template <typename Label, StringType S>
+inline std::ostream &StringWeight<Label, S>::Write(std::ostream &strm) const {
+ const int32 size = Size();
+ WriteType(strm, size);
+ for (StringWeightIterator<Label, S> iter(*this); !iter.Done(); iter.Next()) {
+ WriteType(strm, iter.Value());
+ }
+ return strm;
+}
+
+template <typename Label, StringType S>
+inline bool StringWeight<Label, S>::Member() const {
+ StringWeightIterator<Label, S> iter(*this);
+ return iter.Value() != kStringBad;
+}
+
+template <typename Label, StringType S>
+inline typename StringWeight<Label, S>::ReverseWeight
+StringWeight<Label, S>::Reverse() const {
+ ReverseWeight rweight;
+ for (StringWeightIterator<Label, S> iter(*this); !iter.Done(); iter.Next()) {
+ rweight.PushFront(iter.Value());
+ }
+ return rweight;
+}
+
+template <typename Label, StringType S>
+inline size_t StringWeight<Label, S>::Hash() const {
+ size_t h = 0;
+ for (StringWeightIterator<Label, S> iter(*this); !iter.Done(); iter.Next()) {
+ h ^= h << 1 ^ iter.Value();
+ }
+ return h;
+}
+
+template <typename Label, StringType S>
+inline bool operator==(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2) {
+ if (w1.Size() != w2.Size()) return false;
+ using WeightIterator = StringWeightIterator<Label, S>;
+ WeightIterator iter1(w1);
+ WeightIterator iter2(w2);
+ for (; !iter1.Done(); iter1.Next(), iter2.Next()) {
+ if (iter1.Value() != iter2.Value()) return false;
+ }
+ return true;
+}
+
+template <typename Label, StringType S>
+inline bool operator!=(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2) {
+ return !(w1 == w2);
+}
+
+template <typename Label, StringType S>
+inline bool ApproxEqual(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2,
+ float delta = kDelta) {
+ return w1 == w2;
+}
+
+template <typename Label, StringType S>
+inline std::ostream &operator<<(std::ostream &strm,
+ const StringWeight<Label, S> &weight) {
+ StringWeightIterator<Label, S> iter(weight);
+ if (iter.Done()) {
+ return strm << "Epsilon";
+ } else if (iter.Value() == kStringInfinity) {
+ return strm << "Infinity";
+ } else if (iter.Value() == kStringBad) {
+ return strm << "BadString";
+ } else {
+ for (auto i = 0; !iter.Done(); ++i, iter.Next()) {
+ if (i > 0) strm << kStringSeparator;
+ strm << iter.Value();
+ }
+ }
+ return strm;
+}
+
+template <typename Label, StringType S>
+inline std::istream &operator>>(std::istream &strm,
+ StringWeight<Label, S> &weight) {
+ string str;
+ strm >> str;
+ if (str == "Infinity") {
+ weight = StringWeight<Label, S>::Zero();
+ } else if (str == "Epsilon") {
+ weight = StringWeight<Label, S>::One();
+ } else {
+ weight.Clear();
+ char *p = nullptr;
+ for (const char *cs = str.c_str(); !p || *p != '\0'; cs = p + 1) {
+ const Label label = strtoll(cs, &p, 10);
+ if (p == cs || (*p != 0 && *p != kStringSeparator)) {
+ strm.clear(std::ios::badbit);
+ break;
+ }
+ weight.PushBack(label);
+ }
+ }
+ return strm;
+}
+
+// Default is for the restricted string semiring. String equality is required
+// (for non-Zero() input. The restriction is used (e.g., in determinization) to
+// ensure the input is functional.
+template <typename Label, StringType S>
+inline StringWeight<Label, S> Plus(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2) {
+ using Weight = StringWeight<Label, S>;
+ if (!w1.Member() || !w2.Member()) return Weight::NoWeight();
+ if (w1 == Weight::Zero()) return w2;
+ if (w2 == Weight::Zero()) return w1;
+ if (w1 != w2) {
+ FSTERROR() << "StringWeight::Plus: Unequal arguments "
+ << "(non-functional FST?)"
+ << " w1 = " << w1 << " w2 = " << w2;
+ return Weight::NoWeight();
+ }
+ return w1;
+}
+
+// Longest common prefix for left string semiring.
+template <typename Label>
+inline StringWeight<Label, STRING_LEFT> Plus(
+ const StringWeight<Label, STRING_LEFT> &w1,
+ const StringWeight<Label, STRING_LEFT> &w2) {
+ using Weight = StringWeight<Label, STRING_LEFT>;
+ if (!w1.Member() || !w2.Member()) return Weight::NoWeight();
+ if (w1 == Weight::Zero()) return w2;
+ if (w2 == Weight::Zero()) return w1;
+ Weight sum;
+ using WeightIterator = StringWeightIterator<Label, STRING_LEFT>;
+ WeightIterator iter1(w1);
+ WeightIterator iter2(w2);
+ for (; !iter1.Done() && !iter2.Done() && iter1.Value() == iter2.Value();
+ iter1.Next(), iter2.Next()) {
+ sum.PushBack(iter1.Value());
+ }
+ return sum;
+}
+
+// Longest common suffix for right string semiring.
+template <typename Label>
+inline StringWeight<Label, STRING_RIGHT> Plus(
+ const StringWeight<Label, STRING_RIGHT> &w1,
+ const StringWeight<Label, STRING_RIGHT> &w2) {
+ using Weight = StringWeight<Label, STRING_RIGHT>;
+ if (!w1.Member() || !w2.Member()) return Weight::NoWeight();
+ if (w1 == Weight::Zero()) return w2;
+ if (w2 == Weight::Zero()) return w1;
+ Weight sum;
+ using WeightReverseIterator =
+ StringWeightReverseIterator<Label, STRING_RIGHT>;
+ WeightReverseIterator iter1(w1);
+ WeightReverseIterator iter2(w2);
+ for (; !iter1.Done() && !iter2.Done() && iter1.Value() == iter2.Value();
+ iter1.Next(), iter2.Next()) {
+ sum.PushFront(iter1.Value());
+ }
+ return sum;
+}
+
+template <typename Label, StringType S>
+inline StringWeight<Label, S> Times(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2) {
+ using Weight = StringWeight<Label, S>;
+ if (!w1.Member() || !w2.Member()) return Weight::NoWeight();
+ if (w1 == Weight::Zero() || w2 == Weight::Zero()) return Weight::Zero();
+ Weight product(w1);
+ for (StringWeightIterator<Label, S> iter(w2); !iter.Done(); iter.Next()) {
+ product.PushBack(iter.Value());
+ }
+ return product;
+}
+
+// Left division in a left string semiring.
+template <typename Label, StringType S>
+inline StringWeight<Label, S> DivideLeft(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2) {
+ using Weight = StringWeight<Label, S>;
+ if (!w1.Member() || !w2.Member()) return Weight::NoWeight();
+ if (w2 == Weight::Zero()) {
+ return Weight(kStringBad);
+ } else if (w1 == Weight::Zero()) {
+ return Weight::Zero();
+ }
+ Weight result;
+ StringWeightIterator<Label, S> iter(w1);
+ size_t i = 0;
+ for (; !iter.Done() && i < w2.Size(); iter.Next(), ++i) {
+ }
+ for (; !iter.Done(); iter.Next()) result.PushBack(iter.Value());
+ return result;
+}
+
+// Right division in a right string semiring.
+template <typename Label, StringType S>
+inline StringWeight<Label, S> DivideRight(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2) {
+ using Weight = StringWeight<Label, S>;
+ if (!w1.Member() || !w2.Member()) return Weight::NoWeight();
+ if (w2 == Weight::Zero()) {
+ return Weight(kStringBad);
+ } else if (w1 == Weight::Zero()) {
+ return Weight::Zero();
+ }
+ Weight result;
+ StringWeightReverseIterator<Label, S> iter(w1);
+ size_t i = 0;
+ for (; !iter.Done() && i < w2.Size(); iter.Next(), ++i) {
+ }
+ for (; !iter.Done(); iter.Next()) result.PushFront(iter.Value());
+ return result;
+}
+
+// Default is the restricted string semiring.
+template <typename Label, StringType S>
+inline StringWeight<Label, S> Divide(const StringWeight<Label, S> &w1,
+ const StringWeight<Label, S> &w2,
+ DivideType divide_type) {
+ using Weight = StringWeight<Label, S>;
+ if (divide_type == DIVIDE_LEFT) {
+ return DivideLeft(w1, w2);
+ } else if (divide_type == DIVIDE_RIGHT) {
+ return DivideRight(w1, w2);
+ } else {
+ FSTERROR() << "StringWeight::Divide: "
+ << "Only explicit left or right division is defined "
+ << "for the " << Weight::Type() << " semiring";
+ return Weight::NoWeight();
+ }
+}
+
+// Left division in the left string semiring.
+template <typename Label>
+inline StringWeight<Label, STRING_LEFT> Divide(
+ const StringWeight<Label, STRING_LEFT> &w1,
+ const StringWeight<Label, STRING_LEFT> &w2, DivideType divide_type) {
+ if (divide_type != DIVIDE_LEFT) {
+ FSTERROR() << "StringWeight::Divide: Only left division is defined "
+ << "for the left string semiring";
+ return StringWeight<Label, STRING_LEFT>::NoWeight();
+ }
+ return DivideLeft(w1, w2);
+}
+
+// Right division in the right string semiring.
+template <typename Label>
+inline StringWeight<Label, STRING_RIGHT> Divide(
+ const StringWeight<Label, STRING_RIGHT> &w1,
+ const StringWeight<Label, STRING_RIGHT> &w2, DivideType divide_type) {
+ if (divide_type != DIVIDE_RIGHT) {
+ FSTERROR() << "StringWeight::Divide: Only right division is defined "
+ << "for the right string semiring";
+ return StringWeight<Label, STRING_RIGHT>::NoWeight();
+ }
+ return DivideRight(w1, w2);
+}
+
+// This function object generates StringWeights that are random integer strings
+// from {1, ... , alphabet_size)^{0, max_string_length} U { Zero }. This is
+// intended primarily for testing.
+template <class Label, StringType S>
+class WeightGenerate<StringWeight<Label, S>> {
+ public:
+ using Weight = StringWeight<Label, S>;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t alphabet_size = kNumRandomWeights,
+ size_t max_string_length = kNumRandomWeights)
+ : allow_zero_(allow_zero), alphabet_size_(alphabet_size),
+ max_string_length_(max_string_length) {}
+
+ Weight operator()() const {
+ int n = rand() % (max_string_length_ + allow_zero_); // NOLINT
+ if (allow_zero_ && n == max_string_length_) return Weight::Zero();
+ std::vector<Label> labels(n);
+ for (auto i = 0; i < n; ++i) {
+ labels.push_back(rand() % alphabet_size_ + 1); // NOLINT
+ }
+ return Weight(labels.begin(), labels.end());
+ }
+
+ private:
+ // Permits Zero() and zero divisors.
+ const bool allow_zero_;
+ // Alphabet size for random weights.
+ const size_t alphabet_size_;
+ // Number of alternative random weights.
+ const size_t max_string_length_;
+};
+
+// Determines whether to use left, right, or (general) gallic semiring. Includes
+// a restricted version that signals an error if proper string prefixes or
+// suffixes would otherwise be returned by string Plus. This is useful with
+// algorithms that require functional transducer input. Also includes min
+// version that changes the Plus to keep only the lowest W weight string.
+enum GallicType {
+ GALLIC_LEFT = 0,
+ GALLIC_RIGHT = 1,
+ GALLIC_RESTRICT = 2,
+ GALLIC_MIN = 3,
+ GALLIC = 4
+};
+
+#define GALLIC_STRING_TYPE(G) \
+ ((G) == GALLIC_LEFT ? STRING_LEFT : ((G) == GALLIC_RIGHT ? STRING_RIGHT \
+ : STRING_RESTRICT))
+
+#define REVERSE_GALLIC_TYPE(G) \
+ ((G) == GALLIC_LEFT \
+ ? GALLIC_RIGHT \
+ : ((G) == GALLIC_RIGHT \
+ ? GALLIC_LEFT \
+ : ((G) == GALLIC_RESTRICT \
+ ? GALLIC_RESTRICT \
+ : ((G) == GALLIC_MIN ? GALLIC_MIN : GALLIC))))
+
+// Product of string weight and an arbitraryy weight.
+template <class Label, class W, GallicType G = GALLIC_LEFT>
+struct GallicWeight
+ : public ProductWeight<StringWeight<Label, GALLIC_STRING_TYPE(G)>, W> {
+ using ReverseWeight =
+ GallicWeight<Label, typename W::ReverseWeight, REVERSE_GALLIC_TYPE(G)>;
+ using SW = StringWeight<Label, GALLIC_STRING_TYPE(G)>;
+
+ using ProductWeight<SW, W>::Properties;
+
+ GallicWeight() {}
+
+ GallicWeight(SW w1, W w2) : ProductWeight<SW, W>(w1, w2) {}
+
+ explicit GallicWeight(const string &s, int *nread = nullptr)
+ : ProductWeight<SW, W>(s, nread) {}
+
+ explicit GallicWeight(const ProductWeight<SW, W> &w)
+ : ProductWeight<SW, W>(w) {}
+
+ static const GallicWeight &Zero() {
+ static const GallicWeight zero(ProductWeight<SW, W>::Zero());
+ return zero;
+ }
+
+ static const GallicWeight &One() {
+ static const GallicWeight one(ProductWeight<SW, W>::One());
+ return one;
+ }
+
+ static const GallicWeight &NoWeight() {
+ static const GallicWeight no_weight(ProductWeight<SW, W>::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type =
+ G == GALLIC_LEFT
+ ? "left_gallic"
+ : (G == GALLIC_RIGHT
+ ? "right_gallic"
+ : (G == GALLIC_RESTRICT
+ ? "restricted_gallic"
+ : (G == GALLIC_MIN ? "min_gallic" : "gallic")));
+ return type;
+ }
+
+ GallicWeight Quantize(float delta = kDelta) const {
+ return GallicWeight(ProductWeight<SW, W>::Quantize(delta));
+ }
+
+ ReverseWeight Reverse() const {
+ return ReverseWeight(ProductWeight<SW, W>::Reverse());
+ }
+};
+
+// Default plus.
+template <class Label, class W, GallicType G>
+inline GallicWeight<Label, W, G> Plus(const GallicWeight<Label, W, G> &w,
+ const GallicWeight<Label, W, G> &v) {
+ return GallicWeight<Label, W, G>(Plus(w.Value1(), v.Value1()),
+ Plus(w.Value2(), v.Value2()));
+}
+
+// Min gallic plus.
+template <class Label, class W>
+inline GallicWeight<Label, W, GALLIC_MIN> Plus(
+ const GallicWeight<Label, W, GALLIC_MIN> &w1,
+ const GallicWeight<Label, W, GALLIC_MIN> &w2) {
+ static const NaturalLess<W> less;
+ return less(w1.Value2(), w2.Value2()) ? w1 : w2;
+}
+
+template <class Label, class W, GallicType G>
+inline GallicWeight<Label, W, G> Times(const GallicWeight<Label, W, G> &w,
+ const GallicWeight<Label, W, G> &v) {
+ return GallicWeight<Label, W, G>(Times(w.Value1(), v.Value1()),
+ Times(w.Value2(), v.Value2()));
+}
+
+template <class Label, class W, GallicType G>
+inline GallicWeight<Label, W, G> Divide(const GallicWeight<Label, W, G> &w,
+ const GallicWeight<Label, W, G> &v,
+ DivideType divide_type = DIVIDE_ANY) {
+ return GallicWeight<Label, W, G>(Divide(w.Value1(), v.Value1(), divide_type),
+ Divide(w.Value2(), v.Value2(), divide_type));
+}
+
+// This function object generates gallic weights by calling an underlying
+// product weight generator. This is intended primarily for testing.
+template <class Label, class W, GallicType G>
+class WeightGenerate<GallicWeight<Label, W, G>>
+ : public WeightGenerate<
+ ProductWeight<StringWeight<Label, GALLIC_STRING_TYPE(G)>, W>> {
+ public:
+ using Weight = GallicWeight<Label, W, G>;
+ using Generate = WeightGenerate<
+ ProductWeight<StringWeight<Label, GALLIC_STRING_TYPE(G)>, W>>;
+
+ explicit WeightGenerate(bool allow_zero = true) : generate_(allow_zero) {}
+
+ Weight operator()() const { return Weight(generate_()); }
+
+ private:
+ const Generate generate_;
+};
+
+// Union weight options for (general) GALLIC type.
+template <class Label, class W>
+struct GallicUnionWeightOptions {
+ using ReverseOptions = GallicUnionWeightOptions<Label, W>;
+ using GW = GallicWeight<Label, W, GALLIC_RESTRICT>;
+ using SW = StringWeight<Label, GALLIC_STRING_TYPE(GALLIC_RESTRICT)>;
+ using SI = StringWeightIterator<Label, GALLIC_STRING_TYPE(GALLIC_RESTRICT)>;
+
+ // Military order.
+ struct Compare {
+ bool operator()(const GW &w1, const GW &w2) const {
+ const SW &s1 = w1.Value1();
+ const SW &s2 = w2.Value1();
+ if (s1.Size() < s2.Size()) return true;
+ if (s1.Size() > s2.Size()) return false;
+ SI iter1(s1);
+ SI iter2(s2);
+ while (!iter1.Done()) {
+ const auto l1 = iter1.Value();
+ const auto l2 = iter2.Value();
+ if (l1 < l2) return true;
+ if (l1 > l2) return false;
+ iter1.Next();
+ iter2.Next();
+ }
+ return false;
+ }
+ };
+
+ // Adds W weights when string part equal.
+ struct Merge {
+ GW operator()(const GW &w1, const GW &w2) const {
+ return GW(w1.Value1(), Plus(w1.Value2(), w2.Value2()));
+ }
+ };
+};
+
+// Specialization for the (general) GALLIC type.
+template <class Label, class W>
+struct GallicWeight<Label, W, GALLIC>
+ : public UnionWeight<GallicWeight<Label, W, GALLIC_RESTRICT>,
+ GallicUnionWeightOptions<Label, W>> {
+ using GW = GallicWeight<Label, W, GALLIC_RESTRICT>;
+ using SW = StringWeight<Label, GALLIC_STRING_TYPE(GALLIC_RESTRICT)>;
+ using SI = StringWeightIterator<Label, GALLIC_STRING_TYPE(GALLIC_RESTRICT)>;
+ using UW = UnionWeight<GW, GallicUnionWeightOptions<Label, W>>;
+ using UI = UnionWeightIterator<GW, GallicUnionWeightOptions<Label, W>>;
+ using ReverseWeight = GallicWeight<Label, W, GALLIC>;
+
+ using UW::Properties;
+
+ GallicWeight() {}
+
+ // Copy constructor.
+ GallicWeight(const UW &weight) : UW(weight) {} // NOLINT
+
+ // Singleton constructors: create a GALLIC weight containing a single
+ // GALLIC_RESTRICT weight. Takes as argument (1) a GALLIC_RESTRICT weight or
+ // (2) the two components of a GALLIC_RESTRICT weight.
+ explicit GallicWeight(const GW &weight) : UW(weight) {}
+
+ GallicWeight(SW w1, W w2) : UW(GW(w1, w2)) {}
+
+ explicit GallicWeight(const string &str, int *nread = nullptr)
+ : UW(str, nread) {}
+
+ static const GallicWeight<Label, W, GALLIC> &Zero() {
+ static const GallicWeight<Label, W, GALLIC> zero(UW::Zero());
+ return zero;
+ }
+
+ static const GallicWeight<Label, W, GALLIC> &One() {
+ static const GallicWeight<Label, W, GALLIC> one(UW::One());
+ return one;
+ }
+
+ static const GallicWeight<Label, W, GALLIC> &NoWeight() {
+ static const GallicWeight<Label, W, GALLIC> no_weight(UW::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type = "gallic";
+ return type;
+ }
+
+ GallicWeight<Label, W, GALLIC> Quantize(float delta = kDelta) const {
+ return UW::Quantize(delta);
+ }
+
+ ReverseWeight Reverse() const { return UW::Reverse(); }
+};
+
+// (General) gallic plus.
+template <class Label, class W>
+inline GallicWeight<Label, W, GALLIC> Plus(
+ const GallicWeight<Label, W, GALLIC> &w1,
+ const GallicWeight<Label, W, GALLIC> &w2) {
+ using GW = GallicWeight<Label, W, GALLIC_RESTRICT>;
+ using UW = UnionWeight<GW, GallicUnionWeightOptions<Label, W>>;
+ return Plus(static_cast<UW>(w1), static_cast<UW>(w2));
+}
+
+// (General) gallic times.
+template <class Label, class W>
+inline GallicWeight<Label, W, GALLIC> Times(
+ const GallicWeight<Label, W, GALLIC> &w1,
+ const GallicWeight<Label, W, GALLIC> &w2) {
+ using GW = GallicWeight<Label, W, GALLIC_RESTRICT>;
+ using UW = UnionWeight<GW, GallicUnionWeightOptions<Label, W>>;
+ return Times(static_cast<UW>(w1), static_cast<UW>(w2));
+}
+
+// (General) gallic divide.
+template <class Label, class W>
+inline GallicWeight<Label, W, GALLIC> Divide(
+ const GallicWeight<Label, W, GALLIC> &w1,
+ const GallicWeight<Label, W, GALLIC> &w2,
+ DivideType divide_type = DIVIDE_ANY) {
+ using GW = GallicWeight<Label, W, GALLIC_RESTRICT>;
+ using UW = UnionWeight<GW, GallicUnionWeightOptions<Label, W>>;
+ return Divide(static_cast<UW>(w1), static_cast<UW>(w2), divide_type);
+}
+
+// This function object generates gallic weights by calling an underlying
+// union weight generator. This is intended primarily for testing.
+template <class Label, class W>
+class WeightGenerate<GallicWeight<Label, W, GALLIC>>
+ : public WeightGenerate<UnionWeight<GallicWeight<Label, W, GALLIC_RESTRICT>,
+ GallicUnionWeightOptions<Label, W>>> {
+ public:
+ using Weight = GallicWeight<Label, W, GALLIC>;
+ using Generate =
+ WeightGenerate<UnionWeight<GallicWeight<Label, W, GALLIC_RESTRICT>,
+ GallicUnionWeightOptions<Label, W>>>;
+
+ explicit WeightGenerate(bool allow_zero = true) : generate_(allow_zero) {}
+
+ Weight operator()() const { return Weight(generate_()); }
+
+ private:
+ const Generate generate_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_STRING_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Utilities to convert strings into FSTs.
+
+#ifndef FST_LIB_STRING_H_
+#define FST_LIB_STRING_H_
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <fst/compact-fst.h>
+#include <fst/icu.h>
+#include <fst/mutable-fst.h>
+#include <fst/util.h>
+
+
+DECLARE_string(fst_field_separator);
+
+namespace fst {
+
+// This will eventually replace StringCompiler<Arc>::TokenType and
+// StringPrinter<Arc>::TokenType.
+enum StringTokenType { SYMBOL = 1, BYTE = 2, UTF8 = 3 };
+
+namespace internal {
+
+template <class Label>
+bool ConvertSymbolToLabel(const char *str, const SymbolTable *syms,
+ Label unknown_label, bool allow_negative,
+ Label *output) {
+ int64 n;
+ if (syms) {
+ n = syms->Find(str);
+ if ((n == -1) && (unknown_label != kNoLabel)) n = unknown_label;
+ if (n == -1 || (!allow_negative && n < 0)) {
+ VLOG(1) << "ConvertSymbolToLabel: Symbol \"" << str
+ << "\" is not mapped to any integer label, symbol table = "
+ << syms->Name();
+ return false;
+ }
+ } else {
+ char *p;
+ n = strtoll(str, &p, 10);
+ if (p < str + strlen(str) || (!allow_negative && n < 0)) {
+ VLOG(1) << "ConvertSymbolToLabel: Bad label integer "
+ << "= \"" << str << "\"";
+ return false;
+ }
+ }
+ *output = n;
+ return true;
+}
+
+template <class Label>
+bool ConvertStringToLabels(const string &str, StringTokenType token_type,
+ const SymbolTable *syms, Label unknown_label,
+ bool allow_negative, std::vector<Label> *labels) {
+ labels->clear();
+ if (token_type == StringTokenType::BYTE) {
+ for (const char c : str) labels->push_back(c);
+ } else if (token_type == StringTokenType::UTF8) {
+ return UTF8StringToLabels(str, labels);
+ } else {
+ auto *c_str = new char[str.size() + 1];
+ str.copy(c_str, str.size());
+ c_str[str.size()] = 0;
+ std::vector<char *> vec;
+ const string separator = "\n" + FLAGS_fst_field_separator;
+ SplitToVector(c_str, separator.c_str(), &vec, true);
+ for (const char *c : vec) {
+ Label label;
+ if (!ConvertSymbolToLabel(c, syms, unknown_label, allow_negative,
+ &label)) {
+ delete[] c_str;
+ return false;
+ }
+ labels->push_back(label);
+ }
+ delete[] c_str;
+ }
+ return true;
+}
+
+} // namespace internal
+
+// Functor for compiling a string in an FST.
+template <class Arc>
+class StringCompiler {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ explicit StringCompiler(StringTokenType token_type,
+ const SymbolTable *syms = nullptr,
+ Label unknown_label = kNoLabel,
+ bool allow_negative = false)
+ : token_type_(token_type),
+ syms_(syms),
+ unknown_label_(unknown_label),
+ allow_negative_(allow_negative) {}
+
+ enum OPENFST_DEPRECATED("Use fst::StringTokenType") TokenType {
+ SYMBOL = 1,
+ BYTE = 2,
+ UTF8 = 3
+ };
+
+ OPENFST_DEPRECATED("Use fst::StringTokenType")
+ explicit StringCompiler(TokenType token_type,
+ const SymbolTable *syms = nullptr,
+ Label unknown_label = kNoLabel,
+ bool allow_negative = false)
+ : StringCompiler(static_cast<StringTokenType>(token_type), syms,
+ unknown_label, allow_negative) {}
+
+ // Compiles string into an FST.
+
+ template <class FST>
+ bool operator()(const string &str, FST *fst) const {
+ std::vector<Label> labels;
+ if (!internal::ConvertStringToLabels(str, token_type_, syms_,
+ unknown_label_, allow_negative_,
+ &labels)) {
+ return false;
+ }
+ Compile(labels, fst);
+ return true;
+ }
+
+ template <class FST>
+ bool operator()(const string &str, FST *fst, Weight weight) const {
+ std::vector<Label> labels;
+ if (!internal::ConvertStringToLabels(str, token_type_, syms_,
+ unknown_label_, allow_negative_,
+ &labels)) {
+ return false;
+ }
+ Compile(labels, fst, std::move(weight));
+ return true;
+ }
+
+ private:
+ void Compile(const std::vector<Label> &labels, MutableFst<Arc> *fst,
+ Weight weight = Weight::One()) const {
+ fst->DeleteStates();
+ while (fst->NumStates() <= labels.size()) fst->AddState();
+ for (StateId i = 0; i < labels.size(); ++i) {
+ fst->AddArc(i, Arc(labels[i], labels[i], Weight::One(), i + 1));
+ }
+ fst->SetStart(0);
+ fst->SetFinal(labels.size(), std::move(weight));
+ }
+
+ template <class Unsigned>
+ void Compile(const std::vector<Label> &labels,
+ CompactStringFst<Arc, Unsigned> *fst) const {
+ fst->SetCompactElements(labels.begin(), labels.end());
+ }
+
+ template <class Unsigned>
+ void Compile(const std::vector<Label> &labels,
+ CompactWeightedStringFst<Arc, Unsigned> *fst,
+ const Weight &weight = Weight::One()) const {
+ std::vector<std::pair<Label, Weight>> compacts;
+ compacts.reserve(labels.size() + 1);
+ for (StateId i = 0; i < static_cast<StateId>(labels.size()) - 1; ++i) {
+ compacts.emplace_back(labels[i], Weight::One());
+ }
+ compacts.emplace_back(!labels.empty() ? labels.back() : kNoLabel, weight);
+ fst->SetCompactElements(compacts.begin(), compacts.end());
+ }
+
+ const StringTokenType token_type_;
+ const SymbolTable *syms_; // Symbol table (used when token type is symbol).
+ const Label unknown_label_; // Label for token missing from symbol table.
+ const bool allow_negative_; // Negative labels allowed?
+
+ StringCompiler(const StringCompiler &) = delete;
+ StringCompiler &operator=(const StringCompiler &) = delete;
+};
+
+// Functor for printing a string FST as a string.
+template <class Arc>
+class StringPrinter {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ explicit StringPrinter(StringTokenType token_type,
+ const SymbolTable *syms = nullptr)
+ : token_type_(token_type), syms_(syms) {}
+
+ enum OPENFST_DEPRECATED("Use fst::StringTokenType") TokenType {
+ SYMBOL = 1,
+ BYTE = 2,
+ UTF8 = 3
+ };
+
+ OPENFST_DEPRECATED("Use fst::StringTokenType")
+ explicit StringPrinter(TokenType token_type,
+ const SymbolTable *syms = nullptr)
+ : StringPrinter(static_cast<StringTokenType>(token_type), syms) {}
+
+ // Converts the FST into a string.
+ bool operator()(const Fst<Arc> &fst, string *result) {
+ if (!FstToLabels(fst)) {
+ VLOG(1) << "StringPrinter::operator(): FST is not a string";
+ return false;
+ }
+ result->clear();
+ if (token_type_ == StringTokenType::SYMBOL) {
+ std::stringstream sstrm;
+ for (auto i = 0; i < labels_.size(); ++i) {
+ if (i) sstrm << *(FLAGS_fst_field_separator.rbegin());
+ if (!PrintLabel(labels_[i], sstrm)) return false;
+ }
+ *result = sstrm.str();
+ } else if (token_type_ == StringTokenType::BYTE) {
+ result->reserve(labels_.size());
+ for (auto i = 0; i < labels_.size(); ++i) result->push_back(labels_[i]);
+ } else if (token_type_ == StringTokenType::UTF8) {
+ return LabelsToUTF8String(labels_, result);
+ } else {
+ VLOG(1) << "StringPrinter::operator(): Unknown token type: "
+ << token_type_;
+ return false;
+ }
+ return true;
+ }
+
+ private:
+ bool FstToLabels(const Fst<Arc> &fst) {
+ labels_.clear();
+ auto s = fst.Start();
+ if (s == kNoStateId) {
+ VLOG(2) << "StringPrinter::FstToLabels: Invalid starting state for "
+ << "string FST";
+ return false;
+ }
+ while (fst.Final(s) == Weight::Zero()) {
+ ArcIterator<Fst<Arc>> aiter(fst, s);
+ if (aiter.Done()) {
+ VLOG(2) << "StringPrinter::FstToLabels: String FST traversal does "
+ << "not reach final state";
+ return false;
+ }
+ const auto &arc = aiter.Value();
+ labels_.push_back(arc.olabel);
+ s = arc.nextstate;
+ if (s == kNoStateId) {
+ VLOG(2) << "StringPrinter::FstToLabels: Transition to invalid state";
+ return false;
+ }
+ aiter.Next();
+ if (!aiter.Done()) {
+ VLOG(2) << "StringPrinter::FstToLabels: State with multiple "
+ << "outgoing arcs found";
+ return false;
+ }
+ }
+ return true;
+ }
+
+ bool PrintLabel(Label label, std::ostream &ostrm) {
+ if (syms_) {
+ const auto symbol = syms_->Find(label);
+ if (symbol == "") {
+ VLOG(2) << "StringPrinter::PrintLabel: Integer " << label << " is not "
+ << "mapped to any textual symbol, symbol table = "
+ << syms_->Name();
+ return false;
+ }
+ ostrm << symbol;
+ } else {
+ ostrm << label;
+ }
+ return true;
+ }
+
+ const StringTokenType token_type_;
+ const SymbolTable *syms_; // Symbol table (used when token type is symbol).
+ std::vector<Label> labels_; // Input FST labels.
+
+ StringPrinter(const StringPrinter &) = delete;
+ StringPrinter &operator=(const StringPrinter &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_STRING_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#ifndef FST_LIB_SYMBOL_TABLE_OPS_H_
+#define FST_LIB_SYMBOL_TABLE_OPS_H_
+
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+
+#include <fst/fst.h>
+#include <fst/symbol-table.h>
+
+
+namespace fst {
+
+// Returns a minimal symbol table containing only symbols referenced by the
+// passed fst. Symbols preserve their original numbering, so fst does not
+// require relabeling.
+template <class Arc>
+SymbolTable *PruneSymbolTable(const Fst<Arc> &fst, const SymbolTable &syms,
+ bool input) {
+ std::unordered_set<typename Arc::Label> seen;
+ seen.insert(0); // Always keep epsilon.
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ for (ArcIterator<Fst<Arc>> aiter(fst, siter.Value()); !aiter.Done();
+ aiter.Next()) {
+ const auto sym = (input) ? aiter.Value().ilabel : aiter.Value().olabel;
+ seen.insert(sym);
+ }
+ }
+ auto *pruned = new SymbolTable(syms.Name() + "_pruned");
+ for (SymbolTableIterator stiter(syms); !stiter.Done(); stiter.Next()) {
+ const auto label = stiter.Value();
+ if (seen.count(label)) pruned->AddSymbol(stiter.Symbol(), label);
+ }
+ return pruned;
+}
+
+// Relabels a symbol table to make it a contiguous mapping.
+SymbolTable *CompactSymbolTable(const SymbolTable &syms);
+
+// Merges two SymbolTables, all symbols from left will be merged into right
+// with the same ids. Symbols in right that have conflicting ids with those
+// in left will be assigned to value assigned from the left SymbolTable.
+// The returned symbol table will never modify symbol assignments from the left
+// side, but may do so on the right. If right_relabel_output is non-NULL, it
+// will be assigned true if the symbols from the right table needed to be
+// reassigned.
+// A potential use case is to Compose two Fst's that have different symbol
+// tables. You can reconcile them in the following way:
+// Fst<Arc> a, b;
+// bool relabel;
+// std::unique_ptr<SymbolTable> bnew(MergeSymbolTable(a.OutputSymbols(),
+// b.InputSymbols(), &relabel);
+// if (relabel) {
+// Relabel(b, bnew.get(), nullptr);
+// }
+// b.SetInputSymbols(bnew);
+SymbolTable *MergeSymbolTable(const SymbolTable &left, const SymbolTable &right,
+ bool *right_relabel_output = nullptr);
+
+// Read the symbol table from any Fst::Read()able file, without loading the
+// corresponding Fst. Returns nullptr if the Fst does not contain a symbol
+// table or the symbol table cannot be read.
+SymbolTable *FstReadSymbols(const string &filename, bool input);
+
+// Adds a contiguous range of symbols to a symbol table using a simple prefix
+// for the string, returning false if the inserted symbol string clashes with
+// any currently present.
+bool AddAuxiliarySymbols(const string &prefix, int64 start_label,
+ int64 nlabels, SymbolTable *syms);
+
+} // namespace fst
+#endif // FST_LIB_SYMBOL_TABLE_OPS_H_
--- /dev/null
+// 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.
+
+#ifndef FST_LIB_SYMBOL_TABLE_H_
+#define FST_LIB_SYMBOL_TABLE_H_
+
+#include <cstring>
+#include <ios>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fstream>
+#include <map>
+
+DECLARE_bool(fst_compat_symbols);
+
+namespace fst {
+
+// WARNING: Reading via symbol table read options should
+// not be used. This is a temporary work around for
+// reading symbol ranges of previously stored symbol sets.
+struct SymbolTableReadOptions {
+ SymbolTableReadOptions() {}
+
+ SymbolTableReadOptions(
+ std::vector<std::pair<int64, int64>> string_hash_ranges,
+ const string &source)
+ : string_hash_ranges(std::move(string_hash_ranges)), source(source) {}
+
+ std::vector<std::pair<int64, int64>> string_hash_ranges;
+ string source;
+};
+
+struct SymbolTableTextOptions {
+ explicit SymbolTableTextOptions(bool allow_negative_labels = false);
+
+ bool allow_negative_labels;
+ string fst_field_separator;
+};
+
+namespace internal {
+
+// List of symbols with a dense hash for looking up symbol index.
+// Hash uses linear probe, rehashes at 0.75% occupancy, avg 6 bytes overhead
+// per entry. Rehash in place from symbol list.
+//
+// Symbols are stored as c strings to avoid adding memory overhead, but the
+// performance penalty for this is high because rehash must call strlen on
+// every symbol. AddSymbol can be another 2x faster if symbol lengths were
+// stored.
+class DenseSymbolMap {
+ public:
+ DenseSymbolMap();
+
+ DenseSymbolMap(const DenseSymbolMap &x);
+
+ ~DenseSymbolMap();
+
+ std::pair<int64, bool> InsertOrFind(const string &key);
+
+ int64 Find(const string &key) const;
+
+ const size_t size() const { return symbols_.size(); }
+
+ const string GetSymbol(size_t idx) const {
+ return string(symbols_[idx], strlen(symbols_[idx]));
+ }
+
+ void RemoveSymbol(size_t idx);
+
+ private:
+ // num_buckets must be power of 2.
+ void Rehash(size_t num_buckets);
+
+ const char* NewSymbol(const string &sym);
+
+ int64 empty_;
+ std::vector<const char *> symbols_;
+ std::hash<string> str_hash_;
+ std::vector<int64> buckets_;
+ uint64 hash_mask_;
+};
+
+class SymbolTableImpl {
+ public:
+ explicit SymbolTableImpl(const string &name)
+ : name_(name),
+ available_key_(0),
+ dense_key_limit_(0),
+ check_sum_finalized_(false) {}
+
+ SymbolTableImpl(const SymbolTableImpl &impl)
+ : name_(impl.name_),
+ available_key_(impl.available_key_),
+ dense_key_limit_(impl.dense_key_limit_),
+ symbols_(impl.symbols_),
+ idx_key_(impl.idx_key_),
+ key_map_(impl.key_map_),
+ check_sum_finalized_(false) {}
+
+ int64 AddSymbol(const string &symbol, int64 key);
+
+ int64 AddSymbol(const string &symbol) {
+ return AddSymbol(symbol, available_key_);
+ }
+
+ // Removes the symbol with the given key. The removal is costly
+ // (O(NumSymbols)) and may reduce the efficiency of Find() because of a
+ // potentially reduced size of the dense key interval.
+ void RemoveSymbol(int64 key);
+
+ static SymbolTableImpl *ReadText(
+ std::istream &strm, const string &name,
+ const SymbolTableTextOptions &opts = SymbolTableTextOptions());
+
+ static SymbolTableImpl* Read(std::istream &strm,
+ const SymbolTableReadOptions &opts);
+
+ bool Write(std::ostream &strm) const;
+
+ // Return the string associated with the key. If the key is out of
+ // range (<0, >max), return an empty string.
+ string 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);
+ }
+
+ // Returns the key associated with the symbol. If the symbol
+ // does not exists, return SymbolTable::kNoSymbol.
+ int64 Find(const string &symbol) const {
+ int64 idx = symbols_.Find(symbol);
+ if (idx == -1 || idx < dense_key_limit_) return idx;
+ return idx_key_[idx - dense_key_limit_];
+ }
+
+ bool Member(int64 key) const { return !Find(key).empty(); }
+
+ bool Member(const string &symbol) const { return Find(symbol) != -1; }
+
+ int64 GetNthKey(ssize_t pos) const {
+ if (pos < 0 || pos >= symbols_.size()) return -1;
+ if (pos < dense_key_limit_) return pos;
+ return Find(symbols_.GetSymbol(pos));
+ }
+
+ const string &Name() const { return name_; }
+
+ void SetName(const string &new_name) { name_ = new_name; }
+
+ string CheckSum() const {
+ MaybeRecomputeCheckSum();
+ return check_sum_string_;
+ }
+
+ string LabeledCheckSum() const {
+ MaybeRecomputeCheckSum();
+ return labeled_check_sum_string_;
+ }
+
+ int64 AvailableKey() const { return available_key_; }
+
+ size_t NumSymbols() const { return symbols_.size(); }
+
+ private:
+ // Recomputes the checksums (both of them) if we've had changes since the last
+ // computation (i.e., if check_sum_finalized_ is false).
+ // Takes ~2.5 microseconds (dbg) or ~230 nanoseconds (opt) on a 2.67GHz Xeon
+ // if the checksum is up-to-date (requiring no recomputation).
+ void MaybeRecomputeCheckSum() const;
+
+ string name_;
+ int64 available_key_;
+ int64 dense_key_limit_;
+
+ DenseSymbolMap symbols_;
+ // Maps index to key for index >= dense_key_limit:
+ // key = idx_key_[index - dense_key_limit]
+ std::vector<int64> idx_key_;
+ // Maps key to index for key >= dense_key_limit_.
+ // index = key_map_[key]
+ map<int64, int64> key_map_;
+
+ mutable bool check_sum_finalized_;
+ mutable string check_sum_string_;
+ mutable string labeled_check_sum_string_;
+ mutable Mutex check_sum_mutex_;
+};
+
+} // namespace internal
+
+// Symbol (string) to integer (and reverse) mapping.
+//
+// The SymbolTable implements the mappings of labels to strings and reverse.
+// SymbolTables are used to describe the alphabet of the input and output
+// labels for arcs in a Finite State Transducer.
+//
+// SymbolTables are reference-counted and can therefore be shared across
+// multiple machines. For example a language model grammar G, with a
+// SymbolTable for the words in the language model can share this symbol
+// table with the lexical representation L o G.
+class SymbolTable {
+ public:
+ static constexpr int64 kNoSymbol = -1;
+
+ // Constructs symbol table with an unspecified name.
+ SymbolTable() :
+ impl_(std::make_shared<internal::SymbolTableImpl>("<unspecified>")) {}
+
+ // Constructs symbol table with a unique name.
+ explicit SymbolTable(const string &name)
+ : impl_(std::make_shared<internal::SymbolTableImpl>(name)) {}
+
+ virtual ~SymbolTable() {}
+
+ // Reads an text representation of the symbol table from an istream. Pass a
+ // name to give the resulting SymbolTable.
+ static SymbolTable* ReadText(std::istream &strm,
+ const string &name,
+ const SymbolTableTextOptions &opts = SymbolTableTextOptions()) {
+ auto *impl = internal::SymbolTableImpl::ReadText(strm, name, opts);
+ if (!impl) {
+ return nullptr;
+ } else {
+ return new SymbolTable(impl);
+ }
+ }
+
+ // Reads an text representation of the symbol table.
+ static SymbolTable *ReadText(const string &filename,
+ const SymbolTableTextOptions &opts = SymbolTableTextOptions()) {
+ std::ifstream strm(filename.c_str(), std::ios_base::in);
+ if (!strm.good()) {
+ LOG(ERROR) << "SymbolTable::ReadText: Can't open file " << filename;
+ return nullptr;
+ }
+ return ReadText(strm, filename, opts);
+ }
+
+ // WARNING: Reading via symbol table read options should not be used. This is
+ // a temporary work-around.
+ static SymbolTable* Read(std::istream &strm,
+ const SymbolTableReadOptions &opts) {
+ auto *impl = internal::SymbolTableImpl::Read(strm, opts);
+ return (impl) ? new SymbolTable(impl) : nullptr;
+ }
+
+ // Reads a binary dump of the symbol table from a stream.
+ static SymbolTable *Read(std::istream &strm,
+ const string &source) {
+ SymbolTableReadOptions opts;
+ opts.source = source;
+ return Read(strm, opts);
+ }
+
+ // Reads a binary dump of the symbol table.
+ static SymbolTable *Read(const string& filename) {
+ std::ifstream strm(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!strm.good()) {
+ LOG(ERROR) << "SymbolTable::Read: Can't open file " << filename;
+ return nullptr;
+ }
+ return Read(strm, filename);
+ }
+
+ //--------------------------------------------------------
+ // Derivable Interface (final)
+ //--------------------------------------------------------
+ // Creates a reference counted copy.
+ virtual SymbolTable *Copy() const { return new SymbolTable(*this); }
+
+ // Adds a symbol with given key to table. A symbol table also keeps track of
+ // the last available key (highest key value in the symbol table).
+ virtual int64 AddSymbol(const string &symbol, int64 key) {
+ MutateCheck();
+ return impl_->AddSymbol(symbol, key);
+ }
+
+ // Adds a symbol to the table. The associated value key is automatically
+ // assigned by the symbol table.
+ virtual int64 AddSymbol(const string &symbol) {
+ MutateCheck();
+ return impl_->AddSymbol(symbol);
+ }
+
+ // Adds another symbol table to this table. All key values will be offset
+ // by the current available key (highest key value in the symbol table).
+ // Note string symbols with the same key value with still have the same
+ // key value after the symbol table has been merged, but a different
+ // value. Adding symbol tables do not result in changes in the base table.
+ virtual void AddTable(const SymbolTable &table);
+
+ virtual void RemoveSymbol(int64 key) {
+ MutateCheck();
+ return impl_->RemoveSymbol(key);
+ }
+
+ // Returns the name of the symbol table.
+ virtual const string &Name() const { return impl_->Name(); }
+
+ // Sets the name of the symbol table.
+ virtual void SetName(const string &new_name) {
+ MutateCheck();
+ impl_->SetName(new_name);
+ }
+
+ // Return the label-agnostic MD5 check-sum for this table. All new symbols
+ // added to the table will result in an updated checksum. Deprecated.
+ virtual string CheckSum() const { return impl_->CheckSum(); }
+
+ // Same as CheckSum(), but returns an label-dependent version.
+ virtual string LabeledCheckSum() const { return impl_->LabeledCheckSum(); }
+
+ virtual bool Write(std::ostream &strm) const { return impl_->Write(strm); }
+
+ bool Write(const string &filename) const {
+ std::ofstream strm(filename.c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (!strm.good()) {
+ LOG(ERROR) << "SymbolTable::Write: Can't open file " << filename;
+ return false;
+ }
+ return Write(strm);
+ }
+
+ // Dump a text representation of the symbol table via a stream.
+ virtual bool WriteText(std::ostream &strm,
+ const SymbolTableTextOptions &opts = SymbolTableTextOptions()) const;
+
+ // Dump an text representation of the symbol table.
+ bool WriteText(const string &filename) const {
+ std::ofstream strm(filename);
+ if (!strm.good()) {
+ LOG(ERROR) << "SymbolTable::WriteText: Can't open file " << filename;
+ return false;
+ }
+ return WriteText(strm);
+ }
+
+ // Returns the string associated with the key. If the key is out of
+ // range (<0, >max), returns an empty string.
+ virtual string Find(int64 key) const { return impl_->Find(key); }
+
+ // Returns the key associated with the symbol. If the symbol does not exist,
+ // SymbolTable::kNoSymbol is returned.
+ virtual int64 Find(const string &symbol) const { return impl_->Find(symbol); }
+
+ // Returns the key associated with the symbol. If the symbol does not exist,
+ // SymbolTable::kNoSymbol is returned.
+ virtual int64 Find(const char *symbol) const { return impl_->Find(symbol); }
+
+ virtual bool Member(int64 key) const { return impl_->Member(key); }
+
+ virtual bool Member(const string &symbol) const {
+ return impl_->Member(symbol);
+ }
+
+ // Returns the current available key (i.e., highest key + 1) in the symbol
+ // table.
+ virtual int64 AvailableKey() const { return impl_->AvailableKey(); }
+
+ // Returns the current number of symbols in table (not necessarily equal to
+ // AvailableKey()).
+ virtual size_t NumSymbols() const { return impl_->NumSymbols(); }
+
+ virtual int64 GetNthKey(ssize_t pos) const { return impl_->GetNthKey(pos); }
+
+ private:
+ explicit SymbolTable(internal::SymbolTableImpl *impl) : impl_(impl) {}
+
+ void MutateCheck() {
+ if (!impl_.unique()) impl_.reset(new internal::SymbolTableImpl(*impl_));
+ }
+
+ const internal::SymbolTableImpl *Impl() const { return impl_.get(); }
+
+ private:
+ std::shared_ptr<internal::SymbolTableImpl> impl_;
+};
+
+// Iterator class for symbols in a symbol table.
+class SymbolTableIterator {
+ public:
+ explicit SymbolTableIterator(const SymbolTable &table)
+ : table_(table),
+ pos_(0),
+ nsymbols_(table.NumSymbols()),
+ key_(table.GetNthKey(0)) {}
+
+ ~SymbolTableIterator() {}
+
+ // Returns whether iterator is done.
+ bool Done() const { return (pos_ == nsymbols_); }
+
+ // Return the key of the current symbol.
+ int64 Value() const { return key_; }
+
+ // Return the string of the current symbol.
+ string Symbol() const { return table_.Find(key_); }
+
+ // Advances iterator.
+ void Next() {
+ ++pos_;
+ if (pos_ < nsymbols_) key_ = table_.GetNthKey(pos_);
+ }
+
+ // Resets iterator.
+ void Reset() {
+ pos_ = 0;
+ key_ = table_.GetNthKey(0);
+ }
+
+ private:
+ const SymbolTable &table_;
+ ssize_t pos_;
+ size_t nsymbols_;
+ int64 key_;
+};
+
+// Relabels a symbol table as specified by the input vector of pairs
+// (old label, new label). The new symbol table only retains symbols
+// for which a relabeling is explicitly specified.
+//
+// TODO(allauzen): consider adding options to allow for some form of implicit
+// identity relabeling.
+template <class Label>
+SymbolTable *RelabelSymbolTable(const SymbolTable *table,
+ const std::vector<std::pair<Label, Label>> &pairs) {
+ auto new_table = new SymbolTable(table->Name().empty() ?
+ string() : (string("relabeled_") + table->Name()));
+ for (const auto &pair : pairs) {
+ new_table->AddSymbol(table->Find(pair.first), pair.second);
+ }
+ return new_table;
+}
+
+// Returns true if the two symbol tables have equal checksums. Passing in
+// nullptr for either table always returns true.
+bool CompatSymbols(const SymbolTable *syms1, const SymbolTable *syms2,
+ bool warning = true);
+
+// Symbol Table serialization.
+
+void SymbolTableToString(const SymbolTable *table, string *result);
+
+SymbolTable *StringToSymbolTable(const string &str);
+
+} // namespace fst
+
+#endif // FST_LIB_SYMBOL_TABLE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Synchronize an FST with bounded delay.
+
+#ifndef FST_LIB_SYNCHRONIZE_H_
+#define FST_LIB_SYNCHRONIZE_H_
+
+#include <algorithm>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <fst/cache.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+using SynchronizeFstOptions = CacheOptions;
+
+namespace internal {
+
+// Implementation class for SynchronizeFst.
+// TODO(kbg,sorenj): Refactor to guarantee thread-safety.
+
+template <class Arc>
+class SynchronizeFstImpl : public CacheImpl<Arc> {
+ public:
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+
+ using CacheBaseImpl<CacheState<Arc>>::PushArc;
+ using CacheBaseImpl<CacheState<Arc>>::HasArcs;
+ using CacheBaseImpl<CacheState<Arc>>::HasFinal;
+ using CacheBaseImpl<CacheState<Arc>>::HasStart;
+ using CacheBaseImpl<CacheState<Arc>>::SetArcs;
+ using CacheBaseImpl<CacheState<Arc>>::SetFinal;
+ using CacheBaseImpl<CacheState<Arc>>::SetStart;
+
+ using String = basic_string<Label>;
+
+ struct Element {
+ Element() {}
+
+ Element(StateId state_, const String *i, const String *o)
+ : state(state_), istring(i), ostring(o) {}
+
+ StateId state; // Input state ID.
+ const String *istring; // Residual input labels.
+ const String *ostring; // Residual output labels.
+ // Residual strings are represented by const pointers to
+ // basic_string<Label> and are stored in a hash_set. The pointed
+ // memory is owned by the hash_set string_set_.
+ };
+
+ SynchronizeFstImpl(const Fst<Arc> &fst, const SynchronizeFstOptions &opts)
+ : CacheImpl<Arc>(opts), fst_(fst.Copy()) {
+ SetType("synchronize");
+ const auto props = fst.Properties(kFstProperties, false);
+ SetProperties(SynchronizeProperties(props), kCopyProperties);
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ }
+
+ SynchronizeFstImpl(const SynchronizeFstImpl &impl)
+ : CacheImpl<Arc>(impl), fst_(impl.fst_->Copy(true)) {
+ SetType("synchronize");
+ SetProperties(impl.Properties(), kCopyProperties);
+ SetInputSymbols(impl.InputSymbols());
+ SetOutputSymbols(impl.OutputSymbols());
+ }
+
+ ~SynchronizeFstImpl() override {
+ for (const auto *ptr : string_set_) delete ptr;
+ }
+
+ StateId Start() {
+ if (!HasStart()) {
+ auto start = fst_->Start();
+ if (start == kNoStateId) return kNoStateId;
+ const auto *empty = FindString(new String());
+ start = FindState(Element(fst_->Start(), empty, empty));
+ SetStart(start);
+ }
+ return CacheImpl<Arc>::Start();
+ }
+
+ Weight Final(StateId s) {
+ if (!HasFinal(s)) {
+ const auto &element = elements_[s];
+ const auto weight = element.state == kNoStateId
+ ? Weight::One()
+ : fst_->Final(element.state);
+ if ((weight != Weight::Zero()) && (element.istring)->empty() &&
+ (element.ostring)->empty()) {
+ SetFinal(s, weight);
+ } else {
+ SetFinal(s, Weight::Zero());
+ }
+ }
+ return CacheImpl<Arc>::Final(s);
+ }
+
+ size_t NumArcs(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumArcs(s);
+ }
+
+ size_t NumInputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumInputEpsilons(s);
+ }
+
+ size_t NumOutputEpsilons(StateId s) {
+ if (!HasArcs(s)) Expand(s);
+ return CacheImpl<Arc>::NumOutputEpsilons(s);
+ }
+
+ uint64 Properties() const override { return Properties(kFstProperties); }
+
+ // Sets error if found, returning other FST impl properties.
+ uint64 Properties(uint64 mask) const override {
+ if ((mask & kError) && fst_->Properties(kError, false)) {
+ SetProperties(kError, kError);
+ }
+ return FstImpl<Arc>::Properties(mask);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) {
+ if (!HasArcs(s)) Expand(s);
+ CacheImpl<Arc>::InitArcIterator(s, data);
+ }
+
+ // Returns the first character of the string obtained by concatenating the
+ // string and the label.
+ Label Car(const String *str, Label label = 0) const {
+ if (!str->empty()) {
+ return (*str)[0];
+ } else {
+ return label;
+ }
+ }
+
+ // Computes the residual string obtained by removing the first
+ // character in the concatenation of the string and the label.
+ const String *Cdr(const String *str, Label label = 0) {
+ auto *r = new String();
+ for (size_t i = 1; i < str->size(); ++i) r->push_back((*str)[i]);
+ if (label && !(str->empty())) r->push_back(label);
+ return FindString(r);
+ }
+
+ // Computes the concatenation of the string and the label.
+ const String *Concat(const String *str, Label label = 0) {
+ auto *r = new String();
+ for (size_t i = 0; i < str->size(); ++i) r->push_back((*str)[i]);
+ if (label) r->push_back(label);
+ return FindString(r);
+ }
+
+ // Tests if the concatenation of the string and label is empty.
+ bool Empty(const String *str, Label label = 0) const {
+ if (str->empty()) {
+ return label == 0;
+ } else {
+ return false;
+ }
+ }
+
+ // Finds the string pointed by s in the hash set. Transfers the pointer
+ // ownership to the hash set.
+ const String *FindString(const String *str) {
+ const auto insert_result = string_set_.insert(str);
+ if (!insert_result.second) {
+ delete str;
+ }
+ return *insert_result.first;
+ }
+
+ // Finds state corresponding to an element. Creates new state if element
+ // is not found.
+ StateId FindState(const Element &element) {
+ const auto insert_result =
+ element_map_.insert(std::make_pair(element, elements_.size()));
+ if (insert_result.second) {
+ elements_.push_back(element);
+ }
+ return insert_result.first->second;
+ }
+
+ // Computes the outgoing transitions from a state, creating new destination
+ // states as needed.
+ void Expand(StateId s) {
+ const auto element = elements_[s];
+ if (element.state != kNoStateId) {
+ for (ArcIterator<Fst<Arc>> aiter(*fst_, element.state); !aiter.Done();
+ aiter.Next()) {
+ const auto &arc = aiter.Value();
+ if (!Empty(element.istring, arc.ilabel) &&
+ !Empty(element.ostring, arc.olabel)) {
+ const auto *istring = Cdr(element.istring, arc.ilabel);
+ const auto *ostring = Cdr(element.ostring, arc.olabel);
+ PushArc(s, Arc(Car(element.istring, arc.ilabel),
+ Car(element.ostring, arc.olabel), arc.weight,
+ FindState(Element(arc.nextstate, istring, ostring))));
+ } else {
+ const auto *istring = Concat(element.istring, arc.ilabel);
+ const auto *ostring = Concat(element.ostring, arc.olabel);
+ PushArc(s, Arc(0, 0, arc.weight,
+ FindState(Element(arc.nextstate, istring, ostring))));
+ }
+ }
+ }
+ const auto weight = element.state == kNoStateId
+ ? Weight::One()
+ : fst_->Final(element.state);
+ if ((weight != Weight::Zero()) &&
+ ((element.istring)->size() + (element.ostring)->size() > 0)) {
+ const auto *istring = Cdr(element.istring);
+ const auto *ostring = Cdr(element.ostring);
+ PushArc(s, Arc(Car(element.istring), Car(element.ostring), weight,
+ FindState(Element(kNoStateId, istring, ostring))));
+ }
+ SetArcs(s);
+ }
+
+ private:
+ // Equality function for Elements; assumes strings have been hashed.
+ class ElementEqual {
+ public:
+ bool operator()(const Element &x, const Element &y) const {
+ return x.state == y.state && x.istring == y.istring &&
+ x.ostring == y.ostring;
+ }
+ };
+
+ // Hash function for Elements to FST states.
+ class ElementKey {
+ public:
+ size_t operator()(const Element &x) const {
+ size_t key = x.state;
+ key = (key << 1) ^ (x.istring)->size();
+ for (size_t i = 0; i < (x.istring)->size(); ++i) {
+ key = (key << 1) ^ (*x.istring)[i];
+ }
+ key = (key << 1) ^ (x.ostring)->size();
+ for (size_t i = 0; i < (x.ostring)->size(); ++i) {
+ key = (key << 1) ^ (*x.ostring)[i];
+ }
+ return key;
+ }
+ };
+
+ // Equality function for strings.
+ class StringEqual {
+ public:
+ bool operator()(const String *const &x, const String *const &y) const {
+ if (x->size() != y->size()) return false;
+ for (size_t i = 0; i < x->size(); ++i) {
+ if ((*x)[i] != (*y)[i]) return false;
+ }
+ return true;
+ }
+ };
+
+ // Hash function for set of strings
+ class StringKey {
+ public:
+ size_t operator()(const String *const &x) const {
+ size_t key = x->size();
+ for (size_t i = 0; i < x->size(); ++i) key = (key << 1) ^ (*x)[i];
+ return key;
+ }
+ };
+
+ using ElementMap =
+ std::unordered_map<Element, StateId, ElementKey, ElementEqual>;
+ using StringSet = std::unordered_set<const String *, StringKey, StringEqual>;
+
+ std::unique_ptr<const Fst<Arc>> fst_;
+ std::vector<Element> elements_; // Maps FST state to Elements.
+ ElementMap element_map_; // Maps Elements to FST state.
+ StringSet string_set_;
+};
+
+} // namespace internal
+
+// Synchronizes a transducer. This version is a delayed FST. The result is 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.
+//
+// This class attaches interface to implementation and handles reference
+// counting, delegating most methods to ImplToFst.
+template <class A>
+class SynchronizeFst : public ImplToFst<internal::SynchronizeFstImpl<A>> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ using Store = DefaultCacheStore<Arc>;
+ using State = typename Store::State;
+ using Impl = internal::SynchronizeFstImpl<A>;
+
+ friend class ArcIterator<SynchronizeFst<A>>;
+ friend class StateIterator<SynchronizeFst<A>>;
+
+ explicit SynchronizeFst(
+ const Fst<A> &fst,
+ const SynchronizeFstOptions &opts = SynchronizeFstOptions())
+ : ImplToFst<Impl>(std::make_shared<Impl>(fst, opts)) {}
+
+ // See Fst<>::Copy() for doc.
+ SynchronizeFst(const SynchronizeFst<Arc> &fst, bool safe = false)
+ : ImplToFst<Impl>(fst, safe) {}
+
+ // Gets a copy of this SynchronizeFst. See Fst<>::Copy() for further doc.
+ SynchronizeFst<Arc> *Copy(bool safe = false) const override {
+ return new SynchronizeFst<Arc>(*this, safe);
+ }
+
+ inline void InitStateIterator(StateIteratorData<Arc> *data) const override;
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetMutableImpl()->InitArcIterator(s, data);
+ }
+
+ private:
+ using ImplToFst<Impl>::GetImpl;
+ using ImplToFst<Impl>::GetMutableImpl;
+
+ SynchronizeFst &operator=(const SynchronizeFst &) = delete;
+};
+
+// Specialization for SynchronizeFst.
+template <class Arc>
+class StateIterator<SynchronizeFst<Arc>>
+ : public CacheStateIterator<SynchronizeFst<Arc>> {
+ public:
+ explicit StateIterator(const SynchronizeFst<Arc> &fst)
+ : CacheStateIterator<SynchronizeFst<Arc>>(fst, fst.GetMutableImpl()) {}
+};
+
+// Specialization for SynchronizeFst.
+template <class Arc>
+class ArcIterator<SynchronizeFst<Arc>>
+ : public CacheArcIterator<SynchronizeFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const SynchronizeFst<Arc> &fst, StateId s)
+ : CacheArcIterator<SynchronizeFst<Arc>>(fst.GetMutableImpl(), s) {
+ if (!fst.GetImpl()->HasArcs(s)) fst.GetMutableImpl()->Expand(s);
+ }
+};
+
+template <class Arc>
+inline void SynchronizeFst<Arc>::InitStateIterator(
+ StateIteratorData<Arc> *data) const {
+ data->base = new StateIterator<SynchronizeFst<Arc>>(*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 <class Arc>
+void Synchronize(const Fst<Arc> &ifst, MutableFst<Arc> *ofst) {
+ // Caches only the last state for fastest copy.
+ const SynchronizeFstOptions opts(FLAGS_fst_default_cache_gc, 0);
+ *ofst = SynchronizeFst<Arc>(ifst, opts);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_SYNCHRONIZE_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions to manipulate and test property bits.
+
+#ifndef FST_LIB_TEST_PROPERTIES_H_
+#define FST_LIB_TEST_PROPERTIES_H_
+
+#include <unordered_set>
+
+#include <fst/connect.h>
+#include <fst/dfs-visit.h>
+
+
+DECLARE_bool(fst_verify_properties);
+
+namespace fst {
+// namespace internal {
+
+// For a binary property, the bit is always returned set. For a trinary (i.e.,
+// two-bit) property, both bits are returned set iff either corresponding input
+// bit is set.
+inline uint64 KnownProperties(uint64 props) {
+ return kBinaryProperties | (props & kTrinaryProperties) |
+ ((props & kPosTrinaryProperties) << 1) |
+ ((props & kNegTrinaryProperties) >> 1);
+}
+
+// Tests compatibility between two sets of properties.
+inline bool CompatProperties(uint64 props1, uint64 props2) {
+ const auto known_props1 = KnownProperties(props1);
+ const auto known_props2 = KnownProperties(props2);
+ const auto known_props = known_props1 & known_props2;
+ const auto incompat_props = (props1 & known_props) ^ (props2 & known_props);
+ if (incompat_props) {
+ uint64 prop = 1;
+ for (auto i = 0; i < 64; ++i, prop <<= 1) {
+ if (prop & incompat_props) {
+ LOG(ERROR) << "CompatProperties: Mismatch: " << PropertyNames[i]
+ << ": props1 = " << (props1 & prop ? "true" : "false")
+ << ", props2 = " << (props2 & prop ? "true" : "false");
+ }
+ }
+ return false;
+ } else {
+ return true;
+ }
+}
+
+// Computes FST property values defined in properties.h. The value of each
+// property indicated in the mask will be determined and returned (these will
+// never be unknown here). In the course of determining the properties
+// specifically requested in the mask, certain other properties may be
+// determined (those with little additional expense) and their values will be
+// returned as well. The complete set of known properties (whether true or
+// false) determined by this operation will be assigned to the the value pointed
+// to by KNOWN. If 'use_stored' is true, pre-computed FST properties may be used
+// when possible. 'mask & required_mask' is used to determine whether the stored
+// propertoes can be used. This routine is seldom called directly; instead it is
+// used to implement fst.Properties(mask, true).
+template <class Arc>
+uint64 ComputeProperties(const Fst<Arc> &fst, uint64 mask, uint64 *known,
+ bool use_stored) {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ const auto fst_props = fst.Properties(kFstProperties, false); // FST-stored.
+ // Check stored FST properties first if allowed.
+ if (use_stored) {
+ const auto known_props = KnownProperties(fst_props);
+ // If FST contains required info, return it.
+ if ((known_props & mask) == mask) {
+ if (known) *known = known_props;
+ return fst_props;
+ }
+ }
+ // Computes (trinary) properties explicitly.
+ // Initialize with binary properties (already known).
+ uint64 comp_props = fst_props & kBinaryProperties;
+ // Computes these trinary properties with a DFS. We compute only those that
+ // need a DFS here, since we otherwise would like to avoid a DFS since its
+ // stack could grow large.
+ uint64 dfs_props = kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic |
+ kAccessible | kNotAccessible | kCoAccessible |
+ kNotCoAccessible;
+ std::vector<StateId> scc;
+ if (mask & (dfs_props | kWeightedCycles | kUnweightedCycles)) {
+ SccVisitor<Arc> scc_visitor(&scc, nullptr, nullptr, &comp_props);
+ DfsVisit(fst, &scc_visitor);
+ }
+ // Computes any remaining trinary properties via a state and arcs iterations
+ if (mask & ~(kBinaryProperties | dfs_props)) {
+ comp_props |= kAcceptor | kNoEpsilons | kNoIEpsilons | kNoOEpsilons |
+ kILabelSorted | kOLabelSorted | kUnweighted | kTopSorted |
+ kString;
+ if (mask & (kIDeterministic | kNonIDeterministic)) {
+ comp_props |= kIDeterministic;
+ }
+ if (mask & (kODeterministic | kNonODeterministic)) {
+ comp_props |= kODeterministic;
+ }
+ if (mask & (dfs_props | kWeightedCycles | kUnweightedCycles)) {
+ comp_props |= kUnweightedCycles;
+ }
+ std::unique_ptr<std::unordered_set<Label>> ilabels;
+ std::unique_ptr<std::unordered_set<Label>> olabels;
+ StateId nfinal = 0;
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ StateId s = siter.Value();
+ Arc prev_arc;
+ // Creates these only if we need to.
+ if (mask & (kIDeterministic | kNonIDeterministic)) {
+ ilabels.reset(new std::unordered_set<Label>());
+ }
+ if (mask & (kODeterministic | kNonODeterministic)) {
+ olabels.reset(new std::unordered_set<Label>());
+ }
+ bool first_arc = true;
+ for (ArcIterator<Fst<Arc>> 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;
+}
+
+// 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, true).
+template <class Arc>
+uint64 TestProperties(const Fst<Arc> &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, false);
+ if (!CompatProperties(stored_props, computed_props)) {
+ FSTERROR() << "TestProperties: stored FST properties incorrect"
+ << " (stored: props1, computed: props2)";
+ }
+ return computed_props;
+ } else {
+ return ComputeProperties(fst, mask, known, true);
+ }
+}
+
+// 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 <class Arc>
+uint64 CheckProperties(const Fst<Arc> &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, nullptr);
+ } else if ((KnownProperties(props) & check_mask) != check_mask) {
+ props = ComputeProperties(fst, check_mask | test_mask, nullptr, false);
+ }
+ return props & (check_mask | test_mask);
+}
+
+//} // namespace internal
+} // namespace fst
+
+#endif // FST_LIB_TEST_PROPERTIES_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Topological sort of FSTs.
+
+#ifndef FST_LIB_TOPSORT_H_
+#define FST_LIB_TOPSORT_H_
+
+#include <memory>
+#include <vector>
+
+
+#include <fst/dfs-visit.h>
+#include <fst/fst.h>
+#include <fst/statesort.h>
+
+
+namespace fst {
+
+// DFS visitor class to return topological ordering.
+template <class Arc>
+class TopOrderVisitor {
+ public:
+ using StateId = typename Arc::StateId;
+
+ // If acyclic, order[i] gives the topological position of StateId i;
+ // otherwise it is unchanged. acyclic_ will be true iff the FST has no
+ // cycles. The caller retains ownership of the state order vector.
+ TopOrderVisitor(std::vector<StateId> *order, bool *acyclic)
+ : order_(order), acyclic_(acyclic) {}
+
+ void InitVisit(const Fst<Arc> &fst) {
+ finish_.reset(new std::vector<StateId>());
+ *acyclic_ = true;
+ }
+
+ constexpr bool InitState(StateId, StateId) const { return true; }
+
+ constexpr bool TreeArc(StateId, const Arc &) const { return true; }
+
+ bool BackArc(StateId, const Arc &) { return (*acyclic_ = false); }
+
+ constexpr bool ForwardOrCrossArc(StateId, const Arc &) const { return true; }
+
+ void FinishState(StateId s, StateId, const Arc *) { finish_->push_back(s); }
+
+ void FinishVisit() {
+ if (*acyclic_) {
+ order_->clear();
+ for (StateId s = 0; s < finish_->size(); ++s) {
+ order_->push_back(kNoStateId);
+ }
+ for (StateId s = 0; s < finish_->size(); ++s) {
+ (*order_)[(*finish_)[finish_->size() - s - 1]] = s;
+ }
+ }
+ finish_.reset();
+ }
+
+ private:
+ std::vector<StateId> *order_;
+ bool *acyclic_;
+ // States in finish-time order.
+ std::unique_ptr<std::vector<StateId>> finish_;
+};
+
+// Topologically sorts its input if acyclic, modifying it. Otherwise, the input
+// is unchanged. When sorted, all transitions are from lower to higher state
+// IDs.
+//
+// Complexity:
+//
+// Time: O(V + E)
+// Space: O(V + E)
+//
+// where V is the number of states and E is the number of arcs.
+template <class Arc>
+bool TopSort(MutableFst<Arc> *fst) {
+ std::vector<typename Arc::StateId> order;
+ bool acyclic;
+ TopOrderVisitor<Arc> top_order_visitor(&order, &acyclic);
+ DfsVisit(*fst, &top_order_visitor);
+ if (acyclic) {
+ StateSort(fst, order);
+ fst->SetProperties(kAcyclic | kInitialAcyclic | kTopSorted,
+ kAcyclic | kInitialAcyclic | kTopSorted);
+ } else {
+ fst->SetProperties(kCyclic | kNotTopSorted, kCyclic | kNotTopSorted);
+ }
+ return acyclic;
+}
+
+} // namespace fst
+
+#endif // FST_LIB_TOPSORT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Tuple weight set operation definitions.
+
+#ifndef FST_LIB_TUPLE_WEIGHT_H_
+#define FST_LIB_TUPLE_WEIGHT_H_
+
+#include <algorithm>
+#include <array>
+#include <string>
+#include <vector>
+
+#include <fst/weight.h>
+
+
+namespace fst {
+
+// n-tuple weight, element of the n-th catersian power of W.
+template <class W, size_t n>
+class TupleWeight {
+ public:
+ using ReverseWeight = TupleWeight<typename W::ReverseWeight, n>;
+
+ TupleWeight() {}
+
+ TupleWeight(const TupleWeight &other) { values_ = other.values_; }
+
+ TupleWeight<W, n> &operator=(const TupleWeight<W, n> &other) {
+ values_ = other.values_;
+ return *this;
+ }
+
+ template <class Iterator>
+ TupleWeight(Iterator begin, Iterator end) {
+ for (auto it = begin; it != end; ++it) {
+ values_[it - begin] = *it;
+ }
+ }
+
+ explicit TupleWeight(const W &weight) { values_.fill(weight); }
+
+ static const TupleWeight<W, n> &Zero() {
+ static const TupleWeight<W, n> zero(W::Zero());
+ return zero;
+ }
+
+ static const TupleWeight<W, n> &One() {
+ static const TupleWeight<W, n> one(W::One());
+ return one;
+ }
+
+ static const TupleWeight<W, n> &NoWeight() {
+ static const TupleWeight<W, n> no_weight(W::NoWeight());
+ return no_weight;
+ }
+
+ constexpr static size_t Length() { return n; }
+
+ std::istream &Read(std::istream &istrm) {
+ for (auto i = 0; i < n; ++i) values_[i].Read(istrm);
+ return istrm;
+ }
+
+ std::ostream &Write(std::ostream &ostrm) const {
+ for (auto i = 0; i < n; ++i) values_[i].Write(ostrm);
+ return ostrm;
+ }
+
+ bool Member() const {
+ auto member_test = [](const W &weight) { return weight.Member(); };
+ return std::all_of(values_.begin(), values_.end(), member_test);
+ }
+
+ size_t Hash() const {
+ uint64 hash = 0;
+ for (auto i = 0; i < n; ++i) hash = 5 * hash + values_[i].Hash();
+ return size_t(hash);
+ }
+
+ TupleWeight<W, n> Quantize(float delta = kDelta) const {
+ TupleWeight<W, n> weight;
+ for (auto i = 0; i < n; ++i) weight.values_[i] = values_[i].Quantize(delta);
+ return weight;
+ }
+
+ ReverseWeight Reverse() const {
+ TupleWeight<W, n> w;
+ for (auto i = 0; i < n; ++i) w.values_[i] = values_[i].Reverse();
+ return w;
+ }
+
+ const W &Value(size_t i) const { return values_[i]; }
+
+ void SetValue(size_t i, const W &w) { values_[i] = w; }
+
+ private:
+ std::array<W, n> values_;
+};
+
+template <class W, size_t n>
+inline bool operator==(const TupleWeight<W, n> &w1,
+ const TupleWeight<W, n> &w2) {
+ for (auto i = 0; i < n; ++i) {
+ if (w1.Value(i) != w2.Value(i)) return false;
+ }
+ return true;
+}
+
+template <class W, size_t n>
+inline bool operator!=(const TupleWeight<W, n> &w1,
+ const TupleWeight<W, n> &w2) {
+ for (auto i = 0; i < n; ++i) {
+ if (w1.Value(i) != w2.Value(i)) return true;
+ }
+ return false;
+}
+
+template <class W, size_t n>
+inline bool ApproxEqual(const TupleWeight<W, n> &w1,
+ const TupleWeight<W, n> &w2, float delta = kDelta) {
+ for (auto i = 0; i < n; ++i) {
+ if (!ApproxEqual(w1.Value(i), w2.Value(i), delta)) return false;
+ }
+ return true;
+}
+
+template <class W, size_t n>
+inline std::ostream &operator<<(std::ostream &strm,
+ const TupleWeight<W, n> &w) {
+ CompositeWeightWriter writer(strm);
+ writer.WriteBegin();
+ for (auto i = 0; i < n; ++i) writer.WriteElement(w.Value(i));
+ writer.WriteEnd();
+ return strm;
+}
+
+template <class W, size_t n>
+inline std::istream &operator>>(std::istream &strm, TupleWeight<W, n> &w) {
+ CompositeWeightReader reader(strm);
+ reader.ReadBegin();
+ W v;
+ // Reads first n-1 elements.
+ for (auto i = 0; i < n - 1; ++i) {
+ reader.ReadElement(&v);
+ w.SetValue(i, v);
+ }
+ // Reads n-th element.
+ reader.ReadElement(&v, true);
+ w.SetValue(n - 1, v);
+ reader.ReadEnd();
+ return strm;
+}
+
+} // namespace fst
+
+#endif // FST_LIB_TUPLE_WEIGHT_H_
--- /dev/null
+// 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.
+//
+// Various type definitions (mostly for Google compatibility).
+
+#include <cstdlib> // for ssize_t.
+#include <cstdint> // for ?int*_t.
+
+#ifndef FST_LIB_TYPES_H_
+#define FST_LIB_TYPES_H_
+
+using int8 = int8_t;
+using int16 = int16_t;
+using int32 = int32_t;
+using int64 = int64_t;
+
+using uint8 = uint8_t;
+using uint16 = uint16_t;
+using uint32 = uint32_t;
+using uint64 = uint64_t;
+
+#endif // FST_LIB_TYPES_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Union-find algorithm for dense sets of non-negative integers, implemented
+// using disjoint tree forests with rank heuristics and path compression.
+
+#ifndef FST_LIB_UNION_FIND_H_
+#define FST_LIB_UNION_FIND_H_
+
+#include <stack>
+#include <vector>
+
+namespace fst {
+
+// Union-Find algorithm for dense sets of non-negative integers.
+template <class T>
+class UnionFind {
+ public:
+ // Creates a disjoint set forest for the range [0; max); 'fail' is a value
+ // indicating that an element hasn't been initialized using MakeSet(...).
+ // The upper bound of the range can be reset (increased) using MakeSet(...).
+ UnionFind(T max, T fail) : parent_(max, fail), rank_(max), fail_(fail) {}
+
+ // Finds the representative of the set 'item' belongs to, performing path
+ // compression if necessary.
+ T FindSet(T item) {
+ if (item >= parent_.size() || item == fail_ || parent_[item] == fail_) {
+ return fail_;
+ }
+ auto *p = &parent_[item];
+ for (; *p != item; item = *p, p = &parent_[item]) exec_stack_.push(p);
+ for (; !exec_stack_.empty(); exec_stack_.pop()) *exec_stack_.top() = *p;
+ return *p;
+ }
+
+ // Creates the (destructive) union of the sets x and y belong to.
+ void Union(T x, T y) { Link(FindSet(x), FindSet(y)); }
+
+ // Initialization of an element: creates a singleton set containing 'item'.
+ // The range [0; max) is reset if item >= max.
+ T MakeSet(T item) {
+ if (item >= parent_.size()) {
+ // New value in parent_ should be initialized to fail_.
+ const auto nitem = item > 0 ? 2 * item : 2;
+ parent_.resize(nitem, fail_);
+ rank_.resize(nitem);
+ }
+ parent_[item] = item;
+ return item;
+ }
+
+ // Initialization of all elements starting from 0 to max - 1 to distinct sets.
+ void MakeAllSet(T max) {
+ parent_.resize(max);
+ for (T item = 0; item < max; ++item) parent_[item] = item;
+ }
+
+ private:
+ // Links trees rooted in 'x' and 'y'.
+ void Link(T x, T y) {
+ if (x == y) return;
+ if (rank_[x] > rank_[y]) {
+ parent_[y] = x;
+ } else {
+ parent_[x] = y;
+ if (rank_[x] == rank_[y]) {
+ ++rank_[y];
+ }
+ }
+ }
+
+ UnionFind(const UnionFind &) = delete;
+
+ UnionFind &operator=(const UnionFind &) = delete;
+
+ std::vector<T> parent_; // Parent nodes.
+ std::vector<int> rank_; // Rank of an element = min. depth in tree.
+ T fail_; // Value indicating lookup failure.
+ std::stack<T *> exec_stack_; // Used for path compression.
+};
+
+} // namespace fst
+
+#endif // FST_LIB_UNION_FIND_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Union weight set and associated semiring operation definitions.
+//
+// TODO(riley): add in normalizer functor
+
+#ifndef FST_LIB_UNION_WEIGHT_H_
+#define FST_LIB_UNION_WEIGHT_H_
+
+#include <cstdlib>
+
+#include <iostream>
+#include <list>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include <fst/weight.h>
+
+
+namespace fst {
+
+// Example UnionWeightOptions for UnionWeight template below. The Merge
+// operation is used to collapse elements of the set and the Compare function
+// to efficiently implement the merge. In the simplest case, merge would just
+// apply with equality of set elements so the result is a set (and not a
+// multiset). More generally, this can be used to maintain the multiplicity or
+// other such weight associated with the set elements (cf. Gallic weights).
+
+// template <class W>
+// struct UnionWeightOptions {
+// // Comparison function C is a total order on W that is monotonic w.r.t. to
+// // Times: for all a, b,c != Zero(): C(a, b) => C(ca, cb) and is
+// // anti-monotonic w.r.rt to Divide: C(a, b) => C(c/b, c/a).
+// //
+// // For all a, b: only one of C(a, b), C(b, a) or a ~ b must true where
+// // ~ is an equivalence relation on W. Also we require a ~ b iff
+// // a.Reverse() ~ b.Reverse().
+// using Compare = NaturalLess<W>;
+//
+// // How to combine two weights if a ~ b as above. For all a, b: a ~ b =>
+// // merge(a, b) ~ a, Merge must define a semiring endomorphism from the
+// // unmerged weight sets to the merged weight sets.
+// struct Merge {
+// W operator()(const W &w1, const W &w2) const { return w1; }
+// };
+//
+// // For ReverseWeight.
+// using ReverseOptions = UnionWeightOptions<ReverseWeight>;
+// };
+
+template <class W, class O>
+class UnionWeight;
+
+template <class W, class O>
+class UnionWeightIterator;
+
+template <class W, class O>
+class UnionWeightReverseIterator;
+
+template <class W, class O>
+bool operator==(const UnionWeight<W, O> &, const UnionWeight<W, O> &);
+
+// Semiring that uses Times() and One() from W and union and the empty set
+// for Plus() and Zero(), respectively. Template argument O specifies the union
+// weight options as above.
+template <class W, class O>
+class UnionWeight {
+ public:
+ using Weight = W;
+ using Compare = typename O::Compare;
+ using Merge = typename O::Merge;
+
+ using ReverseWeight =
+ UnionWeight<typename W::ReverseWeight, typename O::ReverseOptions>;
+
+ friend class UnionWeightIterator<W, O>;
+ friend class UnionWeightReverseIterator<W, O>;
+ friend bool operator==
+ <>(const UnionWeight<W, O> &, const UnionWeight<W, O> &);
+
+ // Sets represented as first_ weight + rest_ weights. Uses first_ as
+ // NoWeight() to indicate the union weight Zero() ask the empty set. Uses
+ // rest_ containing NoWeight() to indicate the union weight NoWeight().
+ UnionWeight() : first_(W::NoWeight()) {}
+
+ explicit UnionWeight(W weight) : first_(weight) {
+ if (weight == W::NoWeight()) rest_.push_back(weight);
+ }
+
+ static const UnionWeight<W, O> &Zero() {
+ static const UnionWeight<W, O> zero(W::NoWeight());
+ return zero;
+ }
+
+ static const UnionWeight<W, O> &One() {
+ static const UnionWeight<W, O> one(W::One());
+ return one;
+ }
+
+ static const UnionWeight<W, O> &NoWeight() {
+ static const UnionWeight<W, O> no_weight(W::Zero(), W::NoWeight());
+ return no_weight;
+ }
+
+ static const string &Type() {
+ static const string type = W::Type() + "_union";
+ return type;
+ }
+
+ static constexpr uint64 Properties() {
+ return W::Properties() &
+ (kLeftSemiring | kRightSemiring | kCommutative | kIdempotent);
+ }
+
+ bool Member() const;
+
+ std::istream &Read(std::istream &strm);
+
+ std::ostream &Write(std::ostream &strm) const;
+
+ size_t Hash() const;
+
+ UnionWeight<W, O> Quantize(float delta = kDelta) const;
+
+ ReverseWeight Reverse() const;
+
+ // These operations combined with the UnionWeightIterator and
+ // UnionWeightReverseIterator provide the access and mutation of the union
+ // weight internal elements.
+
+ // Common initializer among constructors; clears existing UnionWeight.
+ void Clear() {
+ first_ = W::NoWeight();
+ rest_.clear();
+ }
+
+ size_t Size() const { return first_.Member() ? rest_.size() + 1 : 0; }
+
+ const W &Back() const { return rest_.empty() ? first_ : rest_.back(); }
+
+ // When srt is true, assumes elements added sorted w.r.t Compare and merging
+ // of weights performed as needed. Otherwise, just ensures first_ is the
+ // least element wrt Compare.
+ void PushBack(W weight, bool srt);
+
+ // Sorts the elements of the set. Assumes that first_, if present, is the
+ // least element.
+ void Sort() { rest_.sort(comp_); }
+
+ private:
+ W &Back() {
+ if (rest_.empty()) {
+ return first_;
+ } else {
+ return rest_.back();
+ }
+ }
+
+ UnionWeight(W w1, W w2) : first_(std::move(w1)), rest_(1, std::move(w2)) {}
+
+ W first_; // First weight in set.
+ std::list<W> rest_; // Remaining weights in set.
+ Compare comp_;
+ Merge merge_;
+};
+
+template <class W, class O>
+void UnionWeight<W, O>::PushBack(W weight, bool srt) {
+ if (!weight.Member()) {
+ rest_.push_back(std::move(weight));
+ } else if (!first_.Member()) {
+ first_ = std::move(weight);
+ } else if (srt) {
+ auto &back = Back();
+ if (comp_(back, weight)) {
+ rest_.push_back(std::move(weight));
+ } else {
+ back = merge_(back, std::move(weight));
+ }
+ } else {
+ if (comp_(first_, weight)) {
+ rest_.push_back(std::move(weight));
+ } else {
+ rest_.push_back(first_);
+ first_ = std::move(weight);
+ }
+ }
+}
+
+// Traverses union weight in the forward direction.
+template <class W, class O>
+class UnionWeightIterator {
+ public:
+ explicit UnionWeightIterator(const UnionWeight<W, O> &weight)
+ : first_(weight.first_),
+ rest_(weight.rest_),
+ init_(true),
+ it_(rest_.begin()) {}
+
+ bool Done() const { return init_ ? !first_.Member() : it_ == rest_.end(); }
+
+ const W &Value() const { return init_ ? first_ : *it_; }
+
+ void Next() {
+ if (init_) {
+ init_ = false;
+ } else {
+ ++it_;
+ }
+ }
+
+ void Reset() {
+ init_ = true;
+ it_ = rest_.begin();
+ }
+
+ private:
+ const W &first_;
+ const std::list<W> &rest_;
+ bool init_; // in the initialized state?
+ typename std::list<W>::const_iterator it_;
+};
+
+// Traverses union weight in backward direction.
+template <typename L, class O>
+class UnionWeightReverseIterator {
+ public:
+ explicit UnionWeightReverseIterator(const UnionWeight<L, O> &weight)
+ : first_(weight.first_),
+ rest_(weight.rest_),
+ fin_(!first_.Member()),
+ it_(rest_.rbegin()) {}
+
+ bool Done() const { return fin_; }
+
+ const L &Value() const { return it_ == rest_.rend() ? first_ : *it_; }
+
+ void Next() {
+ if (it_ == rest_.rend()) {
+ fin_ = true;
+ } else {
+ ++it_;
+ }
+ }
+
+ void Reset() {
+ fin_ = !first_.Member();
+ it_ = rest_.rbegin();
+ }
+
+ private:
+ const L &first_;
+ const std::list<L> &rest_;
+ bool fin_; // in the final state?
+ typename std::list<L>::const_reverse_iterator it_;
+};
+
+// UnionWeight member functions follow that require UnionWeightIterator.
+template <class W, class O>
+inline std::istream &UnionWeight<W, O>::Read(std::istream &istrm) {
+ Clear();
+ int32 size;
+ ReadType(istrm, &size);
+ for (int i = 0; i < size; ++i) {
+ W weight;
+ ReadType(istrm, &weight);
+ PushBack(weight, true);
+ }
+ return istrm;
+}
+
+template <class W, class O>
+inline std::ostream &UnionWeight<W, O>::Write(std::ostream &ostrm) const {
+ const int32 size = Size();
+ WriteType(ostrm, size);
+ for (UnionWeightIterator<W, O> it(*this); !it.Done(); it.Next()) {
+ WriteType(ostrm, it.Value());
+ }
+ return ostrm;
+}
+
+template <class W, class O>
+inline bool UnionWeight<W, O>::Member() const {
+ if (Size() <= 1) return true;
+ for (UnionWeightIterator<W, O> it(*this); !it.Done(); it.Next()) {
+ if (!it.Value().Member()) return false;
+ }
+ return true;
+}
+
+template <class W, class O>
+inline UnionWeight<W, O> UnionWeight<W, O>::Quantize(float delta) const {
+ UnionWeight<W, O> weight;
+ for (UnionWeightIterator<W, O> it(*this); !it.Done(); it.Next()) {
+ weight.PushBack(it.Value().Quantize(delta), true);
+ }
+ return weight;
+}
+
+template <class W, class O>
+inline typename UnionWeight<W, O>::ReverseWeight UnionWeight<W, O>::Reverse()
+ const {
+ ReverseWeight weight;
+ for (UnionWeightIterator<W, O> it(*this); !it.Done(); it.Next()) {
+ weight.PushBack(it.Value().Reverse(), false);
+ }
+ weight.Sort();
+ return weight;
+}
+
+template <class W, class O>
+inline size_t UnionWeight<W, O>::Hash() const {
+ size_t h = 0;
+ static constexpr int lshift = 5;
+ static constexpr int rshift = CHAR_BIT * sizeof(size_t) - lshift;
+ for (UnionWeightIterator<W, O> it(*this); !it.Done(); it.Next()) {
+ h = h << lshift ^ h >> rshift ^ it.Value().Hash();
+ }
+ return h;
+}
+
+// Requires union weight has been canonicalized.
+template <class W, class O>
+inline bool operator==(const UnionWeight<W, O> &w1,
+ const UnionWeight<W, O> &w2) {
+ if (w1.Size() != w2.Size()) return false;
+ UnionWeightIterator<W, O> it1(w1);
+ UnionWeightIterator<W, O> it2(w2);
+ for (; !it1.Done(); it1.Next(), it2.Next()) {
+ if (it1.Value() != it2.Value()) return false;
+ }
+ return true;
+}
+
+// Requires union weight has been canonicalized.
+template <class W, class O>
+inline bool operator!=(const UnionWeight<W, O> &w1,
+ const UnionWeight<W, O> &w2) {
+ return !(w1 == w2);
+}
+
+// Requires union weight has been canonicalized.
+template <class W, class O>
+inline bool ApproxEqual(const UnionWeight<W, O> &w1,
+ const UnionWeight<W, O> &w2, float delta = kDelta) {
+ if (w1.Size() != w2.Size()) return false;
+ UnionWeightIterator<W, O> it1(w1);
+ UnionWeightIterator<W, O> it2(w2);
+ for (; !it1.Done(); it1.Next(), it2.Next()) {
+ if (!ApproxEqual(it1.Value(), it2.Value(), delta)) return false;
+ }
+ return true;
+}
+
+template <class W, class O>
+inline std::ostream &operator<<(std::ostream &ostrm,
+ const UnionWeight<W, O> &weight) {
+ UnionWeightIterator<W, O> it(weight);
+ if (it.Done()) {
+ return ostrm << "EmptySet";
+ } else if (!weight.Member()) {
+ return ostrm << "BadSet";
+ } else {
+ CompositeWeightWriter writer(ostrm);
+ writer.WriteBegin();
+ for (; !it.Done(); it.Next()) writer.WriteElement(it.Value());
+ writer.WriteEnd();
+ }
+ return ostrm;
+}
+
+template <class W, class O>
+inline std::istream &operator>>(std::istream &istrm,
+ UnionWeight<W, O> &weight) {
+ string s;
+ istrm >> s;
+ if (s == "EmptySet") {
+ weight = UnionWeight<W, O>::Zero();
+ } else if (s == "BadSet") {
+ weight = UnionWeight<W, O>::NoWeight();
+ } else {
+ weight = UnionWeight<W, O>::Zero();
+ std::istringstream sstrm(s);
+ CompositeWeightReader reader(sstrm);
+ reader.ReadBegin();
+ bool more = true;
+ while (more) {
+ W v;
+ more = reader.ReadElement(&v);
+ weight.PushBack(v, true);
+ }
+ reader.ReadEnd();
+ }
+ return istrm;
+}
+
+template <class W, class O>
+inline UnionWeight<W, O> Plus(const UnionWeight<W, O> &w1,
+ const UnionWeight<W, O> &w2) {
+ if (!w1.Member() || !w2.Member()) return UnionWeight<W, O>::NoWeight();
+ if (w1 == UnionWeight<W, O>::Zero()) return w2;
+ if (w2 == UnionWeight<W, O>::Zero()) return w1;
+ UnionWeightIterator<W, O> it1(w1);
+ UnionWeightIterator<W, O> it2(w2);
+ UnionWeight<W, O> sum;
+ typename O::Compare comp;
+ while (!it1.Done() && !it2.Done()) {
+ const auto v1 = it1.Value();
+ const auto v2 = it2.Value();
+ if (comp(v1, v2)) {
+ sum.PushBack(v1, true);
+ it1.Next();
+ } else {
+ sum.PushBack(v2, true);
+ it2.Next();
+ }
+ }
+ for (; !it1.Done(); it1.Next()) sum.PushBack(it1.Value(), true);
+ for (; !it2.Done(); it2.Next()) sum.PushBack(it2.Value(), true);
+ return sum;
+}
+
+template <class W, class O>
+inline UnionWeight<W, O> Times(const UnionWeight<W, O> &w1,
+ const UnionWeight<W, O> &w2) {
+ if (!w1.Member() || !w2.Member()) return UnionWeight<W, O>::NoWeight();
+ if (w1 == UnionWeight<W, O>::Zero() || w2 == UnionWeight<W, O>::Zero()) {
+ return UnionWeight<W, O>::Zero();
+ }
+ UnionWeightIterator<W, O> it1(w1);
+ UnionWeightIterator<W, O> it2(w2);
+ UnionWeight<W, O> prod1;
+ for (; !it1.Done(); it1.Next()) {
+ UnionWeight<W, O> prod2;
+ for (; !it2.Done(); it2.Next()) {
+ prod2.PushBack(Times(it1.Value(), it2.Value()), true);
+ }
+ prod1 = Plus(prod1, prod2);
+ it2.Reset();
+ }
+ return prod1;
+}
+
+template <class W, class O>
+inline UnionWeight<W, O> Divide(const UnionWeight<W, O> &w1,
+ const UnionWeight<W, O> &w2, DivideType typ) {
+ if (!w1.Member() || !w2.Member()) return UnionWeight<W, O>::NoWeight();
+ if (w1 == UnionWeight<W, O>::Zero() || w2 == UnionWeight<W, O>::Zero()) {
+ return UnionWeight<W, O>::Zero();
+ }
+ UnionWeightIterator<W, O> it1(w1);
+ UnionWeightReverseIterator<W, O> it2(w2);
+ UnionWeight<W, O> quot;
+ if (w1.Size() == 1) {
+ for (; !it2.Done(); it2.Next()) {
+ quot.PushBack(Divide(it1.Value(), it2.Value(), typ), true);
+ }
+ } else if (w2.Size() == 1) {
+ for (; !it1.Done(); it1.Next()) {
+ quot.PushBack(Divide(it1.Value(), it2.Value(), typ), true);
+ }
+ } else {
+ quot = UnionWeight<W, O>::NoWeight();
+ }
+ return quot;
+}
+
+// This function object generates weights over the union of weights for the
+// underlying generators for the template weight types. This is intended
+// primarily for testing.
+template <class W, class O>
+class WeightGenerate<UnionWeight<W, O>> {
+ public:
+ using Weight = UnionWeight<W, O>;
+ using Generate = WeightGenerate<W>;
+
+ explicit WeightGenerate(bool allow_zero = true,
+ size_t num_random_weights = kNumRandomWeights)
+ : generate_(false), allow_zero_(allow_zero),
+ num_random_weights_(num_random_weights) {}
+
+ Weight operator()() const {
+ const int n = rand() % (num_random_weights_ + 1); // NOLINT
+ if (allow_zero_ && n == num_random_weights_) {
+ return Weight::Zero();
+ } else if (n % 2 == 0) {
+ return Weight(generate_());
+ } else {
+ return Plus(Weight(generate_()), Weight(generate_()));
+ }
+ }
+
+ private:
+ Generate generate_;
+ // Permits Zero() and zero divisors.
+ bool allow_zero_;
+ // The number of alternative random weights.
+ const size_t num_random_weights_;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_UNION_WEIGHT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Functions and classes to compute the union of two FSTs.
+
+#ifndef FST_LIB_UNION_H_
+#define FST_LIB_UNION_H_
+
+#include <algorithm>
+#include <vector>
+
+#include <fst/mutable-fst.h>
+#include <fst/rational.h>
+
+
+namespace fst {
+
+// Computes the union (sum) of two FSTs. This version writes the union to an
+// output MutableFst. 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.
+//
+// Complexity:
+//
+// Time: (V_2 + E_2)
+// Space: O(V_2 + E_2)
+//
+// where Vi is the number of states, and Ei is the number of arcs, in the ith
+// FST.
+template <class Arc>
+void Union(MutableFst<Arc> *fst1, const Fst<Arc> &fst2) {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ // Checks for symbol table compatibility.
+ if (!CompatSymbols(fst1->InputSymbols(), fst2.InputSymbols()) ||
+ !CompatSymbols(fst1->OutputSymbols(), fst2.OutputSymbols())) {
+ FSTERROR() << "Union: Input/output symbol tables of 1st argument "
+ << "do not match input/output symbol tables of 2nd argument";
+ fst1->SetProperties(kError, kError);
+ return;
+ }
+ const auto numstates1 = fst1->NumStates();
+ const bool initial_acyclic1 = fst1->Properties(kInitialAcyclic, true);
+ const auto props1 = fst1->Properties(kFstProperties, false);
+ const auto props2 = fst2.Properties(kFstProperties, false);
+ const auto start2 = fst2.Start();
+ if (start2 == kNoStateId) {
+ if (props2 & kError) fst1->SetProperties(kError, kError);
+ return;
+ }
+ if (fst2.Properties(kExpanded, false)) {
+ fst1->ReserveStates(numstates1 + CountStates(fst2) +
+ (initial_acyclic1 ? 0 : 1));
+ }
+ for (StateIterator<Fst<Arc>> siter(fst2); !siter.Done(); siter.Next()) {
+ const auto s1 = fst1->AddState();
+ const auto s2 = siter.Value();
+ fst1->SetFinal(s1, fst2.Final(s2));
+ fst1->ReserveArcs(s1, fst2.NumArcs(s2));
+ for (ArcIterator<Fst<Arc>> aiter(fst2, s2); !aiter.Done(); aiter.Next()) {
+ auto arc = aiter.Value(); // Copy intended.
+ arc.nextstate += numstates1;
+ fst1->AddArc(s1, arc);
+ }
+ }
+ const auto start1 = fst1->Start();
+ if (start1 == kNoStateId) {
+ fst1->SetStart(start2);
+ fst1->SetProperties(props2, kCopyProperties);
+ return;
+ }
+ if (initial_acyclic1) {
+ fst1->AddArc(start1, Arc(0, 0, Weight::One(), start2 + numstates1));
+ } else {
+ const auto nstart1 = fst1->AddState();
+ fst1->SetStart(nstart1);
+ fst1->AddArc(nstart1, Arc(0, 0, Weight::One(), start1));
+ fst1->AddArc(nstart1, Arc(0, 0, Weight::One(), start2 + numstates1));
+ }
+ fst1->SetProperties(UnionProperties(props1, props2), kFstProperties);
+}
+
+// Computes the union of two FSTs, modifying the RationalFst argument.
+template <class Arc>
+void Union(RationalFst<Arc> *fst1, const Fst<Arc> &fst2) {
+ fst1->GetMutableImpl()->AddUnion(fst2);
+}
+
+using UnionFstOptions = RationalFstOptions;
+
+// Computes the union (sum) of two FSTs. This version is a delayed FST. 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.
+//
+// Complexity:
+//
+// Time: O(v_1 + e_1 + v_2 + e_2)
+// Space: O(v_1 + v_2)
+//
+// where vi is the number of states visited, and ei is the number of arcs
+// visited, in the ith FST. Constant time and space to visit an input state or
+// arc is assumed and exclusive of caching.
+template <class A>
+class UnionFst : public RationalFst<A> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ UnionFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2) {
+ GetMutableImpl()->InitUnion(fst1, fst2);
+ }
+
+ UnionFst(const Fst<Arc> &fst1, const Fst<Arc> &fst2,
+ const UnionFstOptions &opts)
+ : RationalFst<Arc>(opts) {
+ GetMutableImpl()->InitUnion(fst1, fst2);
+ }
+
+ // See Fst<>::Copy() for doc.
+ UnionFst(const UnionFst<Arc> &fst, bool safe = false)
+ : RationalFst<Arc>(fst, safe) {}
+
+ // Gets a copy of this UnionFst. See Fst<>::Copy() for further doc.
+ UnionFst<Arc> *Copy(bool safe = false) const override {
+ return new UnionFst<Arc>(*this, safe);
+ }
+
+ private:
+ using ImplToFst<internal::RationalFstImpl<Arc>>::GetImpl;
+ using ImplToFst<internal::RationalFstImpl<Arc>>::GetMutableImpl;
+};
+
+// Specialization for UnionFst.
+template <class Arc>
+class StateIterator<UnionFst<Arc>> : public StateIterator<RationalFst<Arc>> {
+ public:
+ explicit StateIterator(const UnionFst<Arc> &fst)
+ : StateIterator<RationalFst<Arc>>(fst) {}
+};
+
+// Specialization for UnionFst.
+template <class Arc>
+class ArcIterator<UnionFst<Arc>> : public ArcIterator<RationalFst<Arc>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const UnionFst<Arc> &fst, StateId s)
+ : ArcIterator<RationalFst<Arc>>(fst, s) {}
+};
+
+using StdUnionFst = UnionFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_UNION_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// FST utility inline definitions.
+
+#ifndef FST_LIB_UTIL_H_
+#define FST_LIB_UTIL_H_
+
+#include <iostream>
+#include <list>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <fst/compat.h>
+#include <fst/types.h>
+#include <fstream>
+
+
+// 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 <class T,
+ typename std::enable_if<std::is_class<T>::value, T>::type* = nullptr>
+inline std::istream &ReadType(std::istream &strm, T *t) {
+ return t->Read(strm);
+}
+
+// Numeric (boolean, integral, floating-point) case.
+template <class T,
+ typename std::enable_if<std::is_arithmetic<T>::value, T>::type* = nullptr>
+inline std::istream &ReadType(std::istream &strm, T *t) {
+ return strm.read(reinterpret_cast<char *>(t), sizeof(T)); \
+}
+
+// String case.
+inline std::istream &ReadType(std::istream &strm, string *s) { // NOLINT
+ s->clear();
+ int32 ns = 0;
+ strm.read(reinterpret_cast<char *>(&ns), sizeof(ns));
+ for (auto 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.
+
+#define DECL_READ_TYPE2(C) \
+ template <typename S, typename T> \
+ inline std::istream &ReadType(std::istream &strm, C<S, T> *c) // NOLINT
+
+#define DECL_READ_TYPE3(C) \
+ template <typename S, typename T, typename U> \
+ inline std::istream &ReadType(std::istream &strm, C<S, T, U> *c)
+
+DECL_READ_TYPE2(std::vector);
+DECL_READ_TYPE2(std::list);
+
+DECL_READ_TYPE3(std::set);
+DECL_READ_TYPE3(std::unordered_set);
+DECL_READ_TYPE3(std::map);
+DECL_READ_TYPE3(std::unordered_map);
+
+// Pair case.
+template <typename S, typename T>
+inline std::istream &ReadType(std::istream &strm, std::pair<S, T> *p) {
+ ReadType(strm, &p->first);
+ ReadType(strm, &p->second);
+ return strm;
+}
+
+template <typename S, typename T>
+inline std::istream &ReadType(std::istream &strm, std::pair<const S, T> *p) {
+ ReadType(strm, const_cast<S *>(&p->first));
+ ReadType(strm, &p->second);
+ return strm;
+}
+
+// General case - no-op.
+template <typename C>
+void StlReserve(C *c, int64 n) {}
+
+// Specialization for vectors.
+template <typename S, typename T>
+void StlReserve(std::vector<S, T> *c, int64 n) {
+ c->reserve(n);
+}
+
+// STL sequence container.
+#define READ_STL_SEQ_TYPE(C) \
+ template <typename S, typename T> \
+ inline std::istream &ReadType(std::istream &strm, C<S, T> *c) { \
+ c->clear(); \
+ int64 n = 0; \
+ strm.read(reinterpret_cast<char *>(&n), sizeof(n)); \
+ StlReserve(c, n); \
+ for (ssize_t i = 0; i < n; ++i) { \
+ typename C<S, T>::value_type value; \
+ ReadType(strm, &value); \
+ c->insert(c->end(), value); \
+ } \
+ return strm; \
+ }
+
+READ_STL_SEQ_TYPE(vector);
+READ_STL_SEQ_TYPE(std::list);
+
+// STL associative container.
+#define READ_STL_ASSOC_TYPE(C) \
+ template <typename S, typename T, typename U> \
+ inline std::istream &ReadType(std::istream &strm, C<S, T, U> *c) { \
+ c->clear(); \
+ int64 n = 0; \
+ strm.read(reinterpret_cast<char *>(&n), sizeof(n)); \
+ for (ssize_t i = 0; i < n; ++i) { \
+ typename C<S, T, U>::value_type value; \
+ ReadType(strm, &value); \
+ c->insert(value); \
+ } \
+ return strm; \
+ }
+
+READ_STL_ASSOC_TYPE(std::set);
+READ_STL_ASSOC_TYPE(std::unordered_set);
+READ_STL_ASSOC_TYPE(std::map);
+READ_STL_ASSOC_TYPE(std::unordered_map);
+
+// Writes types to an output stream.
+
+// Generic case.
+template <class T,
+ typename std::enable_if<std::is_class<T>::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 <class T,
+ typename std::enable_if<std::is_arithmetic<T>::value, T>::type* = nullptr>
+inline std::ostream &WriteType(std::ostream &strm, const T t) {
+ return strm.write(reinterpret_cast<const char *>(&t), sizeof(T));
+}
+
+// String case.
+inline std::ostream &WriteType(std::ostream &strm, const string &s) { // NOLINT
+ int32 ns = s.size();
+ strm.write(reinterpret_cast<const char *>(&ns), sizeof(ns));
+ return strm.write(s.data(), ns);
+}
+
+// Declares types that can be written to an output stream.
+
+#define DECL_WRITE_TYPE2(C) \
+ template <typename S, typename T> \
+ inline std::ostream &WriteType(std::ostream &strm, const C<S, T> &c)
+
+#define DECL_WRITE_TYPE3(C) \
+ template <typename S, typename T, typename U> \
+ inline std::ostream &WriteType(std::ostream &strm, \
+ const C<S, T, U> &c) // NOLINT
+
+DECL_WRITE_TYPE2(std::vector);
+DECL_WRITE_TYPE2(std::list);
+
+DECL_WRITE_TYPE3(std::set);
+DECL_WRITE_TYPE3(std::unordered_set);
+DECL_WRITE_TYPE3(std::map);
+DECL_WRITE_TYPE3(std::unordered_map);
+
+// Pair case.
+template <typename S, typename T>
+inline std::ostream &WriteType(std::ostream &strm,
+ const std::pair<S, T> &p) { // NOLINT
+ WriteType(strm, p.first);
+ WriteType(strm, p.second);
+ return strm;
+}
+
+// STL sequence container.
+#define WRITE_STL_SEQ_TYPE(C) \
+ template <typename S, typename T> \
+ inline std::ostream &WriteType(std::ostream &strm, const C<S, T> &c) { \
+ int64 n = c.size(); \
+ strm.write(reinterpret_cast<char *>(&n), sizeof(n)); \
+ for (typename C<S, T>::const_iterator it = c.begin(); it != c.end(); ++it) \
+ WriteType(strm, *it); \
+ return strm; \
+ }
+
+WRITE_STL_SEQ_TYPE(vector);
+WRITE_STL_SEQ_TYPE(std::list);
+
+// STL associative container.
+#define WRITE_STL_ASSOC_TYPE(C) \
+ template <typename S, typename T, typename U> \
+ inline std::ostream &WriteType(std::ostream &strm, const C<S, T, U> &c) { \
+ int64 n = c.size(); \
+ strm.write(reinterpret_cast<char *>(&n), sizeof(n)); \
+ for (typename C<S, T, U>::const_iterator it = c.begin(); it != c.end(); \
+ ++it) \
+ WriteType(strm, *it); \
+ return strm; \
+ }
+
+WRITE_STL_ASSOC_TYPE(std::set);
+WRITE_STL_ASSOC_TYPE(std::unordered_set);
+WRITE_STL_ASSOC_TYPE(std::map);
+WRITE_STL_ASSOC_TYPE(std::unordered_map);
+
+// Utilities for converting between int64 or Weight and string.
+
+int64 StrToInt64(const string &s, const string &src, size_t nline,
+ bool allow_negative, bool *error = nullptr);
+
+template <typename Weight>
+Weight StrToWeight(const string &s, const string &src, size_t nline) {
+ Weight w;
+ std::istringstream strm(s);
+ strm >> w;
+ if (!strm) {
+ FSTERROR() << "StrToWeight: Bad weight = \"" << s << "\", source = " << src
+ << ", line = " << nline;
+ return Weight::NoWeight();
+ }
+ return w;
+}
+
+void Int64ToStr(int64 n, string *s);
+
+template <typename Weight>
+void WeightToStr(Weight w, string *s) {
+ std::ostringstream strm;
+ strm.precision(9);
+ strm << w;
+ s->append(strm.str().data(), strm.str().size());
+}
+
+// Utilities for reading/writing integer pairs (typically labels)
+
+// Modifies line using a vector of pointers to a buffer beginning with line.
+void SplitToVector(char *line, const char *delim, std::vector<char *> *vec,
+ bool omit_empty_strings);
+
+template <typename I>
+bool ReadIntPairs(const string &filename, std::vector<std::pair<I, I>> *pairs,
+ bool allow_negative = false) {
+ std::ifstream strm(filename.c_str(), std::ios_base::in);
+ if (!strm) {
+ LOG(ERROR) << "ReadIntPairs: Can't open file: " << filename;
+ return false;
+ }
+ const int kLineLen = 8096;
+ char line[kLineLen];
+ size_t nline = 0;
+ pairs->clear();
+ while (strm.getline(line, kLineLen)) {
+ ++nline;
+ std::vector<char *> col;
+ SplitToVector(line, "\n\t ", &col, true);
+ // empty line or comment?
+ if (col.empty() || col[0][0] == '\0' || col[0][0] == '#') continue;
+ if (col.size() != 2) {
+ LOG(ERROR) << "ReadIntPairs: Bad number of columns, "
+ << "file = " << filename << ", line = " << nline;
+ return false;
+ }
+ bool err;
+ I i1 = StrToInt64(col[0], filename, nline, allow_negative, &err);
+ if (err) return false;
+ I i2 = StrToInt64(col[1], filename, nline, allow_negative, &err);
+ if (err) return false;
+ pairs->push_back(std::make_pair(i1, i2));
+ }
+ return true;
+}
+
+template <typename I>
+bool WriteIntPairs(const string &filename,
+ const std::vector<std::pair<I, I>> &pairs) {
+ std::ostream *strm = &std::cout;
+ if (!filename.empty()) {
+ strm = new std::ofstream(filename);
+ if (!*strm) {
+ LOG(ERROR) << "WriteIntPairs: Can't open file: " << filename;
+ return false;
+ }
+ }
+ for (ssize_t n = 0; n < pairs.size(); ++n) {
+ *strm << pairs[n].first << "\t" << pairs[n].second << "\n";
+ }
+ if (!*strm) {
+ LOG(ERROR) << "WriteIntPairs: Write failed: "
+ << (filename.empty() ? "standard output" : filename);
+ return false;
+ }
+ if (strm != &std::cout) delete strm;
+ return true;
+}
+
+// Utilities for reading/writing label pairs.
+
+template <typename Label>
+bool ReadLabelPairs(const string &filename,
+ std::vector<std::pair<Label, Label>> *pairs,
+ bool allow_negative = false) {
+ return ReadIntPairs(filename, pairs, allow_negative);
+}
+
+template <typename Label>
+bool WriteLabelPairs(const string &filename,
+ const std::vector<std::pair<Label, Label>> &pairs) {
+ return WriteIntPairs(filename, pairs);
+}
+
+// Utilities for converting a type name to a legal C symbol.
+
+void ConvertToLegalCSymbol(string *s);
+
+// Utilities for stream I/O.
+
+bool AlignInput(std::istream &strm);
+bool AlignOutput(std::ostream &strm);
+
+// An associative container for which testing membership is faster than an STL
+// set if members are restricted to an interval that excludes most non-members.
+// A Key must have ==, !=, and < operators defined. Element NoKey should be a
+// key that marks an uninitialized key and is otherwise unused. Find() returns
+// an STL const_iterator to the match found, otherwise it equals End().
+template <class Key, Key NoKey>
+class CompactSet {
+ public:
+ using const_iterator = typename std::set<Key>::const_iterator;
+
+ CompactSet() : min_key_(NoKey), max_key_(NoKey) {}
+
+ CompactSet(const CompactSet<Key, NoKey> &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<Key> set_;
+ Key min_key_;
+ Key max_key_;
+
+ void operator=(const CompactSet &) = delete;
+};
+
+} // namespace fst
+
+#endif // FST_LIB_UTIL_H_
--- /dev/null
+// 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_LIB_VECTOR_FST_H_
+#define FST_LIB_VECTOR_FST_H_
+
+#include <string>
+#include <vector>
+
+#include <fst/fst-decl.h> // For optional argument declarations
+#include <fst/mutable-fst.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+template <class A, class S>
+class VectorFst;
+
+template <class F, class G>
+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 A, class M /* = std::allocator<A> */>
+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<VectorState<Arc, M>>::other;
+
+ // Provide STL allocator for arcs.
+ explicit VectorState(const ArcAllocator &alloc)
+ : final_(Weight::Zero()), niepsilons_(0), noepsilons_(0), arcs_(alloc) {}
+
+ VectorState(const VectorState<A, M> &state, const ArcAllocator &alloc)
+ : final_(state.Final()),
+ niepsilons_(state.NumInputEpsilons()),
+ noepsilons_(state.NumOutputEpsilons()),
+ arcs_(state.arcs_.begin(), state.arcs_.end(), alloc) {}
+
+ void Reset() {
+ final_ = Weight::Zero();
+ niepsilons_ = 0;
+ noepsilons_ = 0;
+ arcs_.clear();
+ }
+
+ Weight Final() const { return final_; }
+
+ size_t NumInputEpsilons() const { return niepsilons_; }
+
+ size_t NumOutputEpsilons() const { return noepsilons_; }
+
+ size_t NumArcs() const { return arcs_.size(); }
+
+ const Arc &GetArc(size_t n) const { return arcs_[n]; }
+
+ const Arc *Arcs() const { return !arcs_.empty() ? &arcs_[0] : nullptr; }
+
+ Arc *MutableArcs() { return !arcs_.empty() ? &arcs_[0] : nullptr; }
+
+ void ReserveArcs(size_t n) { arcs_.reserve(n); }
+
+ void SetFinal(Weight weight) { final_ = weight; }
+
+ void SetNumInputEpsilons(size_t n) { niepsilons_ = n; }
+
+ void SetNumOutputEpsilons(size_t n) { noepsilons_ = n; }
+
+ void AddArc(const Arc &arc) {
+ if (arc.ilabel == 0) ++niepsilons_;
+ if (arc.olabel == 0) ++noepsilons_;
+ arcs_.push_back(arc);
+ }
+
+ void SetArc(const Arc &arc, size_t n) {
+ if (arcs_[n].ilabel == 0) --niepsilons_;
+ if (arcs_[n].olabel == 0) --noepsilons_;
+ if (arc.ilabel == 0) ++niepsilons_;
+ if (arc.olabel == 0) ++noepsilons_;
+ arcs_[n] = arc;
+ }
+
+ void DeleteArcs() {
+ niepsilons_ = 0;
+ noepsilons_ = 0;
+ arcs_.clear();
+ }
+
+ void DeleteArcs(size_t n) {
+ for (size_t i = 0; i < n; ++i) {
+ if (arcs_.back().ilabel == 0) --niepsilons_;
+ if (arcs_.back().olabel == 0) --noepsilons_;
+ arcs_.pop_back();
+ }
+ }
+
+ // For state class allocation.
+ void *operator new(size_t size, StateAllocator *alloc) {
+ return alloc->allocate(1);
+ }
+
+ // For state destruction and memory freeing.
+ static void Destroy(VectorState<A, M> *state, StateAllocator *alloc) {
+ if (state) {
+ state->~VectorState<A, M>();
+ alloc->deallocate(state, 1);
+ }
+ }
+
+ private:
+ Weight final_; // Final weight.
+ size_t niepsilons_; // # of input epsilons
+ size_t noepsilons_; // # of output epsilons
+ std::vector<A, ArcAllocator> 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 S>
+class VectorFstBaseImpl : public FstImpl<typename S::Arc> {
+ public:
+ using State = S;
+ using Arc = typename State::Arc;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ VectorFstBaseImpl() : start_(kNoStateId) {}
+
+ ~VectorFstBaseImpl() override {
+ for (StateId s = 0; s < states_.size(); ++s) {
+ State::Destroy(states_[s], &state_alloc_);
+ }
+ }
+
+ StateId Start() const { return start_; }
+
+ Weight Final(StateId state) const { return states_[state]->Final(); }
+
+ StateId NumStates() const { return states_.size(); }
+
+ size_t NumArcs(StateId state) const { return states_[state]->NumArcs(); }
+
+ size_t NumInputEpsilons(StateId state) const {
+ return GetState(state)->NumInputEpsilons();
+ }
+
+ size_t NumOutputEpsilons(StateId state) const {
+ return GetState(state)->NumOutputEpsilons();
+ }
+
+ void SetStart(StateId state) { start_ = state; }
+
+ void SetFinal(StateId state, Weight weight) {
+ states_[state]->SetFinal(weight);
+ }
+
+ StateId AddState() {
+ states_.push_back(new (&state_alloc_) State(arc_alloc_));
+ return states_.size() - 1;
+ }
+
+ StateId AddState(State *state) {
+ states_.push_back(state);
+ return states_.size() - 1;
+ }
+
+ void AddArc(StateId state, const Arc &arc) { states_[state]->AddArc(arc); }
+
+ void DeleteStates(const std::vector<StateId> &dstates) {
+ std::vector<StateId> newid(states_.size(), 0);
+ for (StateId i = 0; i < dstates.size(); ++i) newid[dstates[i]] = kNoStateId;
+ StateId nstates = 0;
+ for (StateId state = 0; state < states_.size(); ++state) {
+ if (newid[state] != kNoStateId) {
+ newid[state] = nstates;
+ if (state != nstates) states_[nstates] = states_[state];
+ ++nstates;
+ } else {
+ State::Destroy(states_[state], &state_alloc_);
+ }
+ }
+ states_.resize(nstates);
+ for (StateId state = 0; state < states_.size(); ++state) {
+ auto *arcs = states_[state]->MutableArcs();
+ size_t narcs = 0;
+ auto nieps = states_[state]->NumInputEpsilons();
+ auto noeps = states_[state]->NumOutputEpsilons();
+ for (auto i = 0; i < states_[state]->NumArcs(); ++i) {
+ const auto t = newid[arcs[i].nextstate];
+ if (t != kNoStateId) {
+ arcs[i].nextstate = t;
+ if (i != narcs) arcs[narcs] = arcs[i];
+ ++narcs;
+ } else {
+ if (arcs[i].ilabel == 0) --nieps;
+ if (arcs[i].olabel == 0) --noeps;
+ }
+ }
+ states_[state]->DeleteArcs(states_[state]->NumArcs() - narcs);
+ states_[state]->SetNumInputEpsilons(nieps);
+ states_[state]->SetNumOutputEpsilons(noeps);
+ }
+ if (Start() != kNoStateId) SetStart(newid[Start()]);
+ }
+
+ void DeleteStates() {
+ for (StateId state = 0; state < states_.size(); ++state) {
+ State::Destroy(states_[state], &state_alloc_);
+ }
+ states_.clear();
+ SetStart(kNoStateId);
+ }
+
+ void DeleteArcs(StateId state, size_t n) { states_[state]->DeleteArcs(n); }
+
+ void DeleteArcs(StateId state) { states_[state]->DeleteArcs(); }
+
+ State *GetState(StateId state) { return states_[state]; }
+
+ const State *GetState(StateId state) const { return states_[state]; }
+
+ void SetState(StateId state, State *vstate) { states_[state] = vstate; }
+
+ void ReserveStates(StateId n) { states_.reserve(n); }
+
+ void ReserveArcs(StateId state, size_t n) { states_[state]->ReserveArcs(n); }
+
+ // Provide information needed for generic state iterator.
+ void InitStateIterator(StateIteratorData<Arc> *data) const {
+ data->base = nullptr;
+ data->nstates = states_.size();
+ }
+
+ // Provide information needed for generic arc iterator.
+ void InitArcIterator(StateId state, ArcIteratorData<Arc> *data) const {
+ data->base = nullptr;
+ data->narcs = states_[state]->NumArcs();
+ data->arcs = states_[state]->Arcs();
+ data->ref_count = nullptr;
+ }
+
+ private:
+ std::vector<State *> states_; // States represenation.
+ StateId start_; // Initial state.
+ typename State::StateAllocator state_alloc_; // For state allocation.
+ typename State::ArcAllocator arc_alloc_; // For arc allocation.
+
+ VectorFstBaseImpl(const VectorFstBaseImpl &) = delete;
+ VectorFstBaseImpl &operator=(const VectorFstBaseImpl &) = delete;
+};
+
+// This is a VectorFstBaseImpl container that holds VectorStates and manages FST
+// properties.
+template <class S>
+class VectorFstImpl : public VectorFstBaseImpl<S> {
+ 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<Arc>::SetInputSymbols;
+ using FstImpl<Arc>::SetOutputSymbols;
+ using FstImpl<Arc>::SetType;
+ using FstImpl<Arc>::SetProperties;
+ using FstImpl<Arc>::Properties;
+
+ using VectorFstBaseImpl<S>::Start;
+ using VectorFstBaseImpl<S>::NumStates;
+ using VectorFstBaseImpl<S>::GetState;
+ using VectorFstBaseImpl<S>::ReserveArcs;
+
+ friend class MutableArcIterator<VectorFst<Arc, S>>;
+
+ using BaseImpl = VectorFstBaseImpl<S>;
+
+ VectorFstImpl() {
+ SetType("vector");
+ SetProperties(kNullProperties | kStaticProperties);
+ }
+
+ explicit VectorFstImpl(const Fst<Arc> &fst);
+
+ static VectorFstImpl<S> *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);
+ BaseImpl::SetFinal(state, weight);
+ SetProperties(SetFinalProperties(Properties(), old_weight, weight));
+ }
+
+ StateId AddState() {
+ const auto state = BaseImpl::AddState();
+ SetProperties(AddStateProperties(Properties()));
+ return state;
+ }
+
+ void AddArc(StateId state, const Arc &arc) {
+ auto *vstate = GetState(state);
+ const auto *parc = vstate->NumArcs() == 0
+ ? nullptr
+ : &(vstate->GetArc(vstate->NumArcs() - 1));
+ SetProperties(AddArcProperties(Properties(), state, arc, parc));
+ BaseImpl::AddArc(state, arc);
+ }
+
+ void DeleteStates(const std::vector<StateId> &dstates) {
+ BaseImpl::DeleteStates(dstates);
+ SetProperties(DeleteStatesProperties(Properties()));
+ }
+
+ void DeleteStates() {
+ BaseImpl::DeleteStates();
+ SetProperties(DeleteAllStatesProperties(Properties(), kStaticProperties));
+ }
+
+ void DeleteArcs(StateId state, size_t n) {
+ BaseImpl::DeleteArcs(state, n);
+ SetProperties(DeleteArcsProperties(Properties()));
+ }
+
+ void DeleteArcs(StateId state) {
+ BaseImpl::DeleteArcs(state);
+ SetProperties(DeleteArcsProperties(Properties()));
+ }
+
+ // Properties always true of this FST class
+ static constexpr uint64 kStaticProperties = kExpanded | kMutable;
+
+ private:
+ // Minimum file format version supported.
+ static constexpr int kMinFileVersion = 2;
+};
+
+template <class S>
+constexpr uint64 VectorFstImpl<S>::kStaticProperties;
+
+template <class S>
+constexpr int VectorFstImpl<S>::kMinFileVersion;
+
+template <class S>
+VectorFstImpl<S>::VectorFstImpl(const Fst<Arc> &fst) {
+ SetType("vector");
+ SetInputSymbols(fst.InputSymbols());
+ SetOutputSymbols(fst.OutputSymbols());
+ BaseImpl::SetStart(fst.Start());
+ if (fst.Properties(kExpanded, false)) {
+ BaseImpl::ReserveStates(CountStates(fst));
+ }
+ for (StateIterator<Fst<Arc>> 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<Fst<Arc>> aiter(fst, state); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ BaseImpl::AddArc(state, arc);
+ }
+ }
+ SetProperties(fst.Properties(kCopyProperties, false) | kStaticProperties);
+}
+
+template <class S>
+VectorFstImpl<S> *VectorFstImpl<S>::Read(std::istream &strm,
+ const FstReadOptions &opts) {
+ std::unique_ptr<VectorFstImpl<S>> impl(new VectorFstImpl());
+ FstHeader hdr;
+ if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) return nullptr;
+ impl->BaseImpl::SetStart(hdr.Start());
+ if (hdr.NumStates() != kNoStateId) impl->ReserveStates(hdr.NumStates());
+ StateId state = 0;
+ for (; hdr.NumStates() == kNoStateId || state < hdr.NumStates(); ++state) {
+ Weight weight;
+ if (!weight.Read(strm)) break;
+ impl->BaseImpl::AddState();
+ auto *vstate = impl->GetState(state);
+ vstate->SetFinal(weight);
+ int64 narcs;
+ ReadType(strm, &narcs);
+ if (!strm) {
+ LOG(ERROR) << "VectorFst::Read: Read failed: " << opts.source;
+ return nullptr;
+ }
+ impl->ReserveArcs(state, narcs);
+ for (int64 i = 0; i < narcs; ++i) {
+ Arc arc;
+ ReadType(strm, &arc.ilabel);
+ ReadType(strm, &arc.olabel);
+ arc.weight.Read(strm);
+ ReadType(strm, &arc.nextstate);
+ if (!strm) {
+ LOG(ERROR) << "VectorFst::Read: Read failed: " << opts.source;
+ return nullptr;
+ }
+ impl->BaseImpl::AddArc(state, arc);
+ }
+ }
+ if (hdr.NumStates() != kNoStateId && state != hdr.NumStates()) {
+ LOG(ERROR) << "VectorFst::Read: Unexpected end of file: " << opts.source;
+ return nullptr;
+ }
+ return impl.release();
+}
+
+} // namespace internal
+
+// Simple concrete, mutable FST. This class attaches interface to implementation
+// and handles reference counting, delegating most methods to ImplToMutableFst.
+// Also supports ReserveStates and ReserveArcs methods (cf. STL vector methods).
+// The second optional template argument gives the State definition.
+template <class A, class S /* = VectorState<A> */>
+class VectorFst : public ImplToMutableFst<internal::VectorFstImpl<S>> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ using State = S;
+ using Impl = internal::VectorFstImpl<State>;
+
+ friend class StateIterator<VectorFst<Arc, State>>;
+ friend class ArcIterator<VectorFst<Arc, State>>;
+ friend class MutableArcIterator<VectorFst<A, S>>;
+
+ template <class F, class G>
+ friend void Cast(const F &, G *);
+
+ VectorFst() : ImplToMutableFst<Impl>(std::make_shared<Impl>()) {}
+
+ explicit VectorFst(const Fst<Arc> &fst)
+ : ImplToMutableFst<Impl>(std::make_shared<Impl>(fst)) {}
+
+ VectorFst(const VectorFst<Arc, State> &fst, bool safe = false)
+ : ImplToMutableFst<Impl>(fst) {}
+
+ // Get a copy of this VectorFst. See Fst<>::Copy() for further doc.
+ VectorFst<Arc, State> *Copy(bool safe = false) const override {
+ return new VectorFst<Arc, State>(*this, safe);
+ }
+
+ VectorFst<Arc, State> &operator=(const VectorFst<Arc, State> &fst) {
+ SetImpl(fst.GetSharedImpl());
+ return *this;
+ }
+
+ VectorFst<Arc, State> &operator=(const Fst<Arc> &fst) override {
+ if (this != &fst) SetImpl(std::make_shared<Impl>(fst));
+ return *this;
+ }
+
+ // Reads a VectorFst from an input stream, returning nullptr on error.
+ static VectorFst<Arc, State> *Read(std::istream &strm,
+ const FstReadOptions &opts) {
+ auto *impl = Impl::Read(strm, opts);
+ return impl ? new VectorFst<Arc, State>(std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ // Read a VectorFst from a file, returning nullptr on error; empty filename
+ // reads from standard input.
+ static VectorFst<Arc, State> *Read(const string &filename) {
+ auto *impl = ImplToExpandedFst<Impl, MutableFst<Arc>>::Read(filename);
+ return impl ? new VectorFst<Arc, State>(std::shared_ptr<Impl>(impl))
+ : nullptr;
+ }
+
+ bool Write(std::ostream &strm, const FstWriteOptions &opts) const override {
+ return WriteFst(*this, strm, opts);
+ }
+
+ bool Write(const string &filename) const override {
+ return Fst<Arc>::WriteFile(filename);
+ }
+
+ template <class FST>
+ static bool WriteFst(const FST &fst, std::ostream &strm,
+ const FstWriteOptions &opts);
+
+ void InitStateIterator(StateIteratorData<Arc> *data) const override {
+ GetImpl()->InitStateIterator(data);
+ }
+
+ void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const override {
+ GetImpl()->InitArcIterator(s, data);
+ }
+
+ inline void InitMutableArcIterator(StateId s,
+ MutableArcIteratorData<Arc> *) override;
+
+ using ImplToMutableFst<Impl, MutableFst<Arc>>::ReserveArcs;
+ using ImplToMutableFst<Impl, MutableFst<Arc>>::ReserveStates;
+
+ private:
+ using ImplToMutableFst<Impl, MutableFst<Arc>>::GetImpl;
+ using ImplToMutableFst<Impl, MutableFst<Arc>>::MutateCheck;
+ using ImplToMutableFst<Impl, MutableFst<Arc>>::SetImpl;
+
+ explicit VectorFst(std::shared_ptr<Impl> impl)
+ : ImplToMutableFst<Impl>(impl) {}
+};
+
+// Writes FST to file in Vector format, potentially with a pass over the machine
+// before writing to compute number of states.
+template <class Arc, class State>
+template <class FST>
+bool VectorFst<Arc, State>::WriteFst(const FST &fst, std::ostream &strm,
+ const FstWriteOptions &opts) {
+ static constexpr int file_version = 2;
+ bool update_header = true;
+ FstHeader hdr;
+ hdr.SetStart(fst.Start());
+ hdr.SetNumStates(kNoStateId);
+ size_t start_offset = 0;
+ if (fst.Properties(kExpanded, false) || opts.stream_write ||
+ (start_offset = strm.tellp()) != -1) {
+ hdr.SetNumStates(CountStates(fst));
+ update_header = false;
+ }
+ const auto properties =
+ fst.Properties(kCopyProperties, false) | Impl::kStaticProperties;
+ internal::FstImpl<Arc>::WriteFstHeader(fst, strm, opts, file_version,
+ "vector", properties, &hdr);
+ StateId num_states = 0;
+ for (StateIterator<FST> 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<FST> 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<Arc>::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 Arc, class State>
+class StateIterator<VectorFst<Arc, State>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ explicit StateIterator(const VectorFst<Arc, State> &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 Arc, class State>
+class ArcIterator<VectorFst<Arc, State>> {
+ public:
+ using StateId = typename Arc::StateId;
+
+ ArcIterator(const VectorFst<Arc, State> &fst, StateId s)
+ : arcs_(fst.GetImpl()->GetState(s)->Arcs()),
+ narcs_(fst.GetImpl()->GetState(s)->NumArcs()),
+ i_(0) {}
+
+ bool Done() const { return i_ >= narcs_; }
+
+ const Arc &Value() const { return arcs_[i_]; }
+
+ void Next() { ++i_; }
+
+ void Reset() { i_ = 0; }
+
+ void Seek(size_t a) { i_ = a; }
+
+ size_t Position() const { return i_; }
+
+ constexpr uint32 Flags() const { return kArcValueFlags; }
+
+ void SetFlags(uint32, uint32) {}
+
+ private:
+ const Arc *arcs_;
+ size_t narcs_;
+ size_t i_;
+};
+
+// Specialization for VectorFst; see generic version in mutable-fst.h for sample
+// usage (but use the VectorFst type instead). This version should inline.
+template <class Arc, class State>
+class MutableArcIterator<VectorFst<Arc, State>>
+ : public MutableArcIteratorBase<Arc> {
+ public:
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+
+ MutableArcIterator(VectorFst<Arc, State> *fst, StateId s) : i_(0) {
+ fst->MutateCheck();
+ state_ = fst->GetMutableImpl()->GetState(s);
+ properties_ = &fst->GetImpl()->properties_;
+ }
+
+ bool Done() const override { return i_ >= state_->NumArcs(); }
+
+ const Arc &Value() const override { return state_->GetArc(i_); }
+
+ void Next() override { ++i_; }
+
+ size_t Position() const override { return i_; }
+
+ void Reset() override { i_ = 0; }
+
+ void Seek(size_t a) override { i_ = a; }
+
+ void SetValue(const Arc &arc) override {
+ const auto &oarc = state_->GetArc(i_);
+ if (oarc.ilabel != oarc.olabel) *properties_ &= ~kNotAcceptor;
+ if (oarc.ilabel == 0) {
+ *properties_ &= ~kIEpsilons;
+ if (oarc.olabel == 0) *properties_ &= ~kEpsilons;
+ }
+ if (oarc.olabel == 0) *properties_ &= ~kOEpsilons;
+ if (oarc.weight != Weight::Zero() && oarc.weight != Weight::One()) {
+ *properties_ &= ~kWeighted;
+ }
+ state_->SetArc(arc, i_);
+ if (arc.ilabel != arc.olabel) {
+ *properties_ |= kNotAcceptor;
+ *properties_ &= ~kAcceptor;
+ }
+ if (arc.ilabel == 0) {
+ *properties_ |= kIEpsilons;
+ *properties_ &= ~kNoIEpsilons;
+ if (arc.olabel == 0) {
+ *properties_ |= kEpsilons;
+ *properties_ &= ~kNoEpsilons;
+ }
+ }
+ if (arc.olabel == 0) {
+ *properties_ |= kOEpsilons;
+ *properties_ &= ~kNoOEpsilons;
+ }
+ if (arc.weight != Weight::Zero() && arc.weight != Weight::One()) {
+ *properties_ |= kWeighted;
+ *properties_ &= ~kUnweighted;
+ }
+ *properties_ &= kSetArcProperties | kAcceptor | kNotAcceptor | kEpsilons |
+ kNoEpsilons | kIEpsilons | kNoIEpsilons | kOEpsilons |
+ kNoOEpsilons | kWeighted | kUnweighted;
+ }
+
+ constexpr uint32 Flags() const override { return kArcValueFlags; }
+
+ void SetFlags(uint32, uint32) override {}
+
+ private:
+ State *state_;
+ uint64 *properties_;
+ size_t i_;
+};
+
+// Provides information needed for the generic mutable arc iterator.
+template <class Arc, class State>
+inline void VectorFst<Arc, State>::InitMutableArcIterator(
+ StateId s, MutableArcIteratorData<Arc> *data) {
+ data->base = new MutableArcIterator<VectorFst<Arc, State>>(this, s);
+}
+
+// A useful alias when using StdArc.
+using StdVectorFst = VectorFst<StdArc>;
+
+} // namespace fst
+
+#endif // FST_LIB_VECTOR_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Function to verify an FST's contents.
+
+#ifndef FST_LIB_VERIFY_H_
+#define FST_LIB_VERIFY_H_
+
+#include <fst/fst.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+// Verifies that an Fst's contents are sane.
+template <class Arc>
+bool Verify(const Fst<Arc> &fst, bool allow_negative_labels = false) {
+ using Label = typename Arc::Label;
+ using StateId = typename Arc::StateId;
+ using Weight = typename Arc::Weight;
+ const auto start = fst.Start();
+ const auto *isyms = fst.InputSymbols();
+ const auto *osyms = fst.OutputSymbols();
+ // Count states
+ StateId ns = 0;
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) ++ns;
+ if (start == kNoStateId && ns > 0) {
+ LOG(ERROR) << "Verify: FST start state ID not set";
+ return false;
+ } else if (start >= ns) {
+ LOG(ERROR) << "Verify: FST start state ID exceeds number of states";
+ return false;
+ }
+ for (StateIterator<Fst<Arc>> siter(fst); !siter.Done(); siter.Next()) {
+ auto state = siter.Value();
+ size_t na = 0;
+ for (ArcIterator<Fst<Arc>> aiter(fst, state); !aiter.Done(); aiter.Next()) {
+ const auto &arc = aiter.Value();
+ if (!allow_negative_labels && arc.ilabel < 0) {
+ LOG(ERROR) << "Verify: FST input label ID of arc at position " << na
+ << " of state " << state << " is negative";
+ return false;
+ } else if (isyms && isyms->Find(arc.ilabel) == "") {
+ LOG(ERROR) << "Verify: FST input label ID " << arc.ilabel
+ << " of arc at position " << na << " of state " << state
+ << " is missing from input symbol table \"" << isyms->Name()
+ << "\"";
+ return false;
+ } else if (!allow_negative_labels && arc.olabel < 0) {
+ LOG(ERROR) << "Verify: FST output label ID of arc at position " << na
+ << " of state " << state << " is negative";
+ return false;
+ } else if (osyms && osyms->Find(arc.olabel) == "") {
+ LOG(ERROR) << "Verify: FST output label ID " << arc.olabel
+ << " of arc at position " << na << " of state " << state
+ << " is missing from output symbol table \"" << osyms->Name()
+ << "\"";
+ return false;
+ } else if (!arc.weight.Member()) {
+ LOG(ERROR) << "Verify: FST weight of arc at position " << na
+ << " of state " << state << " is invalid";
+ return false;
+ } else if (arc.nextstate < 0) {
+ LOG(ERROR) << "Verify: FST destination state ID of arc at position "
+ << na << " of state " << state << " is negative";
+ return false;
+ } else if (arc.nextstate >= ns) {
+ LOG(ERROR) << "Verify: FST destination state ID of arc at position "
+ << na << " of state " << state
+ << " exceeds number of states";
+ return false;
+ }
+ ++na;
+ }
+ if (!fst.Final(state).Member()) {
+ LOG(ERROR) << "Verify: FST final weight of state " << state
+ << " is invalid";
+ return false;
+ }
+ }
+ const auto fst_props = fst.Properties(kFstProperties, false);
+ if (fst_props & kError) {
+ LOG(ERROR) << "Verify: FST error property is set";
+ return false;
+ }
+ uint64 known_props;
+ uint64 test_props =
+ ComputeProperties(fst, kFstProperties, &known_props, false);
+ if (!CompatProperties(fst_props, test_props)) {
+ LOG(ERROR) << "Verify: Stored FST properties incorrect "
+ << "(props1 = stored props, props2 = tested)";
+ return false;
+ } else {
+ return true;
+ }
+}
+
+} // namespace fst
+
+#endif // FST_LIB_VERIFY_H_
--- /dev/null
+// 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_LIB_VISIT_H_
+#define FST_LIB_VISIT_H_
+
+
+#include <fst/arcfilter.h>
+#include <fst/mutable-fst.h>
+
+
+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 Arc>
+// class Visitor {
+// public:
+// using StateId = typename Arc::StateId;
+//
+// Visitor(T *return_data);
+//
+// // Invoked before visit.
+// void InitVisit(const Fst<Arc> &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 <class FST, class Visitor, class Queue, class ArcFilter>
+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<uint8> state_status;
+ std::vector<ArcIterator<FST> *> arc_iterator;
+ MemoryPool<ArcIterator<FST>> aiter_pool;
+ auto 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<Fst<Arc>> 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>(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 <class Arc, class Visitor, class Queue>
+inline void Visit(const Fst<Arc> &fst, Visitor *visitor, Queue *queue) {
+ Visit(fst, visitor, queue, AnyArcFilter<Arc>());
+}
+
+// Copies input FST to mutable FST following queue order.
+template <class A>
+class CopyVisitor {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ explicit CopyVisitor(MutableFst<Arc> *ofst) : ifst_(nullptr), ofst_(ofst) {}
+
+ void InitVisit(const Fst<A> &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<Arc> *ifst_;
+ MutableFst<Arc> *ofst_;
+};
+
+// Visits input FST up to a state limit following queue order.
+template <class A>
+class PartialVisitor {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ explicit PartialVisitor(StateId maxvisit)
+ : fst_(nullptr), maxvisit_(maxvisit) {}
+
+ void InitVisit(const Fst<A> &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<Arc> *fst_;
+ StateId maxvisit_;
+ StateId ninit_;
+ StateId nfinish_;
+};
+
+// Copies input FST to mutable FST up to a state limit following queue order.
+template <class A>
+class PartialCopyVisitor : public CopyVisitor<A> {
+ public:
+ using Arc = A;
+ using StateId = typename Arc::StateId;
+
+ using CopyVisitor<A>::WhiteArc;
+
+ PartialCopyVisitor(MutableFst<Arc> *ofst, StateId maxvisit,
+ bool copy_grey = true, bool copy_black = true)
+ : CopyVisitor<A>(ofst), maxvisit_(maxvisit),
+ copy_grey_(copy_grey), copy_black_(copy_black) {}
+
+ void InitVisit(const Fst<A> &ifst) {
+ CopyVisitor<A>::InitVisit(ifst);
+ ninit_ = 0;
+ nfinish_ = 0;
+ }
+
+ bool InitState(StateId state, StateId root) {
+ CopyVisitor<A>::InitState(state, root);
+ ++ninit_;
+ return ninit_ <= maxvisit_;
+ }
+
+ bool GreyArc(StateId state, const Arc &arc) {
+ if (copy_grey_) return CopyVisitor<A>::GreyArc(state, arc);
+ return true;
+ }
+
+ bool BlackArc(StateId state, const Arc &arc) {
+ if (copy_black_) return CopyVisitor<A>::BlackArc(state, arc);
+ return true;
+ }
+
+ void FinishState(StateId state) {
+ CopyVisitor<A>::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_LIB_VISIT_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// General weight set and associated semiring operation definitions.
+
+#ifndef FST_LIB_WEIGHT_H_
+#define FST_LIB_WEIGHT_H_
+
+#include <cctype>
+#include <cmath>
+#include <iostream>
+#include <sstream>
+
+#include <fst/compat.h>
+
+#include <fst/util.h>
+
+
+DECLARE_string(fst_weight_parentheses);
+DECLARE_string(fst_weight_separator);
+
+namespace fst {
+
+// A semiring is specified by two binary operations Plus and Times and two
+// designated elements Zero and One with the following properties:
+//
+// Plus: associative, commutative, and has Zero as its identity.
+//
+// Times: associative and has identity One, distributes w.r.t. Plus, and
+// has Zero as an annihilator:
+// Times(Zero(), a) == Times(a, Zero()) = Zero().
+//
+// A left semiring distributes on the left; a right semiring is similarly
+// defined.
+//
+// A Weight class must have binary functions Plus and Times and static member
+// functions Zero() and One() and these must form (at least) a left or right
+// semiring.
+//
+// In addition, the following should be defined for a Weight:
+//
+// Member: predicate on set membership.
+//
+// NoWeight: static member function that returns an element that is
+// not a set member; used to signal an error.
+//
+// >>: reads textual representation of a weight.
+//
+// <<: prints textual representation of a weight.
+//
+// Read(istream &istrm): reads binary representation of a weight.
+//
+// Write(ostream &ostrm): writes binary representation of a weight.
+//
+// Hash: maps weight to size_t.
+//
+// ApproxEqual: approximate equality (for inexact weights)
+//
+// Quantize: quantizes w.r.t delta (for inexact weights)
+//
+// Divide: for all a, b, c s.t. Times(a, b) == c
+//
+// --> b' = Divide(c, a, DIVIDE_LEFT) if a left semiring, b'.Member()
+// and Times(a, b') == c
+// --> a' = Divide(c, b, DIVIDE_RIGHT) if a right semiring, a'.Member()
+// and Times(a', b) == c
+// --> b' = Divide(c, a) = Divide(c, a, DIVIDE_ANY) =
+// Divide(c, a, DIVIDE_LEFT) = Divide(c, a, DIVIDE_RIGHT) if a
+// commutative semiring, b'.Member() and Times(a, b') = Times(b', a) = c
+//
+// ReverseWeight: the type of the corresponding reverse weight.
+//
+// Typically the same type as Weight for a (both left and right) semiring.
+// For the left string semiring, it is the right string semiring.
+//
+// Reverse: a mapping from Weight to ReverseWeight s.t.
+//
+// --> Reverse(Reverse(a)) = a
+// --> Reverse(Plus(a, b)) = Plus(Reverse(a), Reverse(b))
+// --> Reverse(Times(a, b)) = Times(Reverse(b), Reverse(a))
+// Typically the identity mapping in a (both left and right) semiring.
+// In the left string semiring, it maps to the reverse string in the right
+// string semiring.
+//
+// Properties: specifies additional properties that hold:
+// LeftSemiring: indicates weights form a left semiring.
+// RightSemiring: indicates weights form a right semiring.
+// Commutative: for all a,b: Times(a,b) == Times(b,a)
+// Idempotent: for all a: Plus(a, a) == a.
+// Path: for all a, b: Plus(a, b) == a or Plus(a, b) == b.
+
+// CONSTANT DEFINITIONS
+
+// A representable float near .001.
+constexpr float kDelta = 1.0F / 1024.0F;
+
+// For all a, b, c: Times(c, Plus(a, b)) = Plus(Times(c, a), Times(c, b)).
+constexpr uint64 kLeftSemiring = 0x0000000000000001ULL;
+
+// For all a, b, c: Times(Plus(a, b), c) = Plus(Times(a, c), Times(b, c)).
+constexpr uint64 kRightSemiring = 0x0000000000000002ULL;
+
+constexpr uint64 kSemiring = kLeftSemiring | kRightSemiring;
+
+// For all a, b: Times(a, b) = Times(b, a).
+constexpr uint64 kCommutative = 0x0000000000000004ULL;
+
+// For all a: Plus(a, a) = a.
+constexpr uint64 kIdempotent = 0x0000000000000008ULL;
+
+// For all a, b: Plus(a, b) = a or Plus(a, b) = b.
+constexpr uint64 kPath = 0x0000000000000010ULL;
+
+// For random weight generation: default number of distinct weights.
+// This is also used for a few other weight generation defaults.
+constexpr size_t kNumRandomWeights = 5;
+
+// 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.
+
+template <class W>
+class NaturalLess {
+ public:
+ using Weight = W;
+
+ NaturalLess() {
+ // TODO(kbg): Make this a compile-time static_assert once:
+ // 1) All weight properties are made constexpr for all weight types.
+ // 2) We have a pleasant way to "deregister" this operation for non-path
+ // semirings so an informative error message is produced. The best
+ // solution will probably involve some kind of SFINAE magic.
+ if (!(W::Properties() & kIdempotent)) {
+ FSTERROR() << "NaturalLess: Weight type is not idempotent: " << W::Type();
+ }
+ }
+
+ bool operator()(const W &w1, const W &w2) const {
+ return (Plus(w1, w2) == w1) && w1 != w2;
+ }
+};
+
+// 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 <class Weight>
+Weight Power(Weight w, size_t n) {
+ auto result = Weight::One();
+ for (auto i = 0; i < n; ++i) result = Times(result, w);
+ return result;
+}
+
+// General weight converter: raises error.
+template <class W1, class W2>
+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 <class W>
+struct WeightConvert<W, W> {
+ W operator()(W weight) const { return weight; }
+};
+
+// General random weight generator: raises error.
+template <class W>
+struct WeightGenerate {
+ W operator()() const {
+ FSTERROR() << "WeightGenerate: No random generator for " << W::Type();
+ return W::NoWeight();
+ }
+};
+
+// Helper class for writing textual composite weights.
+class CompositeWeightWriter {
+ public:
+ explicit CompositeWeightWriter(std::ostream &ostrm);
+
+ // Writes open parenthesis to a stream if option selected.
+ void WriteBegin();
+
+ // Writes element to a stream.
+ template <class T>
+ void WriteElement(const T &comp) {
+ if (i_++ > 0) ostrm_ << FLAGS_fst_weight_separator[0];
+ ostrm_ << comp;
+ }
+
+ // Writes close parenthesis to a stream if option selected.
+ void WriteEnd();
+
+ private:
+ std::ostream &ostrm_;
+ int i_; // Element position.
+ CompositeWeightWriter(const CompositeWeightWriter &) = delete;
+ CompositeWeightWriter &operator=(const CompositeWeightWriter &) = delete;
+};
+
+// Helper class for reading textual composite weights. Elements are separated by
+// FLAGS_fst_weight_separator. There must be at least one element per textual
+// representation. FLAGS_fst_weight_parentheses should be set if the composite
+// weights themselves contain composite weights to ensure proper parsing.
+class CompositeWeightReader {
+ public:
+ explicit CompositeWeightReader(std::istream &istrm);
+
+ // 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 <class T>
+ bool ReadElement(T *comp, bool last = false);
+
+ // Finalizes reading.
+ void ReadEnd();
+
+ private:
+ std::istream &istrm_; // Input stream.
+ int c_; // Last character read, or EOF.
+ char separator_;
+ bool has_parens_;
+ int depth_; // Weight parentheses depth.
+ char open_paren_;
+ char close_paren_;
+
+ CompositeWeightReader(const CompositeWeightReader &) = delete;
+ CompositeWeightReader &operator=(const CompositeWeightReader &) = delete;
+};
+
+template <class T>
+inline bool CompositeWeightReader::ReadElement(T *comp, bool last) {
+ string s;
+ while ((c_ != 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 correcty?";
+ 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 correcty?";
+ istrm_.clear(std::ios::badbit);
+ return false;
+ }
+ std::istringstream istrm(s);
+ istrm >> *comp;
+ // Skips separator/close parenthesis.
+ if (c_ != EOF && !std::isspace(c_)) c_ = istrm_.get();
+ // Clears fail bit if just EOF.
+ if (c_ == EOF && !istrm_.bad()) istrm_.clear(std::ios::eofbit);
+ return c_ != EOF && !std::isspace(c_);
+}
+
+} // namespace fst
+
+#endif // FST_LIB_WEIGHT_H_
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS)
+
+lib_LTLIBRARIES = libfst.la
+libfst_la_SOURCES = compat.cc flags.cc fst.cc properties.cc symbol-table.cc util.cc \
+ symbol-table-ops.cc mapped-file.cc weight.cc
+libfst_la_LDFLAGS = -version-info 6:0:0
+libfst_la_LIBADD = $(DL_LIBS)
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/lib
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+libfst_la_DEPENDENCIES = $(am__DEPENDENCIES_1)
+am_libfst_la_OBJECTS = compat.lo flags.lo fst.lo properties.lo \
+ symbol-table.lo util.lo symbol-table-ops.lo mapped-file.lo \
+ weight.lo
+libfst_la_OBJECTS = $(am_libfst_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfst_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(libfst_la_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfst_la_SOURCES)
+DIST_SOURCES = $(libfst_la_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS)
+lib_LTLIBRARIES = libfst.la
+libfst_la_SOURCES = compat.cc flags.cc fst.cc properties.cc symbol-table.cc util.cc \
+ symbol-table-ops.cc mapped-file.cc weight.cc
+
+libfst_la_LDFLAGS = -version-info 6:0:0
+libfst_la_LIBADD = $(DL_LIBS)
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/lib/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/lib/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfst.la: $(libfst_la_OBJECTS) $(libfst_la_DEPENDENCIES) $(EXTRA_libfst_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfst_la_LINK) -rpath $(libdir) $(libfst_la_OBJECTS) $(libfst_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compat.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flags.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mapped-file.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/properties.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/symbol-table-ops.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/symbol-table.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/util.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+ mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \
+ ctags-am distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-libLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// compat.cc
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: riley@google.com (Michael Riley)
+//
+// \file
+// Google compatibility definitions.
+
+#include <cstring>
+#include <fst/compat.h>
+
+using namespace std;
+
+void FailedNewHandler() {
+ cerr << "Memory allocation failed\n";
+ exit(1);
+}
--- /dev/null
+// 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 <fst/compat.h>
+#include <fst/flags.h>
+
+static const char *private_tmpdir = getenv("TMPDIR");
+
+DEFINE_int32(v, 0, "verbosity level");
+DEFINE_bool(help, false, "show usage information");
+DEFINE_bool(helpshort, false, "show brief usage information");
+DEFINE_string(tmpdir, private_tmpdir ? private_tmpdir : "/tmp",
+ "temporary directory");
+
+using namespace std;
+
+static string flag_usage;
+static string prog_src;
+
+void SetFlags(const char *usage, int *argc, char ***argv,
+ bool remove_flags, const char *src) {
+ flag_usage = usage;
+ prog_src = src;
+ int index = 1;
+ for (; index < *argc; ++index) {
+ string argval = (*argv)[index];
+ if (argval[0] != '-' || argval == "-") break;
+ while (argval[0] == '-') argval = argval.substr(1); // Removes initial '-'.
+ string arg = argval;
+ string val = "";
+ // Splits argval (arg=val) into arg and val.
+ auto pos = argval.find("=");
+ if (pos != string::npos) {
+ arg = argval.substr(0, pos);
+ val = argval.substr(pos + 1);
+ }
+ auto bool_register = FlagRegister<bool>::GetRegister();
+ if (bool_register->SetFlag(arg, val))
+ continue;
+ auto string_register = FlagRegister<string>::GetRegister();
+ if (string_register->SetFlag(arg, val))
+ continue;
+ auto int32_register = FlagRegister<int32>::GetRegister();
+ if (int32_register->SetFlag(arg, val))
+ continue;
+ auto int64_register = FlagRegister<int64>::GetRegister();
+ if (int64_register->SetFlag(arg, val))
+ continue;
+ auto double_register = FlagRegister<double>::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<pair<string, string>> &usage_set,
+ const string &src, bool in_src, bool show_file) {
+ string old_file;
+ bool file_out = false;
+ bool usage_out = false;
+ for (const auto &pair : usage_set) {
+ const auto &file = pair.first;
+ const auto &usage = pair.second;
+ bool match = file == src;
+ if ((match && !in_src) || (!match && in_src)) continue;
+ if (file != old_file) {
+ if (show_file) {
+ if (file_out) cout << "\n";
+ cout << "Flags from: " << file << "\n";
+ file_out = true;
+ }
+ old_file = file;
+ }
+ cout << usage << "\n";
+ usage_out = true;
+ }
+ if (usage_out) cout << "\n";
+}
+
+void ShowUsage(bool long_usage) {
+ std::set<pair<string, string>> usage_set;
+ cout << flag_usage << "\n";
+ auto bool_register = FlagRegister<bool>::GetRegister();
+ bool_register->GetUsage(&usage_set);
+ auto string_register = FlagRegister<string>::GetRegister();
+ string_register->GetUsage(&usage_set);
+ auto int32_register = FlagRegister<int32>::GetRegister();
+ int32_register->GetUsage(&usage_set);
+ auto int64_register = FlagRegister<int64>::GetRegister();
+ int64_register->GetUsage(&usage_set);
+ auto double_register = FlagRegister<double>::GetRegister();
+ double_register->GetUsage(&usage_set);
+ if (!prog_src.empty()) {
+ cout << "PROGRAM FLAGS:\n\n";
+ ShowUsageRestrict(usage_set, prog_src, true, false);
+ }
+ if (!long_usage) return;
+ if (!prog_src.empty()) cout << "LIBRARY FLAGS:\n\n";
+ ShowUsageRestrict(usage_set, prog_src, false, true);
+}
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// FST definitions.
+
+#include <fst/fst.h>
+
+#include <sstream>
+
+// Include these for registration.
+#include <fst/compact-fst.h>
+#include <fst/const-fst.h>
+#include <fst/edit-fst.h>
+#include <fst/matcher-fst.h>
+#include <fst/vector-fst.h>
+
+// 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 {
+
+// Registers VectorFst, ConstFst and EditFst for common arcs types.
+REGISTER_FST(VectorFst, StdArc);
+REGISTER_FST(VectorFst, LogArc);
+REGISTER_FST(VectorFst, Log64Arc);
+REGISTER_FST(ConstFst, StdArc);
+REGISTER_FST(ConstFst, LogArc);
+REGISTER_FST(ConstFst, Log64Arc);
+REGISTER_FST(EditFst, StdArc);
+REGISTER_FST(EditFst, LogArc);
+REGISTER_FST(EditFst, Log64Arc);
+
+// Register CompactFst for common arcs with the default (uint32) size type
+REGISTER_FST(CompactStringFst, StdArc);
+REGISTER_FST(CompactStringFst, LogArc);
+REGISTER_FST(CompactWeightedStringFst, StdArc);
+REGISTER_FST(CompactWeightedStringFst, LogArc);
+REGISTER_FST(CompactAcceptorFst, StdArc);
+REGISTER_FST(CompactAcceptorFst, LogArc);
+REGISTER_FST(CompactUnweightedFst, StdArc);
+REGISTER_FST(CompactUnweightedFst, LogArc);
+REGISTER_FST(CompactUnweightedAcceptorFst, StdArc);
+REGISTER_FST(CompactUnweightedAcceptorFst, LogArc);
+
+// FST type definitions for lookahead FSTs.
+const char arc_lookahead_fst_type[] = "arc_lookahead";
+const char ilabel_lookahead_fst_type[] = "ilabel_lookahead";
+const char olabel_lookahead_fst_type[] = "olabel_lookahead";
+
+// Identifies stream data as an FST (and its endianity).
+constexpr int32 kFstMagicNumber = 2125659606;
+
+// Checks for FST magic number in stream, to indicate caller function that the
+// stream content is an FST header.
+bool IsFstHeader(std::istream &strm, const string &source) {
+ int64 pos = strm.tellg();
+ bool match = true;
+ int32 magic_number = 0;
+ ReadType(strm, &magic_number);
+ if (magic_number != kFstMagicNumber) {
+ match = false;
+ }
+ strm.seekg(pos);
+ return match;
+}
+
+// Checks FST magic number and reads in the header; if rewind = true,
+// the stream is repositioned before call if possible.
+bool FstHeader::Read(std::istream &strm, const string &source, bool rewind) {
+ int64 pos = 0;
+ if (rewind) pos = strm.tellg();
+ int32 magic_number = 0;
+ ReadType(strm, &magic_number);
+ if (magic_number != kFstMagicNumber) {
+ LOG(ERROR) << "FstHeader::Read: Bad FST header: " << source;
+ if (rewind) strm.seekg(pos);
+ return false;
+ }
+ ReadType(strm, &fsttype_);
+ ReadType(strm, &arctype_);
+ ReadType(strm, &version_);
+ ReadType(strm, &flags_);
+ ReadType(strm, &properties_);
+ ReadType(strm, &start_);
+ ReadType(strm, &numstates_);
+ ReadType(strm, &numarcs_);
+ if (!strm) {
+ LOG(ERROR) << "FstHeader::Read: Read failed: " << source;
+ return false;
+ }
+ if (rewind) strm.seekg(pos);
+ return true;
+}
+
+// Writes FST magic number and FST header.
+bool FstHeader::Write(std::ostream &strm, const string &source) const {
+ WriteType(strm, kFstMagicNumber);
+ WriteType(strm, fsttype_);
+ WriteType(strm, arctype_);
+ WriteType(strm, version_);
+ WriteType(strm, flags_);
+ WriteType(strm, properties_);
+ WriteType(strm, start_);
+ WriteType(strm, numstates_);
+ WriteType(strm, numarcs_);
+ return true;
+}
+
+string FstHeader::DebugString() const {
+ std::ostringstream ostrm;
+ ostrm << "fsttype: \"" << fsttype_ << "\" arctype: \"" << arctype_
+ << "\" version: \"" << version_ << "\" flags: \"" << flags_
+ << "\" properties: \"" << properties_ << "\" start: \"" << start_
+ << "\" numstates: \"" << numstates_ << "\" numarcs: \"" << numarcs_
+ << "\"";
+ return ostrm.str();
+}
+
+FstReadOptions::FstReadOptions(const string &source, const FstHeader *header,
+ const SymbolTable *isymbols,
+ const SymbolTable *osymbols)
+ : source(source),
+ header(header),
+ isymbols(isymbols),
+ osymbols(osymbols),
+ read_isymbols(true),
+ read_osymbols(true) {
+ mode = ReadMode(FLAGS_fst_read_mode);
+}
+
+FstReadOptions::FstReadOptions(const string &source,
+ const SymbolTable *isymbols,
+ const SymbolTable *osymbols)
+ : source(source),
+ header(nullptr),
+ isymbols(isymbols),
+ osymbols(osymbols),
+ read_isymbols(true),
+ read_osymbols(true) {
+ mode = ReadMode(FLAGS_fst_read_mode);
+}
+
+FstReadOptions::FileReadMode FstReadOptions::ReadMode(const string &mode) {
+ if (mode == "read") return READ;
+ if (mode == "map") return MAP;
+ LOG(ERROR) << "Unknown file read mode " << mode;
+ return READ;
+}
+
+string FstReadOptions::DebugString() const {
+ std::ostringstream ostrm;
+ ostrm << "source: \"" << source << "\" mode: \""
+ << (mode == READ ? "READ" : "MAP") << "\" read_isymbols: \""
+ << (read_isymbols ? "true" : "false") << "\" read_osymbols: \""
+ << (read_osymbols ? "true" : "false") << "\" header: \""
+ << (header ? "set" : "null") << "\" isymbols: \""
+ << (isymbols ? "set" : "null") << "\" osymbols: \""
+ << (osymbols ? "set" : "null") << "\"";
+ return ostrm.str();
+}
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+
+#include <fst/mapped-file.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <ios>
+#include <memory>
+
+namespace fst {
+
+MappedFile::MappedFile(const MemoryRegion ®ion) : region_(region) {}
+
+MappedFile::~MappedFile() {
+ if (region_.size != 0) {
+ if (region_.mmap) {
+ VLOG(1) << "munmap'ed " << region_.size << " bytes at " << region_.mmap;
+ if (munmap(region_.mmap, region_.size) != 0) {
+ LOG(ERROR) << "Failed to unmap region: " << strerror(errno);
+ }
+ } else {
+ if (region_.data) {
+ operator delete(static_cast<char *>(region_.data) - region_.offset);
+ }
+ }
+ }
+}
+
+MappedFile *MappedFile::Map(std::istream *istrm, bool memorymap,
+ const string &source, size_t size) {
+ const auto spos = istrm->tellg();
+ VLOG(1) << "memorymap: " << (memorymap ? "true" : "false") << " source: \""
+ << source << "\""
+ << " size: " << size << " offset: " << spos;
+ if (memorymap && spos >= 0 && spos % kArchAlignment == 0) {
+ const size_t pos = spos;
+ int fd = open(source.c_str(), O_RDONLY);
+ if (fd != -1) {
+ const int pagesize = sysconf(_SC_PAGESIZE);
+ const off_t offset = pos % pagesize;
+ const off_t upsize = size + offset;
+ void *map =
+ mmap(nullptr, upsize, PROT_READ, MAP_SHARED, fd, pos - offset);
+ auto *data = reinterpret_cast<char *>(map);
+ if (close(fd) == 0 && map != MAP_FAILED) {
+ MemoryRegion region;
+ region.mmap = map;
+ region.size = upsize;
+ region.data = reinterpret_cast<void *>(data + offset);
+ region.offset = offset;
+ std::unique_ptr<MappedFile> mmf(new MappedFile(region));
+ istrm->seekg(pos + size, std::ios::beg);
+ if (istrm) {
+ VLOG(1) << "mmap'ed region of " << size << " at offset " << pos
+ << " from " << source << " to addr " << map;
+ return mmf.release();
+ }
+ } else {
+ LOG(INFO) << "Mapping of file failed: " << strerror(errno);
+ }
+ }
+ }
+ // If all else fails, reads from the file into the allocated buffer.
+ if (memorymap) {
+ LOG(WARNING) << "File mapping at offset " << spos << " of file " << source
+ << " could not be honored, reading instead";
+ }
+ // Reads the file into the buffer in chunks not larger than kMaxReadChunk.
+ std::unique_ptr<MappedFile> mf(Allocate(size));
+ auto *buffer = reinterpret_cast<char *>(mf->mutable_data());
+ while (size > 0) {
+ const auto next_size = std::min(size, kMaxReadChunk);
+ const auto current_pos = istrm->tellg();
+ if (!istrm->read(buffer, next_size)) {
+ LOG(ERROR) << "Failed to read " << next_size << " bytes at offset "
+ << current_pos << "from \"" << source << "\"";
+ return nullptr;
+ }
+ size -= next_size;
+ buffer += next_size;
+ VLOG(2) << "Read " << next_size << " bytes. " << size << " remaining";
+ }
+ return mf.release();
+}
+
+MappedFile *MappedFile::Allocate(size_t size, int align) {
+ MemoryRegion region;
+ region.data = nullptr;
+ region.offset = 0;
+ if (size > 0) {
+ char *buffer = static_cast<char *>(operator new(size + align));
+ size_t address = reinterpret_cast<size_t>(buffer);
+ region.offset = kArchAlignment - (address % align);
+ region.data = buffer + region.offset;
+ }
+ region.mmap = nullptr;
+ region.size = size;
+ return new MappedFile(region);
+}
+
+MappedFile *MappedFile::Borrow(void *data) {
+ MemoryRegion region;
+ region.data = data;
+ region.mmap = data;
+ region.size = 0;
+ region.offset = 0;
+ return new MappedFile(region);
+}
+
+constexpr int MappedFile::kArchAlignment;
+
+constexpr size_t MappedFile::kMaxReadChunk;
+
+} // namespace fst
--- /dev/null
+// 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 <fst/properties.h>
+
+#include <stddef.h>
+#include <vector>
+
+namespace fst {
+
+// These functions determine the properties associated with the FST result of
+// various finite-state operations. The property arguments correspond to the
+// operation's FST arguments. The properties returned assume the operation
+// modifies its first argument. Bitwise-and this result with kCopyProperties for
+// the case when a new (possibly delayed) FST is instead constructed.
+
+// Properties for a concatenatively-closed FST.
+uint64 ClosureProperties(uint64 inprops, bool star, bool delayed) {
+ auto outprops = (kError | kAcceptor | kUnweighted | kAccessible) & inprops;
+ if (inprops & kUnweighted) outprops |= kUnweightedCycles;
+ if (!delayed) {
+ outprops |=
+ (kExpanded | kMutable | kCoAccessible | kNotTopSorted | kNotString) &
+ inprops;
+ }
+ if (!delayed || inprops & kAccessible) {
+ outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic |
+ kNotILabelSorted | kNotOLabelSorted | kWeighted |
+ kWeightedCycles | kNotAccessible | kNotCoAccessible) & inprops;
+ if ((inprops & kWeighted) && (inprops & kAccessible) &&
+ (inprops & kCoAccessible)) {
+ outprops |= kWeightedCycles;
+ }
+ }
+ return outprops;
+}
+
+// Properties for a complemented FST.
+uint64 ComplementProperties(uint64 inprops) {
+ auto outprops = kAcceptor | kUnweighted | kUnweightedCycles | kNoEpsilons |
+ kNoIEpsilons | kNoOEpsilons | kIDeterministic |
+ kODeterministic | kAccessible;
+ outprops |=
+ (kError | kILabelSorted | kOLabelSorted | kInitialCyclic) & inprops;
+ if (inprops & kAccessible) {
+ outprops |= kNotILabelSorted | kNotOLabelSorted | kCyclic;
+ }
+ return outprops;
+}
+
+// Properties for a composed FST.
+uint64 ComposeProperties(uint64 inprops1, uint64 inprops2) {
+ auto outprops = kError & (inprops1 | inprops2);
+ if (inprops1 & kAcceptor && inprops2 & kAcceptor) {
+ outprops |= kAcceptor | kAccessible;
+ outprops |= (kNoEpsilons | kNoIEpsilons | kNoOEpsilons | kAcyclic |
+ kInitialAcyclic) &
+ inprops1 & inprops2;
+ if (kNoIEpsilons & inprops1 & inprops2) {
+ outprops |= (kIDeterministic | kODeterministic) & inprops1 & inprops2;
+ }
+ } else {
+ outprops |= kAccessible;
+ outprops |= (kAcceptor | kNoIEpsilons | kAcyclic | kInitialAcyclic) &
+ inprops1 & inprops2;
+ if (kNoIEpsilons & inprops1 & inprops2) {
+ outprops |= kIDeterministic & inprops1 & inprops2;
+ }
+ }
+ return outprops;
+}
+
+// Properties for a concatenated FST.
+uint64 ConcatProperties(uint64 inprops1, uint64 inprops2, bool delayed) {
+ auto outprops = (kAcceptor | kUnweighted | kUnweightedCycles | kAcyclic) &
+ inprops1 & inprops2;
+ outprops |= kError & (inprops1 | inprops2);
+ const bool empty1 = delayed; // Can the first FST be the empty machine?
+ const bool empty2 = delayed; // Can the second FST be the empty machine?
+ if (!delayed) {
+ outprops |= (kExpanded | kMutable | kNotTopSorted | kNotString) & inprops1;
+ outprops |= (kNotTopSorted | kNotString) & inprops2;
+ }
+ if (!empty1) outprops |= (kInitialAcyclic | kInitialCyclic) & inprops1;
+ if (!delayed || inprops1 & kAccessible) {
+ outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic |
+ kEpsilons | kIEpsilons | kOEpsilons | kNotILabelSorted |
+ kNotOLabelSorted | kWeighted | kWeightedCycles | kCyclic |
+ kNotAccessible | kNotCoAccessible) &
+ inprops1;
+ }
+ if ((inprops1 & (kAccessible | kCoAccessible)) ==
+ (kAccessible | kCoAccessible) &&
+ !empty1) {
+ outprops |= kAccessible & inprops2;
+ if (!empty2) outprops |= kCoAccessible & inprops2;
+ if (!delayed || inprops2 & kAccessible) {
+ outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic |
+ kEpsilons | kIEpsilons | kOEpsilons | kNotILabelSorted |
+ kNotOLabelSorted | kWeighted | kWeightedCycles | kCyclic |
+ kNotAccessible | kNotCoAccessible) &
+ inprops2;
+ }
+ }
+ return outprops;
+}
+
+// Properties for a determinized FST.
+uint64 DeterminizeProperties(uint64 inprops, bool has_subsequential_label,
+ bool distinct_psubsequential_labels) {
+ auto outprops = kAccessible;
+ if ((kAcceptor & inprops) ||
+ ((kNoIEpsilons & inprops) && distinct_psubsequential_labels) ||
+ (has_subsequential_label && distinct_psubsequential_labels)) {
+ outprops |= kIDeterministic;
+ }
+ outprops |= (kError | kAcceptor | kAcyclic | kInitialAcyclic | kCoAccessible |
+ kString) &
+ inprops;
+ if ((inprops & kNoIEpsilons) && distinct_psubsequential_labels) {
+ outprops |= kNoEpsilons & inprops;
+ }
+ if (inprops & kAccessible) {
+ outprops |= (kIEpsilons | kOEpsilons | kCyclic) & inprops;
+ }
+ if (inprops & kAcceptor) outprops |= (kNoIEpsilons | kNoOEpsilons) & inprops;
+ if ((inprops & kNoIEpsilons) && has_subsequential_label) {
+ outprops |= kNoIEpsilons;
+ }
+ return outprops;
+}
+
+// Properties for factored weight FST.
+uint64 FactorWeightProperties(uint64 inprops) {
+ auto outprops = (kExpanded | kMutable | kError | kAcceptor | kAcyclic |
+ kAccessible | kCoAccessible) &
+ inprops;
+ if (inprops & kAccessible) {
+ outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic |
+ kEpsilons | kIEpsilons | kOEpsilons | kCyclic |
+ kNotILabelSorted | kNotOLabelSorted) &
+ inprops;
+ }
+ return outprops;
+}
+
+// Properties for an inverted FST.
+uint64 InvertProperties(uint64 inprops) {
+ auto outprops = (kExpanded | kMutable | kError | kAcceptor | kNotAcceptor |
+ kEpsilons | kNoEpsilons | kWeighted | kUnweighted |
+ kWeightedCycles | kUnweightedCycles | kCyclic | kAcyclic |
+ kInitialCyclic | kInitialAcyclic | kTopSorted |
+ kNotTopSorted | kAccessible | kNotAccessible |
+ kCoAccessible | kNotCoAccessible | kString | kNotString) &
+ inprops;
+ if (kIDeterministic & inprops) outprops |= kODeterministic;
+ if (kNonIDeterministic & inprops) outprops |= kNonODeterministic;
+ if (kODeterministic & inprops) outprops |= kIDeterministic;
+ if (kNonODeterministic & inprops) outprops |= kNonIDeterministic;
+
+ if (kIEpsilons & inprops) outprops |= kOEpsilons;
+ if (kNoIEpsilons & inprops) outprops |= kNoOEpsilons;
+ if (kOEpsilons & inprops) outprops |= kIEpsilons;
+ if (kNoOEpsilons & inprops) outprops |= kNoIEpsilons;
+
+ if (kILabelSorted & inprops) outprops |= kOLabelSorted;
+ if (kNotILabelSorted & inprops) outprops |= kNotOLabelSorted;
+ if (kOLabelSorted & inprops) outprops |= kILabelSorted;
+ if (kNotOLabelSorted & inprops) outprops |= kNotILabelSorted;
+ return outprops;
+}
+
+// Properties for a projected FST.
+uint64 ProjectProperties(uint64 inprops, bool project_input) {
+ auto outprops = kAcceptor;
+ outprops |= (kExpanded | kMutable | kError | kWeighted | kUnweighted |
+ kWeightedCycles | kUnweightedCycles |
+ kCyclic | kAcyclic | kInitialCyclic | kInitialAcyclic |
+ kTopSorted | kNotTopSorted | kAccessible | kNotAccessible |
+ kCoAccessible | kNotCoAccessible | kString | kNotString) &
+ inprops;
+ if (project_input) {
+ outprops |= (kIDeterministic | kNonIDeterministic | kIEpsilons |
+ kNoIEpsilons | kILabelSorted | kNotILabelSorted) &
+ inprops;
+
+ if (kIDeterministic & inprops) outprops |= kODeterministic;
+ if (kNonIDeterministic & inprops) outprops |= kNonODeterministic;
+
+ if (kIEpsilons & inprops) outprops |= kOEpsilons | kEpsilons;
+ if (kNoIEpsilons & inprops) outprops |= kNoOEpsilons | kNoEpsilons;
+
+ if (kILabelSorted & inprops) outprops |= kOLabelSorted;
+ if (kNotILabelSorted & inprops) outprops |= kNotOLabelSorted;
+ } else {
+ outprops |= (kODeterministic | kNonODeterministic | kOEpsilons |
+ kNoOEpsilons | kOLabelSorted | kNotOLabelSorted) &
+ inprops;
+
+ if (kODeterministic & inprops) outprops |= kIDeterministic;
+ if (kNonODeterministic & inprops) outprops |= kNonIDeterministic;
+
+ if (kOEpsilons & inprops) outprops |= kIEpsilons | kEpsilons;
+ if (kNoOEpsilons & inprops) outprops |= kNoIEpsilons | kNoEpsilons;
+
+ if (kOLabelSorted & inprops) outprops |= kILabelSorted;
+ if (kNotOLabelSorted & inprops) outprops |= kNotILabelSorted;
+ }
+ return outprops;
+}
+
+// Properties for a randgen FST.
+uint64 RandGenProperties(uint64 inprops, bool weighted) {
+ auto outprops = kAcyclic | kInitialAcyclic | kAccessible | kUnweightedCycles;
+ outprops |= inprops & kError;
+ if (weighted) {
+ outprops |= kTopSorted;
+ outprops |=
+ (kAcceptor | kNoEpsilons | kNoIEpsilons | kNoOEpsilons |
+ kIDeterministic | kODeterministic | kILabelSorted | kOLabelSorted) &
+ inprops;
+ } else {
+ outprops |= kUnweighted;
+ outprops |= (kAcceptor | kILabelSorted | kOLabelSorted) & inprops;
+ }
+ return outprops;
+}
+
+// Properties for a replace FST.
+uint64 ReplaceProperties(const std::vector<uint64>& inprops, ssize_t root,
+ bool epsilon_on_call, bool epsilon_on_return,
+ bool out_epsilon_on_call, bool out_epsilon_on_return,
+ bool replace_transducer, bool no_empty_fsts,
+ bool all_ilabel_sorted, bool all_olabel_sorted,
+ bool all_negative_or_dense) {
+ if (inprops.empty()) return kNullProperties;
+ uint64 outprops = 0;
+ for (auto inprop : inprops) outprops |= kError & inprop;
+ uint64 access_props = no_empty_fsts ? kAccessible | kCoAccessible : 0;
+ for (auto inprop : inprops) {
+ access_props &= (inprop & (kAccessible | kCoAccessible));
+ }
+ if (access_props == (kAccessible | kCoAccessible)) {
+ outprops |= access_props;
+ if (inprops[root] & kInitialCyclic) outprops |= kInitialCyclic;
+ uint64 props = 0;
+ bool string = true;
+ for (auto inprop : inprops) {
+ if (replace_transducer) props |= kNotAcceptor & inprop;
+ props |= (kNonIDeterministic | kNonODeterministic | kEpsilons |
+ kIEpsilons | kOEpsilons | kWeighted | kWeightedCycles |
+ kCyclic | kNotTopSorted | kNotString) & inprop;
+ if (!(inprop & kString)) string = false;
+ }
+ outprops |= props;
+ if (string) outprops |= kString;
+ }
+ bool acceptor = !replace_transducer;
+ bool ideterministic = !epsilon_on_call && epsilon_on_return;
+ bool no_iepsilons = !epsilon_on_call && !epsilon_on_return;
+ bool acyclic = true;
+ bool unweighted = true;
+ for (size_t i = 0; i < inprops.size(); ++i) {
+ if (!(inprops[i] & kAcceptor)) acceptor = false;
+ if (!(inprops[i] & kIDeterministic)) ideterministic = false;
+ if (!(inprops[i] & kNoIEpsilons)) no_iepsilons = false;
+ if (!(inprops[i] & kAcyclic)) acyclic = false;
+ if (!(inprops[i] & kUnweighted)) unweighted = false;
+ if (i != root && !(inprops[i] & kNoIEpsilons)) ideterministic = false;
+ }
+ if (acceptor) outprops |= kAcceptor;
+ if (ideterministic) outprops |= kIDeterministic;
+ if (no_iepsilons) outprops |= kNoIEpsilons;
+ if (acyclic) outprops |= kAcyclic;
+ if (unweighted) outprops |= kUnweighted;
+ if (inprops[root] & kInitialAcyclic) outprops |= kInitialAcyclic;
+ // We assume that all terminals are positive. The resulting ReplaceFst is
+ // known to be kILabelSorted when: (1) all sub-FSTs are kILabelSorted, (2) the
+ // input label of the return arc is epsilon, and (3) one of the 3 following
+ // conditions is satisfied:
+ //
+ // 1. the input label of the call arc is not epsilon
+ // 2. all non-terminals are negative, or
+ // 3. all non-terninals are positive and form a dense range containing 1.
+ if (all_ilabel_sorted && epsilon_on_return &&
+ (!epsilon_on_call || all_negative_or_dense)) {
+ outprops |= kILabelSorted;
+ }
+ // Similarly, the resulting ReplaceFst is known to be kOLabelSorted when: (1)
+ // all sub-FSTs are kOLabelSorted, (2) the output label of the return arc is
+ // epsilon, and (3) one of the 3 following conditions is satisfied:
+ //
+ // 1. the output label of the call arc is not epsilon
+ // 2. all non-terminals are negative, or
+ // 3. all non-terninals are positive and form a dense range containing 1.
+ if (all_olabel_sorted && out_epsilon_on_return &&
+ (!out_epsilon_on_call || all_negative_or_dense)) {
+ outprops |= kOLabelSorted;
+ }
+ return outprops;
+}
+
+// Properties for a relabeled FST.
+uint64 RelabelProperties(uint64 inprops) {
+ static constexpr auto outprops =
+ kExpanded | kMutable | kError | kWeighted | kUnweighted |
+ kWeightedCycles | kUnweightedCycles | kCyclic | kAcyclic |
+ kInitialCyclic | kInitialAcyclic | kTopSorted | kNotTopSorted |
+ kAccessible | kNotAccessible | kCoAccessible | kNotCoAccessible |
+ kString | kNotString;
+ return outprops & inprops;
+}
+
+// Properties for a reversed FST (the superinitial state limits this set).
+uint64 ReverseProperties(uint64 inprops, bool has_superinitial) {
+ auto outprops = (kExpanded | kMutable | kError | kAcceptor | kNotAcceptor |
+ kEpsilons | kIEpsilons | kOEpsilons | kUnweighted | kCyclic |
+ kAcyclic | kWeightedCycles | kUnweightedCycles) &
+ inprops;
+ if (has_superinitial) outprops |= kWeighted & inprops;
+ return outprops;
+}
+
+// Properties for re-weighted FST.
+uint64 ReweightProperties(uint64 inprops) {
+ auto outprops = inprops & kWeightInvariantProperties;
+ outprops = outprops & ~kCoAccessible;
+ return outprops;
+}
+
+// Properties for an epsilon-removed FST.
+uint64 RmEpsilonProperties(uint64 inprops, bool delayed) {
+ auto outprops = kNoEpsilons;
+ outprops |= (kError | kAcceptor | kAcyclic | kInitialAcyclic) & inprops;
+ if (inprops & kAcceptor) outprops |= kNoIEpsilons | kNoOEpsilons;
+ if (!delayed) {
+ outprops |= kExpanded | kMutable;
+ outprops |= kTopSorted & inprops;
+ }
+ if (!delayed || inprops & kAccessible) outprops |= kNotAcceptor & inprops;
+ return outprops;
+}
+
+// Properties for shortest path. This function computes how the properties of
+// the output of shortest path need to be updated, given that 'props' is already
+// known.
+uint64 ShortestPathProperties(uint64 props, bool tree) {
+ auto outprops =
+ props | kAcyclic | kInitialAcyclic | kAccessible | kUnweightedCycles;
+ if (!tree) outprops |= kCoAccessible;
+ return outprops;
+}
+
+// Properties for a synchronized FST.
+uint64 SynchronizeProperties(uint64 inprops) {
+ auto outprops = (kError | kAcceptor | kAcyclic | kAccessible | kCoAccessible |
+ kUnweighted | kUnweightedCycles) &
+ inprops;
+ if (inprops & kAccessible) {
+ outprops |= (kCyclic | kNotCoAccessible | kWeighted | kWeightedCycles) &
+ inprops;
+ }
+ return outprops;
+}
+
+// Properties for a unioned FST.
+uint64 UnionProperties(uint64 inprops1, uint64 inprops2, bool delayed) {
+ auto outprops =
+ (kAcceptor | kUnweighted | kUnweightedCycles | kAcyclic | kAccessible) &
+ inprops1 & inprops2;
+ outprops |= kError & (inprops1 | inprops2);
+ outprops |= kInitialAcyclic;
+ bool empty1 = delayed; // Can the first FST be the empty machine?
+ bool empty2 = delayed; // Can the second FST be the empty machine?
+ if (!delayed) {
+ outprops |= (kExpanded | kMutable | kNotTopSorted) & inprops1;
+ outprops |= kNotTopSorted & inprops2;
+ }
+ if (!empty1 && !empty2) {
+ outprops |= kEpsilons | kIEpsilons | kOEpsilons;
+ outprops |= kCoAccessible & inprops1 & inprops2;
+ }
+ // Note kNotCoAccessible does not hold because of kInitialAcyclic option.
+ if (!delayed || inprops1 & kAccessible) {
+ outprops |=
+ (kNotAcceptor | kNonIDeterministic | kNonODeterministic | kEpsilons |
+ kIEpsilons | kOEpsilons | kNotILabelSorted | kNotOLabelSorted |
+ kWeighted | kWeightedCycles | kCyclic | kNotAccessible) &
+ inprops1;
+ }
+ if (!delayed || inprops2 & kAccessible) {
+ outprops |= (kNotAcceptor | kNonIDeterministic | kNonODeterministic |
+ kEpsilons | kIEpsilons | kOEpsilons | kNotILabelSorted |
+ kNotOLabelSorted | kWeighted | kWeightedCycles | kCyclic |
+ kNotAccessible | kNotCoAccessible) &
+ inprops2;
+ }
+ return outprops;
+}
+
+// Property string names (indexed by bit position).
+const char* PropertyNames[] = {
+ // Binary.
+ "expanded", "mutable", "error", "", "", "", "", "", "", "", "", "", "", "",
+ "", "",
+ // Ternary.
+ "acceptor", "not acceptor", "input deterministic",
+ "non input deterministic", "output deterministic",
+ "non output deterministic", "input/output epsilons",
+ "no input/output epsilons", "input epsilons", "no input epsilons",
+ "output epsilons", "no output epsilons", "input label sorted",
+ "not input label sorted", "output label sorted", "not output label sorted",
+ "weighted", "unweighted", "cyclic", "acyclic", "cyclic at initial state",
+ "acyclic at initial state", "top sorted", "not top sorted", "accessible",
+ "not accessible", "coaccessible", "not coaccessible", "string",
+ "not string", "weighted cycles", "unweighted cycles"};
+
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+
+#include <fst/symbol-table-ops.h>
+
+#include <string>
+
+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<SymbolTable> merged(
+ new SymbolTable("merge_" + left.Name() + "_" + right.Name()));
+ // Copies everything from the left symbol table.
+ bool left_has_all = true;
+ bool right_has_all = true;
+ bool relabel = false;
+ for (SymbolTableIterator liter(left); !liter.Done(); liter.Next()) {
+ merged->AddSymbol(liter.Symbol(), liter.Value());
+ if (right_has_all) {
+ int64 key = right.Find(liter.Symbol());
+ if (key == -1) {
+ right_has_all = false;
+ } else if (!relabel && key != liter.Value()) {
+ relabel = true;
+ }
+ }
+ }
+ if (right_has_all) {
+ if (right_relabel_output) *right_relabel_output = relabel;
+ return right.Copy();
+ }
+ // add all symbols we can from right symbol table
+ std::vector<string> conflicts;
+ for (SymbolTableIterator riter(right); !riter.Done(); riter.Next()) {
+ int64 key = merged->Find(riter.Symbol());
+ if (key != -1) {
+ // Symbol already exists, maybe with different value
+ if (key != riter.Value()) relabel = true;
+ continue;
+ }
+ // Symbol doesn't exist from left
+ left_has_all = false;
+ if (!merged->Find(riter.Value()).empty()) {
+ // we can't add this where we want to, add it later, in order
+ conflicts.push_back(riter.Symbol());
+ continue;
+ }
+ // there is a hole and we can add this symbol with its id
+ merged->AddSymbol(riter.Symbol(), riter.Value());
+ }
+ if (right_relabel_output) *right_relabel_output = relabel;
+ if (left_has_all) return left.Copy();
+ // Add all symbols that conflicted, in order
+ for (const auto &conflict : conflicts) merged->AddSymbol(conflict);
+ return merged.release();
+}
+
+SymbolTable *CompactSymbolTable(const SymbolTable &syms) {
+ std::map<int64, string> sorted;
+ SymbolTableIterator stiter(syms);
+ for (; !stiter.Done(); stiter.Next()) {
+ sorted[stiter.Value()] = stiter.Symbol();
+ }
+ auto *compact = new SymbolTable(syms.Name() + "_compact");
+ int64 newkey = 0;
+ for (const auto &kv : sorted) compact->AddSymbol(kv.second, newkey++);
+ return compact;
+}
+
+SymbolTable *FstReadSymbols(const string &filename, bool input_symbols) {
+ std::ifstream in(filename.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ if (!in) {
+ LOG(ERROR) << "FstReadSymbols: Can't open file " << filename;
+ return nullptr;
+ }
+ FstHeader hdr;
+ if (!hdr.Read(in, filename)) {
+ LOG(ERROR) << "FstReadSymbols: Couldn't read header from " << filename;
+ return nullptr;
+ }
+ if (hdr.GetFlags() & FstHeader::HAS_ISYMBOLS) {
+ std::unique_ptr<SymbolTable> isymbols(SymbolTable::Read(in, filename));
+ if (isymbols == nullptr) {
+ LOG(ERROR) << "FstReadSymbols: Couldn't read input symbols from "
+ << filename;
+ return nullptr;
+ }
+ if (input_symbols) return isymbols.release();
+ }
+ if (hdr.GetFlags() & FstHeader::HAS_OSYMBOLS) {
+ std::unique_ptr<SymbolTable> osymbols(SymbolTable::Read(in, filename));
+ if (osymbols == nullptr) {
+ LOG(ERROR) << "FstReadSymbols: Couldn't read output symbols from "
+ << filename;
+ return nullptr;
+ }
+ if (!input_symbols) return osymbols.release();
+ }
+ LOG(ERROR) << "FstReadSymbols: The file " << filename
+ << " doesn't contain the requested symbols";
+ return nullptr;
+}
+
+bool AddAuxiliarySymbols(const string &prefix, int64 start_label,
+ int64 nlabels, SymbolTable *syms) {
+ for (auto 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
--- /dev/null
+// 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 <fst/symbol-table.h>
+
+#include <fstream>
+#include <fst/util.h>
+
+DEFINE_bool(fst_compat_symbols, true,
+ "Require symbol tables to match when appropriate");
+DEFINE_string(fst_field_separator, "\t ",
+ "Set of characters used as a separator between printed fields");
+
+namespace fst {
+
+// Maximum line length in textual symbols file.
+static constexpr int kLineLen = 8096;
+
+// Identifies stream data as a symbol table (and its endianity).
+static constexpr int32 kSymbolTableMagicNumber = 2125658996;
+
+SymbolTableTextOptions::SymbolTableTextOptions(bool allow_negative_labels)
+ : allow_negative_labels(allow_negative_labels),
+ fst_field_separator(FLAGS_fst_field_separator) {}
+
+namespace internal {
+
+SymbolTableImpl *SymbolTableImpl::ReadText(std::istream &strm,
+ const string &filename,
+ const SymbolTableTextOptions &opts) {
+ std::unique_ptr<SymbolTableImpl> impl(new SymbolTableImpl(filename));
+ int64 nline = 0;
+ char line[kLineLen];
+ while (!strm.getline(line, kLineLen).fail()) {
+ ++nline;
+ std::vector<char *> col;
+ auto separator = opts.fst_field_separator + "\n";
+ SplitToVector(line, separator.c_str(), &col, true);
+ if (col.empty()) continue; // Empty line.
+ if (col.size() != 2) {
+ LOG(ERROR) << "SymbolTable::ReadText: Bad number of columns ("
+ << col.size() << "), "
+ << "file = " << filename << ", line = " << nline << ":<"
+ << line << ">";
+ return nullptr;
+ }
+ const char *symbol = col[0];
+ const char *value = col[1];
+ char *p;
+ const auto key = strtoll(value, &p, 10);
+ if (p < value + strlen(value) ||
+ (!opts.allow_negative_labels && key < 0) || key == -1) {
+ LOG(ERROR) << "SymbolTable::ReadText: Bad non-negative integer \""
+ << value << "\", "
+ << "file = " << filename << ", line = " << nline;
+ return nullptr;
+ }
+ impl->AddSymbol(symbol, key);
+ }
+ return impl.release();
+}
+
+void SymbolTableImpl::MaybeRecomputeCheckSum() const {
+ {
+ ReaderMutexLock check_sum_lock(&check_sum_mutex_);
+ if (check_sum_finalized_) return;
+ }
+ // We'll acquire an exclusive lock to recompute the checksums.
+ MutexLock check_sum_lock(&check_sum_mutex_);
+ if (check_sum_finalized_) { // Another thread (coming in around the same time
+ return; // might have done it already). So we recheck.
+ }
+ // Calculates the original label-agnostic checksum.
+ CheckSummer check_sum;
+ for (size_t i = 0; i < symbols_.size(); ++i) {
+ const auto &symbol = symbols_.GetSymbol(i);
+ check_sum.Update(symbol.data(), symbol.size());
+ check_sum.Update("", 1);
+ }
+ check_sum_string_ = check_sum.Digest();
+ // Calculates the safer, label-dependent checksum.
+ CheckSummer labeled_check_sum;
+ for (int64 i = 0; i < dense_key_limit_; ++i) {
+ std::ostringstream line;
+ line << symbols_.GetSymbol(i) << '\t' << i;
+ labeled_check_sum.Update(line.str().data(), line.str().size());
+ }
+ using citer = map<int64, int64>::const_iterator;
+ for (citer it = key_map_.begin(); it != key_map_.end(); ++it) {
+ // TODO(tombagby, 2013-11-22) This line maintains a bug that ignores
+ // negative labels in the checksum that too many tests rely on.
+ if (it->first < dense_key_limit_) continue;
+ std::ostringstream line;
+ line << symbols_.GetSymbol(it->second) << '\t' << it->first;
+ labeled_check_sum.Update(line.str().data(), line.str().size());
+ }
+ labeled_check_sum_string_ = labeled_check_sum.Digest();
+ check_sum_finalized_ = true;
+}
+
+int64 SymbolTableImpl::AddSymbol(const string &symbol, int64 key) {
+ if (key == -1) return key;
+ const std::pair<int64, bool> &insert_key = symbols_.InsertOrFind(symbol);
+ if (!insert_key.second) {
+ auto key_already = GetNthKey(insert_key.first);
+ if (key_already == key) return key;
+ VLOG(1) << "SymbolTable::AddSymbol: symbol = " << symbol
+ << " already in symbol_map_ with key = " << key_already
+ << " but supplied new key = " << key << " (ignoring new key)";
+ return key_already;
+ }
+ if (key == (symbols_.size() - 1) && key == dense_key_limit_) {
+ ++dense_key_limit_;
+ } else {
+ idx_key_.push_back(key);
+ key_map_[key] = symbols_.size() - 1;
+ }
+ if (key >= available_key_) available_key_ = key + 1;
+ check_sum_finalized_ = false;
+ return key;
+}
+
+// TODO(rybach): Consider a more efficient implementation which re-uses holes in
+// the dense-key range or re-arranges the dense-key range from time to time.
+void SymbolTableImpl::RemoveSymbol(const int64 key) {
+ auto idx = key;
+ if (key < 0 || key >= dense_key_limit_) {
+ auto iter = key_map_.find(key);
+ if (iter == key_map_.end()) return;
+ idx = iter->second;
+ key_map_.erase(iter);
+ }
+ if (idx < 0 || idx >= symbols_.size()) return;
+ symbols_.RemoveSymbol(idx);
+ // Removed one symbol, all indexes > idx are shifted by -1.
+ for (auto &k : key_map_) {
+ if (k.second > idx) --k.second;
+ }
+ if (key >= 0 && key < dense_key_limit_) {
+ // Removal puts a hole in the dense key range. Adjusts range to [0, key).
+ const auto new_dense_key_limit = key;
+ for (int64 i = key + 1; i < dense_key_limit_; ++i) {
+ key_map_[i] = i - 1;
+ }
+ // Moves existing values in idx_key to new place.
+ idx_key_.resize(symbols_.size() - new_dense_key_limit);
+ for (int64 i = symbols_.size(); i >= dense_key_limit_; --i) {
+ idx_key_[i - new_dense_key_limit - 1] = idx_key_[i - dense_key_limit_];
+ }
+ // Adds indexes for previously dense keys.
+ for (int64 i = new_dense_key_limit; i < dense_key_limit_ - 1; ++i) {
+ idx_key_[i - new_dense_key_limit] = i + 1;
+ }
+ dense_key_limit_ = new_dense_key_limit;
+ } else {
+ // Remove entry for removed index in idx_key.
+ for (int64 i = idx - dense_key_limit_; i < idx_key_.size() - 1; ++i) {
+ idx_key_[i] = idx_key_[i + 1];
+ }
+ idx_key_.pop_back();
+ }
+ if (key == available_key_ - 1) available_key_ = key;
+}
+
+SymbolTableImpl *SymbolTableImpl::Read(std::istream &strm,
+ const SymbolTableReadOptions &opts) {
+ int32 magic_number = 0;
+ ReadType(strm, &magic_number);
+ if (strm.fail()) {
+ LOG(ERROR) << "SymbolTable::Read: Read failed";
+ return nullptr;
+ }
+ string name;
+ ReadType(strm, &name);
+ std::unique_ptr<SymbolTableImpl> impl(new SymbolTableImpl(name));
+ ReadType(strm, &impl->available_key_);
+ int64 size;
+ ReadType(strm, &size);
+ if (strm.fail()) {
+ LOG(ERROR) << "SymbolTable::Read: Read failed";
+ return nullptr;
+ }
+ string symbol;
+ int64 key;
+ impl->check_sum_finalized_ = false;
+ for (int64 i = 0; i < size; ++i) {
+ ReadType(strm, &symbol);
+ ReadType(strm, &key);
+ if (strm.fail()) {
+ LOG(ERROR) << "SymbolTable::Read: Read failed";
+ return nullptr;
+ }
+ impl->AddSymbol(symbol, key);
+ }
+ return impl.release();
+}
+
+bool SymbolTableImpl::Write(std::ostream &strm) const {
+ WriteType(strm, kSymbolTableMagicNumber);
+ WriteType(strm, name_);
+ WriteType(strm, available_key_);
+ int64 size = symbols_.size();
+ WriteType(strm, size);
+ for (int64 i = 0; i < size; ++i) {
+ auto key = (i < dense_key_limit_) ? i : idx_key_[i - dense_key_limit_];
+ WriteType(strm, symbols_.GetSymbol(i));
+ WriteType(strm, key);
+ }
+ strm.flush();
+ if (strm.fail()) {
+ LOG(ERROR) << "SymbolTable::Write: Write failed";
+ return false;
+ }
+ return true;
+}
+
+} // namespace internal
+
+constexpr int64 SymbolTable::kNoSymbol;
+
+void SymbolTable::AddTable(const SymbolTable &table) {
+ MutateCheck();
+ for (SymbolTableIterator iter(table); !iter.Done(); iter.Next()) {
+ impl_->AddSymbol(iter.Symbol());
+ }
+}
+
+bool SymbolTable::WriteText(std::ostream &strm,
+ const SymbolTableTextOptions &opts) const {
+ if (opts.fst_field_separator.empty()) {
+ LOG(ERROR) << "Missing required field separator";
+ return false;
+ }
+ bool once_only = false;
+ for (SymbolTableIterator iter(*this); !iter.Done(); iter.Next()) {
+ std::ostringstream line;
+ if (iter.Value() < 0 && !opts.allow_negative_labels && !once_only) {
+ LOG(WARNING) << "Negative symbol table entry when not allowed";
+ once_only = true;
+ }
+ line << iter.Symbol() << opts.fst_field_separator[0] << iter.Value()
+ << '\n';
+ strm.write(line.str().data(), line.str().length());
+ }
+ return true;
+}
+
+namespace internal {
+
+DenseSymbolMap::DenseSymbolMap()
+ : empty_(-1), buckets_(1 << 4), hash_mask_(buckets_.size() - 1) {
+ std::uninitialized_fill(buckets_.begin(), buckets_.end(), empty_);
+}
+
+DenseSymbolMap::DenseSymbolMap(const DenseSymbolMap &x)
+ : empty_(-1),
+ symbols_(x.symbols_.size()),
+ buckets_(x.buckets_),
+ hash_mask_(x.hash_mask_) {
+ for (size_t i = 0; i < symbols_.size(); ++i) {
+ const auto sz = strlen(x.symbols_[i]) + 1;
+ auto *cpy = new char[sz];
+ memcpy(cpy, x.symbols_[i], sz);
+ symbols_[i] = cpy;
+ }
+}
+
+DenseSymbolMap::~DenseSymbolMap() {
+ for (size_t i = 0; i < symbols_.size(); ++i) delete[] symbols_[i];
+}
+
+std::pair<int64, bool> DenseSymbolMap::InsertOrFind(const string &key) {
+ static constexpr float kMaxOccupancyRatio = 0.75; // Grows when 75% full.
+ if (symbols_.size() >= kMaxOccupancyRatio * buckets_.size()) {
+ Rehash(buckets_.size() * 2);
+ }
+ size_t idx = str_hash_(key) & hash_mask_;
+ while (buckets_[idx] != empty_) {
+ const auto stored_value = buckets_[idx];
+ if (!strcmp(symbols_[stored_value], key.c_str())) {
+ return std::make_pair(stored_value, false);
+ }
+ idx = (idx + 1) & hash_mask_;
+ }
+ auto next = symbols_.size();
+ buckets_[idx] = next;
+ symbols_.push_back(NewSymbol(key));
+ return std::make_pair(next, true);
+}
+
+int64 DenseSymbolMap::Find(const string &key) const {
+ size_t idx = str_hash_(key) & hash_mask_;
+ while (buckets_[idx] != empty_) {
+ const auto stored_value = buckets_[idx];
+ if (!strcmp(symbols_[stored_value], key.c_str())) {
+ return stored_value;
+ }
+ idx = (idx + 1) & hash_mask_;
+ }
+ return buckets_[idx];
+}
+
+void DenseSymbolMap::Rehash(size_t num_buckets) {
+ buckets_.resize(num_buckets);
+ hash_mask_ = buckets_.size() - 1;
+ std::uninitialized_fill(buckets_.begin(), buckets_.end(), empty_);
+ for (size_t i = 0; i < symbols_.size(); ++i) {
+ size_t idx = str_hash_(string(symbols_[i])) & hash_mask_;
+ while (buckets_[idx] != empty_) {
+ idx = (idx + 1) & hash_mask_;
+ }
+ buckets_[idx] = i;
+ }
+}
+
+const char *DenseSymbolMap::NewSymbol(const string &sym) {
+ auto num = sym.size() + 1;
+ auto newstr = new char[num];
+ memcpy(newstr, sym.c_str(), num);
+ return newstr;
+}
+
+void DenseSymbolMap::RemoveSymbol(size_t idx) {
+ delete[] symbols_[idx];
+ symbols_.erase(symbols_.begin() + idx);
+ Rehash(buckets_.size());
+}
+
+} // namespace internal
+
+bool CompatSymbols(const SymbolTable *syms1, const SymbolTable *syms2,
+ bool warning) {
+ // Flag can explicitly override this check.
+ if (!FLAGS_fst_compat_symbols) return true;
+ if (syms1 && syms2 &&
+ (syms1->LabeledCheckSum() != syms2->LabeledCheckSum())) {
+ if (warning) {
+ LOG(WARNING) << "CompatSymbols: Symbol table checksums do not match. "
+ << "Table sizes are " << syms1->NumSymbols() << " and "
+ << syms2->NumSymbols();
+ }
+ return false;
+ } else {
+ return true;
+ }
+}
+
+void SymbolTableToString(const SymbolTable *table, string *result) {
+ std::ostringstream ostrm;
+ table->Write(ostrm);
+ *result = ostrm.str();
+}
+
+SymbolTable *StringToSymbolTable(const string &str) {
+ std::istringstream istrm(str);
+ return SymbolTable::Read(istrm, SymbolTableReadOptions());
+}
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// FST utility definitions.
+
+#include <fst/util.h>
+#include <cctype>
+#include <sstream>
+#include <string>
+#include <fst/mapped-file.h>
+
+// Utility flag definitions
+
+DEFINE_bool(fst_error_fatal, true,
+ "FST errors are fatal; o.w. return objects flagged as bad: "
+ " e.g., FSTs - kError prop. true, FST weights - not a Member()");
+
+namespace fst {
+
+void SplitToVector(char *full, const char *delim, std::vector<char *> *vec,
+ bool omit_empty_strings) {
+ char *p = full;
+ while (p) {
+ if ((p = strpbrk(full, delim))) {
+ p[0] = '\0';
+ }
+ if (!omit_empty_strings || full[0] != '\0') vec->push_back(full);
+ if (p) full = p + 1;
+ }
+}
+
+int64 StrToInt64(const string &s, const string &src, size_t nline,
+ bool allow_negative, bool *error) {
+ int64 n;
+ const char *cs = s.c_str();
+ char *p;
+ if (error) *error = false;
+ n = strtoll(cs, &p, 10);
+ if (p < cs + s.size() || (!allow_negative && n < 0)) {
+ FSTERROR() << "StrToInt64: Bad integer = " << s << "\", source = " << src
+ << ", line = " << nline;
+ if (error) *error = true;
+ return 0;
+ }
+ return n;
+}
+
+void Int64ToStr(int64 n, string *s) {
+ std::ostringstream nstr;
+ nstr << n;
+ s->append(nstr.str().data(), nstr.str().size());
+}
+
+void ConvertToLegalCSymbol(string *s) {
+ for (auto it = s->begin(); it != s->end(); ++it) {
+ if (!isalnum(*it)) {
+ *it = '_';
+ }
+ }
+}
+
+// Skips over input characters to align to 'align' bytes. Returns
+// false if can't align.
+bool AlignInput(std::istream &strm) {
+ char c;
+ for (int i = 0; i < MappedFile::kArchAlignment; ++i) {
+ int64 pos = strm.tellg();
+ if (pos < 0) {
+ LOG(ERROR) << "AlignInput: Can't determine stream position";
+ return false;
+ }
+ if (pos % MappedFile::kArchAlignment == 0) break;
+ strm.read(&c, 1);
+ }
+ return true;
+}
+
+// Write null output characters to align to 'align' bytes. Returns
+// false if can't align.
+bool AlignOutput(std::ostream &strm) {
+ for (int i = 0; i < MappedFile::kArchAlignment; ++i) {
+ int64 pos = strm.tellp();
+ if (pos < 0) {
+ LOG(ERROR) << "AlignOutput: Can't determine stream position";
+ return false;
+ }
+ if (pos % MappedFile::kArchAlignment == 0) break;
+ strm.write("", 1);
+ }
+ return true;
+}
+
+} // namespace fst
--- /dev/null
+#include <fst/weight.h>
+
+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 {
+
+CompositeWeightWriter::CompositeWeightWriter(std::ostream &ostrm)
+ : ostrm_(ostrm), i_(0) {
+ if (FLAGS_fst_weight_separator.size() != 1) {
+ FSTERROR() << "CompositeWeightWriter: "
+ << "FLAGS_fst_weight_separator.size() is not equal to 1";
+ ostrm.clear(std::ios::badbit);
+ return;
+ }
+ if (!FLAGS_fst_weight_parentheses.empty()) {
+ if (FLAGS_fst_weight_parentheses.size() != 2) {
+ FSTERROR() << "CompositeWeightWriter: "
+ << "FLAGS_fst_weight_parentheses.size() is not equal to 2";
+ ostrm.clear(std::ios::badbit);
+ return;
+ }
+ }
+}
+
+void CompositeWeightWriter::WriteBegin() {
+ if (!FLAGS_fst_weight_parentheses.empty()) {
+ ostrm_ << FLAGS_fst_weight_parentheses[0];
+ }
+}
+
+void CompositeWeightWriter::WriteEnd() {
+ if (!FLAGS_fst_weight_parentheses.empty()) {
+ ostrm_ << FLAGS_fst_weight_parentheses[1];
+ }
+}
+
+CompositeWeightReader::CompositeWeightReader(std::istream &istrm)
+ : istrm_(istrm),
+ c_(0),
+ has_parens_(false),
+ depth_(0),
+ open_paren_(0),
+ close_paren_(0) {
+ if (FLAGS_fst_weight_separator.size() != 1) {
+ FSTERROR() << "ComposeWeightReader: "
+ << "FLAGS_fst_weight_separator.size() is not equal to 1";
+ istrm_.clear(std::ios::badbit);
+ return;
+ }
+ separator_ = FLAGS_fst_weight_separator[0];
+ if (!FLAGS_fst_weight_parentheses.empty()) {
+ if (FLAGS_fst_weight_parentheses.size() != 2) {
+ FSTERROR() << "ComposeWeightReader: "
+ << "FLAGS_fst_weight_parentheses.size() is not equal to 2";
+ istrm_.clear(std::ios::badbit);
+ return;
+ }
+ has_parens_ = true;
+ open_paren_ = FLAGS_fst_weight_parentheses[0];
+ close_paren_ = FLAGS_fst_weight_parentheses[1];
+ }
+}
+
+void CompositeWeightReader::ReadBegin() {
+ do { // Skips whitespace.
+ c_ = istrm_.get();
+ } while (std::isspace(c_));
+ if (has_parens_) {
+ 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<char>(c_)
+ << "': fst_weight_parentheses flag set correcty?";
+ istrm_.clear(std::ios::badbit);
+ }
+}
+
+} // namespace fst
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS)
+
+if HAVE_SCRIPT
+lib_LTLIBRARIES = libfstscript.la
+libfstscript_la_SOURCES = arciterator-class.cc arcsort.cc closure.cc \
+compile.cc compose.cc concat.cc connect.cc convert.cc decode.cc determinize.cc \
+difference.cc disambiguate.cc draw.cc encode.cc encodemapper-class.cc \
+epsnormalize.cc equal.cc equivalent.cc fst-class.cc getters.cc info.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 6:0:0
+endif
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/script
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(libdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+@HAVE_SCRIPT_TRUE@libfstscript_la_DEPENDENCIES = ../lib/libfst.la \
+@HAVE_SCRIPT_TRUE@ $(am__DEPENDENCIES_1)
+am__libfstscript_la_SOURCES_DIST = arciterator-class.cc arcsort.cc \
+ closure.cc compile.cc compose.cc concat.cc connect.cc \
+ convert.cc decode.cc determinize.cc difference.cc \
+ disambiguate.cc draw.cc encode.cc encodemapper-class.cc \
+ epsnormalize.cc equal.cc equivalent.cc fst-class.cc getters.cc \
+ info.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.lo intersect.lo \
+@HAVE_SCRIPT_TRUE@ invert.lo isomorphic.lo map.lo minimize.lo \
+@HAVE_SCRIPT_TRUE@ print.lo project.lo prune.lo push.lo \
+@HAVE_SCRIPT_TRUE@ randequivalent.lo randgen.lo relabel.lo \
+@HAVE_SCRIPT_TRUE@ replace.lo reverse.lo reweight.lo \
+@HAVE_SCRIPT_TRUE@ rmepsilon.lo shortest-distance.lo \
+@HAVE_SCRIPT_TRUE@ shortest-path.lo stateiterator-class.lo \
+@HAVE_SCRIPT_TRUE@ synchronize.lo text-io.lo topsort.lo \
+@HAVE_SCRIPT_TRUE@ union.lo weight-class.lo verify.lo
+libfstscript_la_OBJECTS = $(am_libfstscript_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+libfstscript_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+ $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+ $(AM_CXXFLAGS) $(CXXFLAGS) $(libfstscript_la_LDFLAGS) \
+ $(LDFLAGS) -o $@
+@HAVE_SCRIPT_TRUE@am_libfstscript_la_rpath = -rpath $(libdir)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+SOURCES = $(libfstscript_la_SOURCES)
+DIST_SOURCES = $(am__libfstscript_la_SOURCES_DIST)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS)
+@HAVE_SCRIPT_TRUE@lib_LTLIBRARIES = libfstscript.la
+@HAVE_SCRIPT_TRUE@libfstscript_la_SOURCES = arciterator-class.cc arcsort.cc closure.cc \
+@HAVE_SCRIPT_TRUE@compile.cc compose.cc concat.cc connect.cc convert.cc decode.cc determinize.cc \
+@HAVE_SCRIPT_TRUE@difference.cc disambiguate.cc draw.cc encode.cc encodemapper-class.cc \
+@HAVE_SCRIPT_TRUE@epsnormalize.cc equal.cc equivalent.cc fst-class.cc getters.cc info.cc \
+@HAVE_SCRIPT_TRUE@intersect.cc invert.cc isomorphic.cc map.cc minimize.cc print.cc project.cc \
+@HAVE_SCRIPT_TRUE@prune.cc push.cc randequivalent.cc randgen.cc relabel.cc replace.cc \
+@HAVE_SCRIPT_TRUE@reverse.cc reweight.cc rmepsilon.cc shortest-distance.cc shortest-path.cc \
+@HAVE_SCRIPT_TRUE@stateiterator-class.cc synchronize.cc text-io.cc topsort.cc union.cc \
+@HAVE_SCRIPT_TRUE@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 6:0:0
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .o .obj
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/script/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/script/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+ @$(NORMAL_INSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ list2=; for p in $$list; do \
+ if test -f $$p; then \
+ list2="$$list2 $$p"; \
+ else :; fi; \
+ done; \
+ test -z "$$list2" || { \
+ echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+ }
+
+uninstall-libLTLIBRARIES:
+ @$(NORMAL_UNINSTALL)
+ @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+ for p in $$list; do \
+ $(am__strip_dir) \
+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+ done
+
+clean-libLTLIBRARIES:
+ -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+ @list='$(lib_LTLIBRARIES)'; \
+ locs=`for p in $$list; do echo $$p; done | \
+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
+ sort -u`; \
+ test -z "$$locs" || { \
+ echo rm -f $${locs}; \
+ rm -f $${locs}; \
+ }
+
+libfstscript.la: $(libfstscript_la_OBJECTS) $(libfstscript_la_DEPENDENCIES) $(EXTRA_libfstscript_la_DEPENDENCIES)
+ $(AM_V_CXXLD)$(libfstscript_la_LINK) $(am_libfstscript_la_rpath) $(libfstscript_la_OBJECTS) $(libfstscript_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arciterator-class.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/arcsort.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/closure.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compile.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/compose.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/concat.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/connect.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/convert.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decode.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/determinize.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/difference.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/disambiguate.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/draw.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encode.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encodemapper-class.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/epsnormalize.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/equal.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/equivalent.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst-class.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/getters.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/info.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/intersect.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/invert.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isomorphic.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/map.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/minimize.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/project.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prune.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/push.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/randequivalent.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/randgen.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/relabel.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/replace.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reverse.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reweight.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rmepsilon.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shortest-distance.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shortest-path.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stateiterator-class.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/synchronize.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/text-io.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/topsort.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/union.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/verify.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight-class.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+installdirs:
+ for dir in "$(DESTDIR)$(libdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+ mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+ clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \
+ ctags-am distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-libLTLIBRARIES install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ tags tags-am uninstall uninstall-am uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/arciterator-class.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+ArcIteratorClass::ArcIteratorClass(const FstClass &fst, int64 s)
+ : impl_(nullptr) {
+ InitArcIteratorClassArgs args(fst, s, this);
+ Apply<Operation<InitArcIteratorClassArgs>>("InitArcIteratorClass",
+ fst.ArcType(), &args);
+}
+
+MutableArcIteratorClass::MutableArcIteratorClass(MutableFstClass *fst,
+ int64 s) : impl_(nullptr) {
+ InitMutableArcIteratorClassArgs args(fst, s, this);
+ Apply<Operation<InitMutableArcIteratorClassArgs>>(
+ "InitMutableArcIteratorClass", fst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(InitArcIteratorClass, StdArc, InitArcIteratorClassArgs);
+REGISTER_FST_OPERATION(InitArcIteratorClass, LogArc, InitArcIteratorClassArgs);
+REGISTER_FST_OPERATION(InitArcIteratorClass, Log64Arc,
+ InitArcIteratorClassArgs);
+
+REGISTER_FST_OPERATION(InitMutableArcIteratorClass, StdArc,
+ InitMutableArcIteratorClassArgs);
+REGISTER_FST_OPERATION(InitMutableArcIteratorClass, LogArc,
+ InitMutableArcIteratorClassArgs);
+REGISTER_FST_OPERATION(InitMutableArcIteratorClass, Log64Arc,
+ InitMutableArcIteratorClassArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/arcsort.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void ArcSort(MutableFstClass *fst, ArcSortType sort_type) {
+ ArcSortArgs args(fst, sort_type);
+ Apply<Operation<ArcSortArgs>>("ArcSort", fst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(ArcSort, StdArc, ArcSortArgs);
+REGISTER_FST_OPERATION(ArcSort, LogArc, ArcSortArgs);
+REGISTER_FST_OPERATION(ArcSort, Log64Arc, ArcSortArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/closure.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Closure(MutableFstClass *fst, ClosureType closure_type) {
+ ClosureArgs args(fst, closure_type);
+ Apply<Operation<ClosureArgs>>("Closure", fst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Closure, StdArc, ClosureArgs);
+REGISTER_FST_OPERATION(Closure, LogArc, ClosureArgs);
+REGISTER_FST_OPERATION(Closure, Log64Arc, ClosureArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <istream>
+#include <string>
+
+#include <fst/script/compile.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void CompileFst(std::istream &istrm, const string &source, const string &dest,
+ const string &fst_type, const string &arc_type,
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ const SymbolTable *ssyms, bool accep, bool ikeep, bool okeep,
+ bool nkeep, bool allow_negative_labels) {
+ std::unique_ptr<FstClass> fst(
+ CompileFstInternal(istrm, source, fst_type, arc_type, isyms, osyms, ssyms,
+ accep, ikeep, okeep, nkeep, allow_negative_labels));
+ fst->Write(dest);
+}
+
+// 2
+FstClass *CompileFstInternal(std::istream &istrm, const string &source,
+ const string &fst_type, const string &arc_type,
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ const SymbolTable *ssyms, bool accep, bool ikeep,
+ bool okeep, bool nkeep,
+ bool allow_negative_labels) {
+ CompileFstInnerArgs iargs(istrm, source, fst_type, isyms, osyms, ssyms, accep,
+ ikeep, okeep, nkeep, allow_negative_labels);
+ CompileFstArgs args(iargs);
+ Apply<Operation<CompileFstArgs>>("CompileFstInternal", arc_type, &args);
+ return args.retval;
+}
+
+// This registers 2; 1 does not require registration.
+REGISTER_FST_OPERATION(CompileFstInternal, StdArc, CompileFstArgs);
+REGISTER_FST_OPERATION(CompileFstInternal, LogArc, CompileFstArgs);
+REGISTER_FST_OPERATION(CompileFstInternal, Log64Arc, CompileFstArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/compose.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Compose(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, ComposeFilter compose_filter) {
+ if (!ArcTypesMatch(ifst1, ifst2, "Compose") ||
+ !ArcTypesMatch(*ofst, ifst1, "Compose")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ComposeArgs1 args(ifst1, ifst2, ofst, compose_filter);
+ Apply<Operation<ComposeArgs1>>("Compose", ifst1.ArcType(), &args);
+}
+
+// 2
+void Compose(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, const ComposeOptions &copts) {
+ if (!ArcTypesMatch(ifst1, ifst2, "Compose") ||
+ !ArcTypesMatch(*ofst, ifst1, "Compose")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ComposeArgs2 args(ifst1, ifst2, ofst, copts);
+ Apply<Operation<ComposeArgs2>>("Compose", ifst1.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Compose, StdArc, ComposeArgs1);
+REGISTER_FST_OPERATION(Compose, LogArc, ComposeArgs1);
+REGISTER_FST_OPERATION(Compose, Log64Arc, ComposeArgs1);
+
+REGISTER_FST_OPERATION(Compose, StdArc, ComposeArgs2);
+REGISTER_FST_OPERATION(Compose, LogArc, ComposeArgs2);
+REGISTER_FST_OPERATION(Compose, Log64Arc, ComposeArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/concat.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Concat(MutableFstClass *ofst, const FstClass &ifst) {
+ if (!ArcTypesMatch(*ofst, ifst, "Concat")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ConcatArgs1 args(ofst, ifst);
+ Apply<Operation<ConcatArgs1>>("Concat", ofst->ArcType(), &args);
+}
+
+// 2
+void Concat(const FstClass &ifst, MutableFstClass *ofst) {
+ if (!ArcTypesMatch(ifst, *ofst, "Concat")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ConcatArgs2 args(ifst, ofst);
+ Apply<Operation<ConcatArgs2>>("Concat", ofst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Concat, StdArc, ConcatArgs1);
+REGISTER_FST_OPERATION(Concat, LogArc, ConcatArgs1);
+REGISTER_FST_OPERATION(Concat, Log64Arc, ConcatArgs1);
+
+REGISTER_FST_OPERATION(Concat, StdArc, ConcatArgs2);
+REGISTER_FST_OPERATION(Concat, LogArc, ConcatArgs2);
+REGISTER_FST_OPERATION(Concat, Log64Arc, ConcatArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/connect.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Connect(MutableFstClass *fst) {
+ Apply<Operation<MutableFstClass>>("Connect", fst->ArcType(), fst);
+}
+
+REGISTER_FST_OPERATION(Connect, StdArc, MutableFstClass);
+REGISTER_FST_OPERATION(Connect, LogArc, MutableFstClass);
+REGISTER_FST_OPERATION(Connect, Log64Arc, MutableFstClass);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/convert.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+FstClass *Convert(const FstClass &ifst, const string &new_type) {
+ ConvertInnerArgs iargs(ifst, new_type);
+ ConvertArgs args(iargs);
+ Apply<Operation<ConvertArgs>>("Convert", ifst.ArcType(), &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(Convert, StdArc, ConvertArgs);
+REGISTER_FST_OPERATION(Convert, LogArc, ConvertArgs);
+REGISTER_FST_OPERATION(Convert, Log64Arc, ConvertArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/encode.h>
+#include <fst/script/decode.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1: Decode using encoder on disk.
+void Decode(MutableFstClass *fst, const string &coder_fname) {
+ DecodeArgs1 args(fst, coder_fname);
+ Apply<Operation<DecodeArgs1>>("Decode", fst->ArcType(), &args);
+}
+
+// 2: Decode using an EncodeMapperClass.
+void Decode(MutableFstClass *fst, const EncodeMapperClass &encoder) {
+ if (fst->ArcType() != encoder.ArcType()) {
+ FSTERROR() << "FST and encoder with non-matching arc types passed to "
+ << "Decode:\n\t" << fst->ArcType() << " and "
+ << encoder.ArcType();
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ DecodeArgs2 args(fst, encoder);
+ Apply<Operation<DecodeArgs2>>("Decode", fst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Decode, StdArc, DecodeArgs1);
+REGISTER_FST_OPERATION(Decode, LogArc, DecodeArgs1);
+REGISTER_FST_OPERATION(Decode, Log64Arc, DecodeArgs1);
+
+REGISTER_FST_OPERATION(Decode, StdArc, DecodeArgs2);
+REGISTER_FST_OPERATION(Decode, LogArc, DecodeArgs2);
+REGISTER_FST_OPERATION(Decode, Log64Arc, DecodeArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/determinize.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1: Full signature with DeterminizeOptions.
+void Determinize(const FstClass &ifst, MutableFstClass *ofst,
+ const DeterminizeOptions &opts) {
+ if (!ArcTypesMatch(ifst, *ofst, "Determinize") ||
+ !ofst->WeightTypesMatch(opts.weight_threshold, "Determinize")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ DeterminizeArgs1 args(ifst, ofst, opts);
+ Apply<Operation<DeterminizeArgs1>>("Determinize", ifst.ArcType(), &args);
+}
+
+// 2: Signature with default WeightClass argument.
+void Determinize(const FstClass &ifst, MutableFstClass *ofst, float d,
+ int64 n, int64 l, DeterminizeType t, bool i) {
+ if (!ArcTypesMatch(ifst, *ofst, "Determinize")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ DeterminizeArgs2 args(ifst, ofst, d, n, l, t, i);
+ Apply<Operation<DeterminizeArgs2>>("Determinize", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Determinize, StdArc, DeterminizeArgs1);
+REGISTER_FST_OPERATION(Determinize, LogArc, DeterminizeArgs1);
+REGISTER_FST_OPERATION(Determinize, Log64Arc, DeterminizeArgs1);
+
+REGISTER_FST_OPERATION(Determinize, StdArc, DeterminizeArgs2);
+REGISTER_FST_OPERATION(Determinize, LogArc, DeterminizeArgs2);
+REGISTER_FST_OPERATION(Determinize, Log64Arc, DeterminizeArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/difference.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Difference(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, ComposeFilter compose_filter) {
+ if (!ArcTypesMatch(ifst1, ifst2, "Difference") ||
+ !ArcTypesMatch(*ofst, ifst1, "Difference")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ DifferenceArgs1 args(ifst1, ifst2, ofst, compose_filter);
+ Apply<Operation<DifferenceArgs1>>("Difference", ifst1.ArcType(), &args);
+}
+
+// 2
+void Difference(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, const ComposeOptions &copts) {
+ if (!ArcTypesMatch(ifst1, ifst2, "Difference") ||
+ !ArcTypesMatch(*ofst, ifst1, "Difference")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ DifferenceArgs2 args(ifst1, ifst2, ofst, copts);
+ Apply<Operation<DifferenceArgs2>>("Difference", ifst1.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Difference, StdArc, DifferenceArgs1);
+REGISTER_FST_OPERATION(Difference, LogArc, DifferenceArgs1);
+REGISTER_FST_OPERATION(Difference, Log64Arc, DifferenceArgs1);
+REGISTER_FST_OPERATION(Difference, StdArc, DifferenceArgs2);
+REGISTER_FST_OPERATION(Difference, LogArc, DifferenceArgs2);
+REGISTER_FST_OPERATION(Difference, Log64Arc, DifferenceArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/disambiguate.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1: Full signature.
+void Disambiguate(const FstClass &ifst, MutableFstClass *ofst,
+ const DisambiguateOptions &opts) {
+ if (!ArcTypesMatch(ifst, *ofst, "Disambiguate") ||
+ !ofst->WeightTypesMatch(opts.weight_threshold, "Disambiguate")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ DisambiguateArgs1 args(ifst, ofst, opts);
+ Apply<Operation<DisambiguateArgs1>>("Disambiguate", ifst.ArcType(), &args);
+}
+
+// 2: Signature with default WeightClass argument.
+void Disambiguate(const FstClass &ifst, MutableFstClass *ofst,
+ int64 n, int64 l) {
+ if (!ArcTypesMatch(ifst, *ofst, "Disambiguate")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ DisambiguateArgs2 args(ifst, ofst, n, l);
+ Apply<Operation<DisambiguateArgs2>>("Disambiguate", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Disambiguate, StdArc, DisambiguateArgs1);
+REGISTER_FST_OPERATION(Disambiguate, LogArc, DisambiguateArgs1);
+REGISTER_FST_OPERATION(Disambiguate, Log64Arc, DisambiguateArgs1);
+
+REGISTER_FST_OPERATION(Disambiguate, StdArc, DisambiguateArgs2);
+REGISTER_FST_OPERATION(Disambiguate, LogArc, DisambiguateArgs2);
+REGISTER_FST_OPERATION(Disambiguate, Log64Arc, DisambiguateArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <ostream>
+#include <string>
+
+#include <fst/script/draw.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void DrawFst(const FstClass &fst, const SymbolTable *isyms,
+ const SymbolTable *osyms, const SymbolTable *ssyms, bool accep,
+ const string &title, float width, float height, bool portrait,
+ bool vertical, float ranksep, float nodesep, int fontsize,
+ int precision, bool show_weight_one, std::ostream *ostrm,
+ const string &dest) {
+ FstDrawerArgs args(fst, isyms, osyms, ssyms, accep, title, width, height,
+ portrait, vertical, ranksep, nodesep, fontsize, precision,
+ show_weight_one, ostrm, dest);
+ Apply<Operation<FstDrawerArgs>>("DrawFst", fst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(DrawFst, StdArc, FstDrawerArgs);
+REGISTER_FST_OPERATION(DrawFst, LogArc, FstDrawerArgs);
+REGISTER_FST_OPERATION(DrawFst, Log64Arc, FstDrawerArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/encode.h>
+#include <fst/script/encode.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Encode(MutableFstClass *fst, uint32 flags, bool reuse_encoder,
+ const string &coder_fname) {
+ EncodeArgs1 args(fst, flags, reuse_encoder, coder_fname);
+ Apply<Operation<EncodeArgs1>>("Encode", fst->ArcType(), &args);
+}
+
+// 2
+void Encode(MutableFstClass *fst, EncodeMapperClass *encoder) {
+ if (fst->ArcType() != encoder->ArcType()) {
+ FSTERROR() << "FST and encoder with non-matching arc types passed to "
+ << "Encode:\n\t" << fst->ArcType() << " and "
+ << encoder->ArcType();
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ EncodeArgs2 args(fst, encoder);
+ Apply<Operation<EncodeArgs2>>("Encode", fst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Encode, StdArc, EncodeArgs1);
+REGISTER_FST_OPERATION(Encode, LogArc, EncodeArgs1);
+REGISTER_FST_OPERATION(Encode, Log64Arc, EncodeArgs1);
+
+REGISTER_FST_OPERATION(Encode, StdArc, EncodeArgs2);
+REGISTER_FST_OPERATION(Encode, LogArc, EncodeArgs2);
+REGISTER_FST_OPERATION(Encode, Log64Arc, EncodeArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/encodemapper-class.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+EncodeMapperClass::EncodeMapperClass(const string &arc_type, uint32 flags,
+ EncodeType type) : impl_(nullptr) {
+ InitEncodeMapperClassArgs args(flags, type, this);
+ Apply<Operation<InitEncodeMapperClassArgs>>("InitEncodeMapperClass",
+ arc_type, &args);
+}
+
+REGISTER_FST_OPERATION(InitEncodeMapperClass, StdArc,
+ InitEncodeMapperClassArgs);
+REGISTER_FST_OPERATION(InitEncodeMapperClass, LogArc,
+ InitEncodeMapperClassArgs);
+REGISTER_FST_OPERATION(InitEncodeMapperClass, Log64Arc,
+ InitEncodeMapperClassArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/epsnormalize.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void EpsNormalize(const FstClass &ifst, MutableFstClass *ofst,
+ EpsNormalizeType norm_type) {
+ if (!ArcTypesMatch(ifst, *ofst, "EpsNormalize")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ EpsNormalizeArgs args(ifst, ofst, norm_type);
+ Apply<Operation<EpsNormalizeArgs>>("EpsNormalize", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(EpsNormalize, StdArc, EpsNormalizeArgs);
+REGISTER_FST_OPERATION(EpsNormalize, LogArc, EpsNormalizeArgs);
+REGISTER_FST_OPERATION(EpsNormalize, Log64Arc, EpsNormalizeArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/equal.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+bool Equal(const FstClass &fst1, const FstClass &fst2, float delta) {
+ if (!ArcTypesMatch(fst1, fst2, "Equal")) return false;
+ EqualInnerArgs iargs(fst1, fst2, delta);
+ EqualArgs args(iargs);
+ Apply<Operation<EqualArgs>>("Equal", fst1.ArcType(), &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(Equal, StdArc, EqualArgs);
+REGISTER_FST_OPERATION(Equal, LogArc, EqualArgs);
+REGISTER_FST_OPERATION(Equal, Log64Arc, EqualArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/equivalent.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+bool Equivalent(const FstClass &fst1, const FstClass &fst2, float delta,
+ bool *error) {
+ if (!ArcTypesMatch(fst1, fst2, "Equivalent")) return false;
+ EquivalentInnerArgs iargs(fst1, fst2, delta, error);
+ EquivalentArgs args(iargs);
+ Apply<Operation<EquivalentArgs>>("Equivalent", fst1.ArcType(), &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(Equivalent, StdArc, EquivalentArgs);
+REGISTER_FST_OPERATION(Equivalent, LogArc, EquivalentArgs);
+REGISTER_FST_OPERATION(Equivalent, Log64Arc, EquivalentArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// 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 <istream>
+
+#include <fst/equal.h>
+#include <fst/fst-decl.h>
+#include <fst/reverse.h>
+#include <fst/union.h>
+#include <fst/script/fst-class.h>
+#include <fst/script/register.h>
+
+namespace fst {
+namespace script {
+
+// Registration.
+
+REGISTER_FST_CLASSES(StdArc);
+REGISTER_FST_CLASSES(LogArc);
+REGISTER_FST_CLASSES(Log64Arc);
+
+// FstClass methods.
+
+template <class FstT>
+FstT *ReadFst(std::istream &istrm, const string &fname) {
+ if (!istrm) {
+ LOG(ERROR) << "ReadFst: Can't open file: " << fname;
+ return nullptr;
+ }
+ FstHeader hdr;
+ if (!hdr.Read(istrm, fname)) return nullptr;
+ FstReadOptions read_options(fname, &hdr);
+ const auto arc_type = hdr.ArcType();
+ const auto reader =
+ IORegistration<FstT>::Register::GetRegister()->GetReader(arc_type);
+ if (!reader) {
+ LOG(ERROR) << "ReadFst: Unknown arc type: " << arc_type;
+ return nullptr;
+ }
+ return reader(istrm, read_options);
+}
+
+FstClass *FstClass::Read(const string &fname) {
+ if (!fname.empty()) {
+ std::ifstream istrm(fname.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ return ReadFst<FstClass>(istrm, fname);
+ } else {
+ return ReadFst<FstClass>(std::cin, "standard input");
+ }
+}
+
+FstClass *FstClass::Read(std::istream &istrm, const string &source) {
+ return ReadFst<FstClass>(istrm, source);
+}
+
+FstClass *FstClass::ReadFromString(const string &fst_string) {
+ std::istringstream istrm(fst_string);
+ return ReadFst<FstClass>(istrm, "StringToFst");
+}
+
+const string FstClass::WriteToString() const {
+ std::ostringstream ostrm;
+ Write(ostrm, FstWriteOptions("StringToFst"));
+ return ostrm.str();
+}
+
+bool FstClass::WeightTypesMatch(const WeightClass &weight,
+ const string &op_name) const {
+ if (WeightType() != weight.Type()) {
+ FSTERROR() << "FST and weight with non-matching weight types passed to "
+ << op_name << ": " << WeightType() << " and " << weight.Type();
+ return false;
+ }
+ return true;
+}
+
+// MutableFstClass methods.
+
+MutableFstClass *MutableFstClass::Read(const string &fname, bool convert) {
+ if (convert == false) {
+ if (!fname.empty()) {
+ std::ifstream in(fname.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ return ReadFst<MutableFstClass>(in, fname);
+ } else {
+ return ReadFst<MutableFstClass>(std::cin, "standard input");
+ }
+ } else { // Converts to VectorFstClass if not mutable.
+ FstClass *ifst = FstClass::Read(fname);
+ if (!ifst) return nullptr;
+ if (ifst->Properties(fst::kMutable, false)) {
+ return static_cast<MutableFstClass *>(ifst);
+ } else {
+ MutableFstClass *ofst = new VectorFstClass(*ifst);
+ delete ifst;
+ return ofst;
+ }
+ }
+}
+
+// VectorFstClass methods.
+
+VectorFstClass *VectorFstClass::Read(const string &fname) {
+ if (!fname.empty()) {
+ std::ifstream in(fname.c_str(),
+ std::ios_base::in | std::ios_base::binary);
+ return ReadFst<VectorFstClass>(in, fname);
+ } else {
+ return ReadFst<VectorFstClass>(std::cin, "standard input");
+ }
+}
+
+IORegistration<VectorFstClass>::Entry GetVFSTRegisterEntry(
+ const string &arc_type) {
+ return IORegistration<VectorFstClass>::Register::GetRegister()->GetEntry(
+ arc_type);
+}
+
+VectorFstClass::VectorFstClass(const string &arc_type)
+ : MutableFstClass(GetVFSTRegisterEntry(arc_type).creator()) {
+ if (Properties(kError, true) == kError) {
+ FSTERROR() << "VectorFstClass: Unknown arc type: " << arc_type;
+ }
+}
+
+VectorFstClass::VectorFstClass(const FstClass &other)
+ : MutableFstClass(GetVFSTRegisterEntry(other.ArcType()).converter(other)) {}
+
+} // namespace script
+} // namespace fst
--- /dev/null
+#include <fst/script/getters.h>
+
+namespace fst {
+namespace script {
+
+bool GetArcSortType(const string &str, ArcSortType *sort_type) {
+ if (str == "ilabel") {
+ *sort_type = ILABEL_SORT;
+ } else if (str == "olabel") {
+ *sort_type = OLABEL_SORT;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetComposeFilter(const string &str, ComposeFilter *compose_filter) {
+ if (str == "alt_sequence") {
+ *compose_filter = ALT_SEQUENCE_FILTER;
+ } else if (str == "auto") {
+ *compose_filter = AUTO_FILTER;
+ } else if (str == "match") {
+ *compose_filter = MATCH_FILTER;
+ } else if (str == "null") {
+ *compose_filter = NULL_FILTER;
+ } else if (str == "sequence") {
+ *compose_filter = SEQUENCE_FILTER;
+ } else if (str == "trivial") {
+ *compose_filter = TRIVIAL_FILTER;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetDeterminizeType(const string &str, DeterminizeType *det_type) {
+ if (str == "functional") {
+ *det_type = DETERMINIZE_FUNCTIONAL;
+ } else if (str == "nonfunctional") {
+ *det_type = DETERMINIZE_NONFUNCTIONAL;
+ } else if (str == "disambiguate") {
+ *det_type = DETERMINIZE_DISAMBIGUATE;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetMapType(const string &str, MapType *map_type) {
+ if (str == "arc_sum") {
+ *map_type = ARC_SUM_MAPPER;
+ } else if (str == "arc_unique") {
+ *map_type = ARC_UNIQUE_MAPPER;
+ } else if (str == "identity") {
+ *map_type = IDENTITY_MAPPER;
+ } else if (str == "input_epsilon") {
+ *map_type = INPUT_EPSILON_MAPPER;
+ } else if (str == "invert") {
+ *map_type = INVERT_MAPPER;
+ } else if (str == "output_epsilon") {
+ *map_type = OUTPUT_EPSILON_MAPPER;
+ } else if (str == "plus") {
+ *map_type = PLUS_MAPPER;
+ } else if (str == "quantize") {
+ *map_type = QUANTIZE_MAPPER;
+ } else if (str == "rmweight") {
+ *map_type = RMWEIGHT_MAPPER;
+ } else if (str == "superfinal") {
+ *map_type = SUPERFINAL_MAPPER;
+ } else if (str == "times") {
+ *map_type = TIMES_MAPPER;
+ } else if (str == "to_log") {
+ *map_type = TO_LOG_MAPPER;
+ } else if (str == "to_log64") {
+ *map_type = TO_LOG64_MAPPER;
+ } else if (str == "to_std" || str == "to_standard") {
+ *map_type = TO_STD_MAPPER;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetRandArcSelection(const string &str, RandArcSelection *ras) {
+ if (str == "uniform") {
+ *ras = UNIFORM_ARC_SELECTOR;
+ } else if (str == "log_prob") {
+ *ras = LOG_PROB_ARC_SELECTOR;
+ } else if (str == "fast_log_prob") {
+ *ras = FAST_LOG_PROB_ARC_SELECTOR;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetQueueType(const string &str, QueueType *queue_type) {
+ if (str == "auto") {
+ *queue_type = AUTO_QUEUE;
+ } else if (str == "fifo") {
+ *queue_type = FIFO_QUEUE;
+ } else if (str == "lifo") {
+ *queue_type = LIFO_QUEUE;
+ } else if (str == "shortest") {
+ *queue_type = SHORTEST_FIRST_QUEUE;
+ } else if (str == "state") {
+ *queue_type = STATE_ORDER_QUEUE;
+ } else if (str == "top") {
+ *queue_type = TOP_ORDER_QUEUE;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+bool GetReplaceLabelType(const string &str, bool epsilon_on_replace,
+ ReplaceLabelType *rlt) {
+ if (epsilon_on_replace || str == "neither") {
+ *rlt = REPLACE_LABEL_NEITHER;
+ } else if (str == "input") {
+ *rlt = REPLACE_LABEL_INPUT;
+ } else if (str == "output") {
+ *rlt = REPLACE_LABEL_OUTPUT;
+ } else if (str == "both") {
+ *rlt = REPLACE_LABEL_BOTH;
+ } else {
+ return false;
+ }
+ return true;
+}
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <string>
+
+#include <fst/script/fst-class.h>
+#include <fst/script/info.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void PrintFstInfo(const FstClass &fst, bool test_properties,
+ const string &arc_filter, const string &info_type, bool pipe,
+ bool verify) {
+ InfoArgs args(fst, test_properties, arc_filter, info_type, pipe, verify);
+ Apply<Operation<InfoArgs>>("PrintFstInfo", fst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(PrintFstInfo, StdArc, InfoArgs);
+REGISTER_FST_OPERATION(PrintFstInfo, LogArc, InfoArgs);
+REGISTER_FST_OPERATION(PrintFstInfo, Log64Arc, InfoArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/intersect.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Intersect(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, ComposeFilter compose_filter) {
+ if (!ArcTypesMatch(ifst1, ifst2, "Intersect") ||
+ !ArcTypesMatch(*ofst, ifst1, "Intersect")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ IntersectArgs1 args(ifst1, ifst2, ofst, compose_filter);
+ Apply<Operation<IntersectArgs1>>("Intersect", ifst1.ArcType(), &args);
+}
+
+// 2
+void Intersect(const FstClass &ifst1, const FstClass &ifst2,
+ MutableFstClass *ofst, const ComposeOptions &copts) {
+ if (!ArcTypesMatch(ifst1, ifst2, "Intersect") ||
+ !ArcTypesMatch(*ofst, ifst1, "Intersect")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ IntersectArgs2 args(ifst1, ifst2, ofst, copts);
+ Apply<Operation<IntersectArgs2>>("Intersect", ifst1.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Intersect, StdArc, IntersectArgs1);
+REGISTER_FST_OPERATION(Intersect, LogArc, IntersectArgs1);
+REGISTER_FST_OPERATION(Intersect, Log64Arc, IntersectArgs1);
+
+REGISTER_FST_OPERATION(Intersect, StdArc, IntersectArgs2);
+REGISTER_FST_OPERATION(Intersect, LogArc, IntersectArgs2);
+REGISTER_FST_OPERATION(Intersect, Log64Arc, IntersectArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/invert.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Invert(MutableFstClass *fst) {
+ Apply<Operation<MutableFstClass>>("Invert", fst->ArcType(), fst);
+}
+
+REGISTER_FST_OPERATION(Invert, StdArc, MutableFstClass);
+REGISTER_FST_OPERATION(Invert, LogArc, MutableFstClass);
+REGISTER_FST_OPERATION(Invert, Log64Arc, MutableFstClass);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/isomorphic.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+bool Isomorphic(const FstClass &fst1, const FstClass &fst2, float delta) {
+ if (!ArcTypesMatch(fst1, fst2, "Isomorphic")) return false;
+ IsomorphicInnerArgs iargs(fst1, fst2, delta);
+ IsomorphicArgs args(iargs);
+ Apply<Operation<IsomorphicArgs>>("Isomorphic", fst1.ArcType(), &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(Isomorphic, StdArc, IsomorphicArgs);
+REGISTER_FST_OPERATION(Isomorphic, LogArc, IsomorphicArgs);
+REGISTER_FST_OPERATION(Isomorphic, Log64Arc, IsomorphicArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/map.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+FstClass *Map(const FstClass &ifst, MapType map_type, float delta,
+ const WeightClass &weight) {
+ if (!ifst.WeightTypesMatch(weight, "Map")) return nullptr;
+ MapInnerArgs iargs(ifst, map_type, delta, weight);
+ MapArgs args(iargs);
+ Apply<Operation<MapArgs>>("Map", ifst.ArcType(), &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(Map, StdArc, MapArgs);
+REGISTER_FST_OPERATION(Map, LogArc, MapArgs);
+REGISTER_FST_OPERATION(Map, Log64Arc, MapArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/minimize.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Minimize(MutableFstClass *ofst1, MutableFstClass *ofst2, float delta,
+ bool allow_nondet) {
+ if (ofst2 && !ArcTypesMatch(*ofst1, *ofst2, "Minimize")) {
+ ofst1->SetProperties(kError, kError);
+ ofst2->SetProperties(kError, kError);
+ return;
+ }
+ MinimizeArgs args(ofst1, ofst2, delta, allow_nondet);
+ Apply<Operation<MinimizeArgs>>("Minimize", ofst1->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Minimize, StdArc, MinimizeArgs);
+REGISTER_FST_OPERATION(Minimize, LogArc, MinimizeArgs);
+REGISTER_FST_OPERATION(Minimize, Log64Arc, MinimizeArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <ostream>
+#include <string>
+
+#include <fst/script/fst-class.h>
+#include <fst/script/print.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void PrintFst(const FstClass &fst, std::ostream &ostrm, const string &dest,
+ const SymbolTable *isyms, const SymbolTable *osyms,
+ const SymbolTable *ssyms, bool accept, bool show_weight_one,
+ const string &missing_sym) {
+ const auto sep = FLAGS_fst_field_separator.substr(0, 1);
+ FstPrinterArgs args(fst, isyms, osyms, ssyms, accept, show_weight_one, &ostrm,
+ dest, sep, missing_sym);
+ Apply<Operation<FstPrinterArgs>>("PrintFst", fst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(PrintFst, StdArc, FstPrinterArgs);
+REGISTER_FST_OPERATION(PrintFst, LogArc, FstPrinterArgs);
+REGISTER_FST_OPERATION(PrintFst, Log64Arc, FstPrinterArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/project.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+
+void Project(MutableFstClass *ofst, ProjectType project_type) {
+ ProjectArgs args(ofst, project_type);
+ Apply<Operation<ProjectArgs>>("Project", ofst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Project, StdArc, ProjectArgs);
+REGISTER_FST_OPERATION(Project, LogArc, ProjectArgs);
+REGISTER_FST_OPERATION(Project, Log64Arc, ProjectArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/prune.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Prune(MutableFstClass *fst, const PruneOptions &opts) {
+ if (!fst->WeightTypesMatch(opts.weight_threshold, "Prune")) {
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ PruneArgs1 args(fst, opts);
+ Apply<Operation<PruneArgs1>>("Prune", fst->ArcType(), &args);
+}
+
+// 2
+void Prune(const FstClass &ifst, MutableFstClass *ofst,
+ const PruneOptions &opts) {
+ if (!ArcTypesMatch(ifst, *ofst, "Prune") ||
+ !ofst->WeightTypesMatch(opts.weight_threshold, "Prune")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ PruneArgs2 args(ifst, ofst, opts);
+ Apply<Operation<PruneArgs2>>("Prune", ofst->ArcType(), &args);
+}
+
+// 3
+void Prune(const FstClass &ifst, MutableFstClass *ofst,
+ const WeightClass &weight_threshold,
+ int64 state_threshold, float delta) {
+ if (!ArcTypesMatch(ifst, *ofst, "Prune") ||
+ !ofst->WeightTypesMatch(weight_threshold, "Prune")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ PruneArgs3 args(ifst, ofst, weight_threshold, state_threshold, delta);
+ Apply<Operation<PruneArgs3>>("Prune", ifst.ArcType(), &args);
+}
+
+// 4
+void Prune(MutableFstClass *fst, const WeightClass &weight_threshold,
+ int64 state_threshold, float delta) {
+ if (!fst->WeightTypesMatch(weight_threshold, "Prune")) {
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ PruneArgs4 args(fst, weight_threshold, state_threshold, delta);
+ Apply<Operation<PruneArgs4>>("Prune", fst->ArcType(), &args);
+}
+
+// 1
+REGISTER_FST_OPERATION(Prune, StdArc, PruneArgs1);
+REGISTER_FST_OPERATION(Prune, LogArc, PruneArgs1);
+REGISTER_FST_OPERATION(Prune, Log64Arc, PruneArgs1);
+
+// 2
+REGISTER_FST_OPERATION(Prune, StdArc, PruneArgs2);
+REGISTER_FST_OPERATION(Prune, LogArc, PruneArgs2);
+REGISTER_FST_OPERATION(Prune, Log64Arc, PruneArgs2);
+
+// 3
+REGISTER_FST_OPERATION(Prune, StdArc, PruneArgs3);
+REGISTER_FST_OPERATION(Prune, LogArc, PruneArgs3);
+REGISTER_FST_OPERATION(Prune, Log64Arc, PruneArgs3);
+
+// 4
+REGISTER_FST_OPERATION(Prune, StdArc, PruneArgs4);
+REGISTER_FST_OPERATION(Prune, LogArc, PruneArgs4);
+REGISTER_FST_OPERATION(Prune, Log64Arc, PruneArgs4);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/push.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Push(MutableFstClass *ofst, ReweightType dir, float delta,
+ bool remove_total_weight) {
+ PushArgs1 args(ofst, dir, delta, remove_total_weight);
+ Apply<Operation<PushArgs1>>("Push", ofst->ArcType(), &args);
+}
+
+// 2
+void Push(const FstClass &ifst, MutableFstClass *ofst, uint32 flags,
+ ReweightType dir, float delta) {
+ if (!ArcTypesMatch(ifst, *ofst, "Push")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ PushArgs2 args(ifst, ofst, flags, dir, delta);
+ Apply<Operation<PushArgs2>>("Push", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Push, StdArc, PushArgs1);
+REGISTER_FST_OPERATION(Push, LogArc, PushArgs1);
+REGISTER_FST_OPERATION(Push, Log64Arc, PushArgs1);
+
+REGISTER_FST_OPERATION(Push, StdArc, PushArgs2);
+REGISTER_FST_OPERATION(Push, LogArc, PushArgs2);
+REGISTER_FST_OPERATION(Push, Log64Arc, PushArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/randequivalent.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath,
+ float delta, time_t seed,
+ const RandGenOptions<RandArcSelection> &opts, bool *error) {
+ if (!ArcTypesMatch(fst1, fst2, "RandEquivalent")) return false;
+ RandEquivalentInnerArgs1 iargs(fst1, fst2, npath, delta, seed, opts, error);
+ RandEquivalentArgs1 args(iargs);
+ Apply<Operation<RandEquivalentArgs1>>("RandEquivalent", fst1.ArcType(),
+ &args);
+ return args.retval;
+}
+
+// 2
+bool RandEquivalent(const FstClass &fst1, const FstClass &fst2, int32 npath,
+ float delta, time_t seed, int32 max_length, bool *error) {
+ if (!ArcTypesMatch(fst1, fst2, "RandEquivalent")) return false;
+ RandEquivalentInnerArgs2 iargs(fst1, fst2, npath, delta, seed, max_length,
+ error);
+ RandEquivalentArgs2 args(iargs);
+ Apply<Operation<RandEquivalentArgs2>>("RandEquivalent", fst1.ArcType(),
+ &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(RandEquivalent, StdArc, RandEquivalentArgs1);
+REGISTER_FST_OPERATION(RandEquivalent, LogArc, RandEquivalentArgs1);
+REGISTER_FST_OPERATION(RandEquivalent, Log64Arc, RandEquivalentArgs1);
+
+REGISTER_FST_OPERATION(RandEquivalent, StdArc, RandEquivalentArgs2);
+REGISTER_FST_OPERATION(RandEquivalent, LogArc, RandEquivalentArgs2);
+REGISTER_FST_OPERATION(RandEquivalent, Log64Arc, RandEquivalentArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/randgen.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void RandGen(const FstClass &ifst, MutableFstClass *ofst, time_t seed,
+ const RandGenOptions<RandArcSelection> &opts) {
+ if (!ArcTypesMatch(ifst, *ofst, "RandGen")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ RandGenArgs args(ifst, ofst, seed, opts);
+ Apply<Operation<RandGenArgs>>("RandGen", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(RandGen, StdArc, RandGenArgs);
+REGISTER_FST_OPERATION(RandGen, LogArc, RandGenArgs);
+REGISTER_FST_OPERATION(RandGen, Log64Arc, RandGenArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/relabel.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void Relabel(MutableFstClass *ofst, const SymbolTable *old_isyms,
+ const SymbolTable *relabel_isyms, bool attach_new_isyms,
+ const SymbolTable *old_osyms, const SymbolTable *relabel_osyms,
+ bool attach_new_osyms) {
+ RelabelArgs1 args(ofst, old_isyms, relabel_isyms, attach_new_isyms, old_osyms,
+ relabel_osyms, attach_new_osyms);
+ Apply<Operation<RelabelArgs1>>("Relabel", ofst->ArcType(), &args);
+}
+
+// 2
+void Relabel(MutableFstClass *ofst, const std::vector<LabelPair> &ipairs,
+ const std::vector<LabelPair> &opairs) {
+ RelabelArgs2 args(ofst, ipairs, opairs);
+ Apply<Operation<RelabelArgs2>>("Relabel", ofst->ArcType(), &args);
+}
+
+// 3
+void Relabel(MutableFstClass *fst, const SymbolTable *new_isymbols,
+ const SymbolTable *new_osymbols) {
+ RelabelArgs3 args(fst, new_isymbols, new_osymbols);
+ Apply<Operation<RelabelArgs3>>("Relabel", fst->ArcType(), &args);
+}
+
+// 1
+REGISTER_FST_OPERATION(Relabel, StdArc, RelabelArgs1);
+REGISTER_FST_OPERATION(Relabel, LogArc, RelabelArgs1);
+REGISTER_FST_OPERATION(Relabel, Log64Arc, RelabelArgs1);
+
+// 2
+REGISTER_FST_OPERATION(Relabel, StdArc, RelabelArgs2);
+REGISTER_FST_OPERATION(Relabel, LogArc, RelabelArgs2);
+REGISTER_FST_OPERATION(Relabel, Log64Arc, RelabelArgs2);
+
+// 3
+REGISTER_FST_OPERATION(Relabel, StdArc, RelabelArgs3);
+REGISTER_FST_OPERATION(Relabel, LogArc, RelabelArgs3);
+REGISTER_FST_OPERATION(Relabel, Log64Arc, RelabelArgs3);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/replace.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Replace(const std::vector<LabelFstClassPair> &pairs, MutableFstClass *ofst,
+ const ReplaceOptions &opts) {
+ for (auto i = 0; i < pairs.size() - 1; ++i) {
+ if (!ArcTypesMatch(*pairs[i].second, *pairs[i + 1].second, "Replace")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ }
+ if (!ArcTypesMatch(*pairs[0].second, *ofst, "Replace")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ReplaceArgs args(pairs, ofst, opts);
+ Apply<Operation<ReplaceArgs>>("Replace", ofst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Replace, StdArc, ReplaceArgs);
+REGISTER_FST_OPERATION(Replace, LogArc, ReplaceArgs);
+REGISTER_FST_OPERATION(Replace, Log64Arc, ReplaceArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/reverse.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Reverse(const FstClass &ifst, MutableFstClass *ofst,
+ bool require_superinitial) {
+ if (!ArcTypesMatch(ifst, *ofst, "Reverse")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ReverseArgs args(ifst, ofst, require_superinitial);
+ Apply<Operation<ReverseArgs>>("Reverse", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Reverse, StdArc, ReverseArgs);
+REGISTER_FST_OPERATION(Reverse, LogArc, ReverseArgs);
+REGISTER_FST_OPERATION(Reverse, Log64Arc, ReverseArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/reweight.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+void Reweight(MutableFstClass *fst, const std::vector<WeightClass> &potential,
+ ReweightType reweight_type) {
+ ReweightArgs args(fst, potential, reweight_type);
+ Apply<Operation<ReweightArgs>>("Reweight", fst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Reweight, StdArc, ReweightArgs);
+REGISTER_FST_OPERATION(Reweight, LogArc, ReweightArgs);
+REGISTER_FST_OPERATION(Reweight, Log64Arc, ReweightArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/rmepsilon.h>
+#include <fst/script/script-impl.h>
+
+namespace fst {
+namespace script {
+
+// 1: Full signature with RmEpsilonOptions.
+void RmEpsilon(const FstClass &ifst, MutableFstClass *ofst, bool reverse,
+ const RmEpsilonOptions &opts) {
+ if (!ArcTypesMatch(ifst, *ofst, "RmEpsilon") ||
+ !ofst->WeightTypesMatch(opts.weight_threshold, "RmEpsilon")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ RmEpsilonArgs1 args(ifst, ofst, reverse, opts);
+ Apply<Operation<RmEpsilonArgs1>>("RmEpsilon", ifst.ArcType(), &args);
+}
+
+// 2: Full signature with flat arguments.
+void RmEpsilon(MutableFstClass *fst, bool connect,
+ const WeightClass &weight_threshold, int64 state_threshold,
+ float delta) {
+ if (!fst->WeightTypesMatch(weight_threshold, "RmEpsilon")) {
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ RmEpsilonArgs2 args(fst, connect, weight_threshold, state_threshold, delta);
+ Apply<Operation<RmEpsilonArgs2>>("RmEpsilon", fst->ArcType(), &args);
+}
+
+// #2 signature with default WeightClass argument.
+void RmEpsilon(MutableFstClass *fst, bool connect, int64 state_threshold,
+ float delta) {
+ const WeightClass weight_threshold = WeightClass::Zero(fst->WeightType());
+ RmEpsilon(fst, connect, weight_threshold, state_threshold, delta);
+}
+
+// 3: Full signature with RmEpsilonOptions and weight vector.
+void RmEpsilon(MutableFstClass *fst, std::vector<WeightClass> *distance,
+ const RmEpsilonOptions &opts) {
+ if (distance) {
+ for (auto it = distance->begin(); it != distance->end(); ++it) {
+ if (!fst->WeightTypesMatch(*it, "RmEpsilon")) {
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ }
+ }
+ if (!fst->WeightTypesMatch(opts.weight_threshold, "RmEpsilon")) {
+ fst->SetProperties(kError, kError);
+ return;
+ }
+ RmEpsilonArgs3 args(fst, distance, opts);
+ Apply<Operation<RmEpsilonArgs3>>("RmEpsilon", fst->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(RmEpsilon, StdArc, RmEpsilonArgs1);
+REGISTER_FST_OPERATION(RmEpsilon, LogArc, RmEpsilonArgs1);
+REGISTER_FST_OPERATION(RmEpsilon, Log64Arc, RmEpsilonArgs1);
+
+REGISTER_FST_OPERATION(RmEpsilon, StdArc, RmEpsilonArgs2);
+REGISTER_FST_OPERATION(RmEpsilon, LogArc, RmEpsilonArgs2);
+REGISTER_FST_OPERATION(RmEpsilon, Log64Arc, RmEpsilonArgs2);
+
+REGISTER_FST_OPERATION(RmEpsilon, StdArc, RmEpsilonArgs3);
+REGISTER_FST_OPERATION(RmEpsilon, LogArc, RmEpsilonArgs3);
+REGISTER_FST_OPERATION(RmEpsilon, Log64Arc, RmEpsilonArgs3);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+#include <fst/script/shortest-distance.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void ShortestDistance(const FstClass &fst, std::vector<WeightClass> *distance,
+ const ShortestDistanceOptions &opts) {
+ ShortestDistanceArgs1 args(fst, distance, opts);
+ Apply<Operation<ShortestDistanceArgs1>>("ShortestDistance", fst.ArcType(),
+ &args);
+}
+
+// 2
+void ShortestDistance(const FstClass &ifst, std::vector<WeightClass> *distance,
+ bool reverse, double delta) {
+ ShortestDistanceArgs2 args(ifst, distance, reverse, delta);
+ Apply<Operation<ShortestDistanceArgs2>>("ShortestDistance", ifst.ArcType(),
+ &args);
+}
+
+REGISTER_FST_OPERATION(ShortestDistance, StdArc, ShortestDistanceArgs1);
+REGISTER_FST_OPERATION(ShortestDistance, LogArc, ShortestDistanceArgs1);
+REGISTER_FST_OPERATION(ShortestDistance, Log64Arc, ShortestDistanceArgs1);
+
+REGISTER_FST_OPERATION(ShortestDistance, StdArc, ShortestDistanceArgs2);
+REGISTER_FST_OPERATION(ShortestDistance, LogArc, ShortestDistanceArgs2);
+REGISTER_FST_OPERATION(ShortestDistance, Log64Arc, ShortestDistanceArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+#include <fst/script/shortest-path.h>
+
+namespace fst {
+namespace script {
+
+// 1
+void ShortestPath(const FstClass &ifst, MutableFstClass *ofst,
+ std::vector<WeightClass> *distance,
+ const ShortestPathOptions &opts) {
+ if (!ArcTypesMatch(ifst, *ofst, "ShortestPath")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ShortestPathArgs1 args(ifst, ofst, distance, opts);
+ Apply<Operation<ShortestPathArgs1>>("ShortestPath", ifst.ArcType(), &args);
+}
+
+// 2
+void ShortestPath(const FstClass &ifst, MutableFstClass *ofst, int32 n,
+ bool unique, bool first_path,
+ const WeightClass &weight_threshold, int64 state_threshold) {
+ if (!ArcTypesMatch(ifst, *ofst, "ShortestPath")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ ShortestPathArgs2 args(ifst, ofst, n, unique, first_path, weight_threshold,
+ state_threshold);
+ Apply<Operation<ShortestPathArgs2>>("ShortestPath", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(ShortestPath, StdArc, ShortestPathArgs1);
+REGISTER_FST_OPERATION(ShortestPath, LogArc, ShortestPathArgs1);
+REGISTER_FST_OPERATION(ShortestPath, Log64Arc, ShortestPathArgs1);
+
+REGISTER_FST_OPERATION(ShortestPath, StdArc, ShortestPathArgs2);
+REGISTER_FST_OPERATION(ShortestPath, LogArc, ShortestPathArgs2);
+REGISTER_FST_OPERATION(ShortestPath, Log64Arc, ShortestPathArgs2);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/script-impl.h>
+#include <fst/script/stateiterator-class.h>
+
+namespace fst {
+namespace script {
+
+StateIteratorClass::StateIteratorClass(const FstClass &fst) : impl_(nullptr) {
+ InitStateIteratorClassArgs args(fst, this);
+ Apply<Operation<InitStateIteratorClassArgs>>("InitStateIteratorClass",
+ fst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(InitStateIteratorClass, StdArc,
+ InitStateIteratorClassArgs);
+REGISTER_FST_OPERATION(InitStateIteratorClass, LogArc,
+ InitStateIteratorClassArgs);
+REGISTER_FST_OPERATION(InitStateIteratorClass, Log64Arc,
+ InitStateIteratorClassArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+#include <fst/script/synchronize.h>
+
+namespace fst {
+namespace script {
+
+void Synchronize(const FstClass &ifst, MutableFstClass *ofst) {
+ if (!ArcTypesMatch(ifst, *ofst, "Synchronize")) {
+ ofst->SetProperties(kError, kError);
+ return;
+ }
+ SynchronizeArgs args(ifst, ofst);
+ Apply<Operation<SynchronizeArgs>>("Synchronize", ifst.ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Synchronize, StdArc, SynchronizeArgs);
+REGISTER_FST_OPERATION(Synchronize, LogArc, SynchronizeArgs);
+REGISTER_FST_OPERATION(Synchronize, Log64Arc, SynchronizeArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/text-io.h>
+
+#include <cstring>
+#include <fstream>
+#include <ostream>
+#include <sstream>
+#include <utility>
+
+#include <fst/types.h>
+#include <fstream>
+#include <fst/util.h>
+
+namespace fst {
+namespace script {
+
+// Reads vector of weights; returns true on success.
+bool ReadPotentials(const string &weight_type, const string &filename,
+ std::vector<WeightClass> *potentials) {
+ std::ifstream strm(filename.c_str());
+ if (!strm.good()) {
+ LOG(ERROR) << "ReadPotentials: Can't open file: " << filename;
+ return false;
+ }
+ static const int kLineLen = 8096;
+ char line[kLineLen];
+ size_t nline = 0;
+ potentials->clear();
+ while (!strm.getline(line, kLineLen).fail()) {
+ ++nline;
+ std::vector<char *> col;
+ SplitToVector(line, "\n\t ", &col, true);
+ if (col.size() == 0 || col[0][0] == '\0') continue;
+ if (col.size() != 2) {
+ FSTERROR() << "ReadPotentials: Bad number of columns, "
+ << "file = " << filename << ", line = " << nline;
+ return false;
+ }
+ ssize_t s = StrToInt64(col[0], filename, nline, false);
+ WeightClass weight(weight_type, col[1]);
+ while (potentials->size() <= s) {
+ potentials->push_back(WeightClass::Zero(weight_type));
+ }
+ potentials->back() = weight;
+ }
+ return true;
+}
+
+// Writes vector of weights; returns true on success.
+bool WritePotentials(const string &filename,
+ const std::vector<WeightClass> &potentials) {
+ std::ofstream fstrm;
+ if (!filename.empty()) {
+ fstrm.open(filename.c_str());
+ if (!fstrm) {
+ LOG(ERROR) << "WritePotentials: Can't open file: " << filename;
+ return false;
+ }
+ }
+ std::ostream &ostrm = fstrm.is_open() ? fstrm : std::cout;
+ ostrm.precision(9);
+ for (auto s = 0; s < potentials.size(); ++s)
+ ostrm << s << "\t" << potentials[s] << "\n";
+ if (ostrm.fail())
+ LOG(ERROR) << "WritePotentials: Write failed: "
+ << (filename.empty() ? "standard output" : filename);
+ return !ostrm;
+}
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+#include <fst/script/topsort.h>
+
+namespace fst {
+namespace script {
+
+bool TopSort(MutableFstClass *fst) {
+ TopSortArgs args(fst);
+ Apply<Operation<TopSortArgs>>("TopSort", fst->ArcType(), &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(TopSort, StdArc, TopSortArgs);
+REGISTER_FST_OPERATION(TopSort, LogArc, TopSortArgs);
+REGISTER_FST_OPERATION(TopSort, Log64Arc, TopSortArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+#include <fst/script/union.h>
+
+namespace fst {
+namespace script {
+
+void Union(MutableFstClass *fst1, const FstClass &fst2) {
+ if (!ArcTypesMatch(*fst1, fst2, "Union")) {
+ fst1->SetProperties(kError, kError);
+ return;
+ }
+ UnionArgs args(fst1, fst2);
+ Apply<Operation<UnionArgs>>("Union", fst1->ArcType(), &args);
+}
+
+REGISTER_FST_OPERATION(Union, StdArc, UnionArgs);
+REGISTER_FST_OPERATION(Union, LogArc, UnionArgs);
+REGISTER_FST_OPERATION(Union, Log64Arc, UnionArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/fst-class.h>
+#include <fst/script/script-impl.h>
+#include <fst/script/verify.h>
+
+namespace fst {
+namespace script {
+
+bool Verify(const FstClass &fst) {
+ VerifyArgs args(fst);
+ Apply<Operation<VerifyArgs>>("Verify", fst.ArcType(), &args);
+ return args.retval;
+}
+
+REGISTER_FST_OPERATION(Verify, StdArc, VerifyArgs);
+REGISTER_FST_OPERATION(Verify, LogArc, VerifyArgs);
+REGISTER_FST_OPERATION(Verify, Log64Arc, VerifyArgs);
+
+} // namespace script
+} // namespace fst
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+
+#include <fst/script/weight-class.h>
+
+namespace fst {
+namespace script {
+
+REGISTER_FST_WEIGHT(StdArc::Weight);
+REGISTER_FST_WEIGHT(LogArc::Weight);
+REGISTER_FST_WEIGHT(Log64Arc::Weight);
+
+WeightClass::WeightClass(const string &weight_type, const string &weight_str) {
+ WeightClassRegister *reg = WeightClassRegister::GetRegister();
+ StrToWeightImplBaseT stw = reg->GetEntry(weight_type);
+ if (!stw) {
+ FSTERROR() << "Unknown weight type: " << weight_type;
+ impl_.reset();
+ return;
+ }
+ impl_.reset(stw(weight_str, "WeightClass", 0));
+}
+
+WeightClass WeightClass::Zero(const string &weight_type) {
+ return WeightClass(weight_type, __ZERO__);
+}
+
+WeightClass WeightClass::One(const string &weight_type) {
+ return WeightClass(weight_type, __ONE__);
+}
+
+WeightClass WeightClass::NoWeight(const string &weight_type) {
+ return WeightClass(weight_type, __NOWEIGHT__);
+}
+
+bool WeightClass::WeightTypesMatch(const WeightClass &other,
+ const string &op_name) const {
+ if (Type() != other.Type()) {
+ FSTERROR() << "Weights with non-matching types passed to " << op_name
+ << ": " << Type() << " and " << other.Type();
+ return false;
+ }
+ return true;
+}
+
+bool operator==(const WeightClass &lhs, const WeightClass &rhs) {
+ const auto *lhs_impl = lhs.GetImpl();
+ const auto *rhs_impl = rhs.GetImpl();
+ if (!(lhs_impl && rhs_impl && lhs.WeightTypesMatch(rhs, "operator=="))) {
+ return false;
+ }
+ return *lhs_impl == *rhs_impl;
+}
+
+bool operator!=(const WeightClass &lhs, const WeightClass &rhs) {
+ return !(lhs == rhs);
+}
+
+WeightClass Plus(const WeightClass &lhs, const WeightClass &rhs) {
+ const auto *rhs_impl = rhs.GetImpl();
+ if (!(lhs.GetImpl() && rhs_impl && lhs.WeightTypesMatch(rhs, "Plus"))) {
+ return WeightClass();
+ }
+ WeightClass result(lhs);
+ result.GetImpl()->PlusEq(*rhs_impl);
+ return result;
+}
+
+WeightClass Times(const WeightClass &lhs, const WeightClass &rhs) {
+ const auto *rhs_impl = rhs.GetImpl();
+ if (!(lhs.GetImpl() && rhs_impl && lhs.WeightTypesMatch(rhs, "Plus"))) {
+ return WeightClass();
+ }
+ WeightClass result(lhs);
+ result.GetImpl()->TimesEq(*rhs_impl);
+ return result;
+}
+
+WeightClass Divide(const WeightClass &lhs, const WeightClass &rhs) {
+ const auto *rhs_impl = rhs.GetImpl();
+ if (!(lhs.GetImpl() && rhs_impl && lhs.WeightTypesMatch(rhs, "Divide"))) {
+ return WeightClass();
+ }
+ WeightClass result(lhs);
+ result.GetImpl()->DivideEq(*rhs_impl);
+ return result;
+}
+
+WeightClass Power(const WeightClass &weight, size_t n) {
+ if (!weight.GetImpl()) return WeightClass();
+ WeightClass result(weight);
+ result.GetImpl()->PowerEq(n);
+ return result;
+}
+
+std::ostream &operator<<(std::ostream &ostrm, const WeightClass &weight) {
+ weight.impl_->Print(&ostrm);
+ return ostrm;
+}
+
+} // namespace script
+} // namespace fst
--- /dev/null
+AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS)
+LDADD = ../lib/libfst.la -lm $(DL_LIBS)
+
+check_PROGRAMS = fst_test weight_test
+
+fst_test_SOURCES = fst_test.cc fst_test.h
+
+weight_test_SOURCES = weight_test.cc weight-tester.h
+
+algo_test_SOURCES = algo_test.cc algo_test.h rand-fst.h
+
+check_PROGRAMS += algo_test_log
+algo_test_log_SOURCES = $(algo_test_SOURCES)
+algo_test_log_CPPFLAGS = -DTEST_LOG $(AM_CPPFLAGS)
+
+check_PROGRAMS += algo_test_tropical
+algo_test_tropical_SOURCES = $(algo_test_SOURCES)
+algo_test_tropical_CPPFLAGS = -DTEST_TROPICAL $(AM_CPPFLAGS)
+
+check_PROGRAMS += algo_test_minmax
+algo_test_minmax_SOURCES = $(algo_test_SOURCES)
+algo_test_minmax_CPPFLAGS = -DTEST_MINMAX $(AM_CPPFLAGS)
+
+# check_PROGRAMS += algo_test_left_string
+# algo_test_left_string_SOURCES = $(algo_test_SOURCES)
+# algo_test_left_string_CPPFLAGS = -DTEST_LEFT_STRING $(AM_CPPFLAGS)
+
+# check_PROGRAMS += algo_test_right_string
+# algo_test_right_string_SOURCES = $(algo_test_SOURCES)
+# algo_test_right_string_CPPFLAGS = -DTEST_RIGHT_STRING $(AM_CPPFLAGS)
+
+# check_PROGRAMS += algo_test_gallic
+# algo_test_gallic_SOURCES = $(algo_test_SOURCES)
+# algo_test_gallic_CPPFLAGS = -DTEST_GALLIC $(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)
--- /dev/null
+# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+VPATH = @srcdir@
+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+check_PROGRAMS = fst_test$(EXEEXT) weight_test$(EXEEXT) \
+ algo_test_log$(EXEEXT) algo_test_tropical$(EXEEXT) \
+ algo_test_minmax$(EXEEXT) algo_test_lexicographic$(EXEEXT) \
+ algo_test_power$(EXEEXT)
+subdir = src/test
+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
+ $(top_srcdir)/depcomp $(top_srcdir)/test-driver
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_python_devel.m4 \
+ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
+ $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
+ $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+ $(top_builddir)/src/include/fst/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__objects_1 = algo_test_lexicographic-algo_test.$(OBJEXT)
+am_algo_test_lexicographic_OBJECTS = $(am__objects_1)
+algo_test_lexicographic_OBJECTS = \
+ $(am_algo_test_lexicographic_OBJECTS)
+algo_test_lexicographic_LDADD = $(LDADD)
+am__DEPENDENCIES_1 =
+algo_test_lexicographic_DEPENDENCIES = ../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 =
+am__objects_2 = algo_test_log-algo_test.$(OBJEXT)
+am_algo_test_log_OBJECTS = $(am__objects_2)
+algo_test_log_OBJECTS = $(am_algo_test_log_OBJECTS)
+algo_test_log_LDADD = $(LDADD)
+algo_test_log_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1)
+am__objects_3 = algo_test_minmax-algo_test.$(OBJEXT)
+am_algo_test_minmax_OBJECTS = $(am__objects_3)
+algo_test_minmax_OBJECTS = $(am_algo_test_minmax_OBJECTS)
+algo_test_minmax_LDADD = $(LDADD)
+algo_test_minmax_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1)
+am__objects_4 = algo_test_power-algo_test.$(OBJEXT)
+am_algo_test_power_OBJECTS = $(am__objects_4)
+algo_test_power_OBJECTS = $(am_algo_test_power_OBJECTS)
+algo_test_power_LDADD = $(LDADD)
+algo_test_power_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1)
+am__objects_5 = algo_test_tropical-algo_test.$(OBJEXT)
+am_algo_test_tropical_OBJECTS = $(am__objects_5)
+algo_test_tropical_OBJECTS = $(am_algo_test_tropical_OBJECTS)
+algo_test_tropical_LDADD = $(LDADD)
+algo_test_tropical_DEPENDENCIES = ../lib/libfst.la \
+ $(am__DEPENDENCIES_1)
+am_fst_test_OBJECTS = fst_test.$(OBJEXT)
+fst_test_OBJECTS = $(am_fst_test_OBJECTS)
+fst_test_LDADD = $(LDADD)
+fst_test_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1)
+am_weight_test_OBJECTS = weight_test.$(OBJEXT)
+weight_test_OBJECTS = $(am_weight_test_OBJECTS)
+weight_test_LDADD = $(LDADD)
+weight_test_DEPENDENCIES = ../lib/libfst.la $(am__DEPENDENCIES_1)
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+DEFAULT_INCLUDES =
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+ $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo " CXX " $@;
+am__v_CXX_1 =
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+ $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo " CXXLD " $@;
+am__v_CXXLD_1 =
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo " CC " $@;
+am__v_CC_1 =
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+ $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo " CCLD " $@;
+am__v_CCLD_1 =
+SOURCES = $(algo_test_lexicographic_SOURCES) $(algo_test_log_SOURCES) \
+ $(algo_test_minmax_SOURCES) $(algo_test_power_SOURCES) \
+ $(algo_test_tropical_SOURCES) $(fst_test_SOURCES) \
+ $(weight_test_SOURCES)
+DIST_SOURCES = $(algo_test_lexicographic_SOURCES) \
+ $(algo_test_log_SOURCES) $(algo_test_minmax_SOURCES) \
+ $(algo_test_power_SOURCES) $(algo_test_tropical_SOURCES) \
+ $(fst_test_SOURCES) $(weight_test_SOURCES)
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates. Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+ BEGIN { nonempty = 0; } \
+ { items[$$0] = 1; nonempty = 1; } \
+ END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique. This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+ list='$(am__tagged_files)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+am__tty_colors_dummy = \
+ mgn= red= grn= lgn= blu= brg= std=; \
+ am__color_tests=no
+am__tty_colors = { \
+ $(am__tty_colors_dummy); \
+ if test "X$(AM_COLOR_TESTS)" = Xno; then \
+ am__color_tests=no; \
+ elif test "X$(AM_COLOR_TESTS)" = Xalways; then \
+ am__color_tests=yes; \
+ elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \
+ am__color_tests=yes; \
+ fi; \
+ if test $$am__color_tests = yes; then \
+ red='\e[0;31m'; \
+ grn='\e[0;32m'; \
+ lgn='\e[1;32m'; \
+ blu='\e[1;34m'; \
+ mgn='\e[0;35m'; \
+ brg='\e[1m'; \
+ std='\e[m'; \
+ fi; \
+}
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__recheck_rx = ^[ ]*:recheck:[ ]*
+am__global_test_result_rx = ^[ ]*:global-test-result:[ ]*
+am__copy_in_global_log_rx = ^[ ]*:copy-in-global-log:[ ]*
+# A command that, given a newline-separated list of test names on the
+# standard input, print the name of the tests that are to be re-run
+# upon "make recheck".
+am__list_recheck_tests = $(AWK) '{ \
+ recheck = 1; \
+ while ((rc = (getline line < ($$0 ".trs"))) != 0) \
+ { \
+ if (rc < 0) \
+ { \
+ if ((getline line2 < ($$0 ".log")) < 0) \
+ recheck = 0; \
+ break; \
+ } \
+ else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \
+ { \
+ recheck = 0; \
+ break; \
+ } \
+ else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \
+ { \
+ break; \
+ } \
+ }; \
+ if (recheck) \
+ print $$0; \
+ close ($$0 ".trs"); \
+ close ($$0 ".log"); \
+}'
+# A command that, given a newline-separated list of test names on the
+# standard input, create the global log from their .trs and .log files.
+am__create_global_log = $(AWK) ' \
+function fatal(msg) \
+{ \
+ print "fatal: making $@: " msg | "cat >&2"; \
+ exit 1; \
+} \
+function rst_section(header) \
+{ \
+ print header; \
+ len = length(header); \
+ for (i = 1; i <= len; i = i + 1) \
+ printf "="; \
+ printf "\n\n"; \
+} \
+{ \
+ copy_in_global_log = 1; \
+ global_test_result = "RUN"; \
+ while ((rc = (getline line < ($$0 ".trs"))) != 0) \
+ { \
+ if (rc < 0) \
+ fatal("failed to read from " $$0 ".trs"); \
+ if (line ~ /$(am__global_test_result_rx)/) \
+ { \
+ sub("$(am__global_test_result_rx)", "", line); \
+ sub("[ ]*$$", "", line); \
+ global_test_result = line; \
+ } \
+ else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \
+ copy_in_global_log = 0; \
+ }; \
+ if (copy_in_global_log) \
+ { \
+ rst_section(global_test_result ": " $$0); \
+ while ((rc = (getline line < ($$0 ".log"))) != 0) \
+ { \
+ if (rc < 0) \
+ fatal("failed to read from " $$0 ".log"); \
+ print line; \
+ }; \
+ printf "\n"; \
+ }; \
+ close ($$0 ".trs"); \
+ close ($$0 ".log"); \
+}'
+# Restructured Text title.
+am__rst_title = { sed 's/.*/ & /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; }
+# Solaris 10 'make', and several other traditional 'make' implementations,
+# pass "-e" to $(SHELL), and POSIX 2008 even requires this. Work around it
+# by disabling -e (using the XSI extension "set +e") if it's set.
+am__sh_e_setup = case $$- in *e*) set +e;; esac
+# Default flags passed to test drivers.
+am__common_driver_flags = \
+ --color-tests "$$am__color_tests" \
+ --enable-hard-errors "$$am__enable_hard_errors" \
+ --expect-failure "$$am__expect_failure"
+# To be inserted before the command running the test. Creates the
+# directory for the log if needed. Stores in $dir the directory
+# containing $f, in $tst the test, in $log the log. Executes the
+# developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and
+# passes TESTS_ENVIRONMENT. Set up options for the wrapper that
+# will run the test scripts (or their associated LOG_COMPILER, if
+# thy have one).
+am__check_pre = \
+$(am__sh_e_setup); \
+$(am__vpath_adj_setup) $(am__vpath_adj) \
+$(am__tty_colors); \
+srcdir=$(srcdir); export srcdir; \
+case "$@" in \
+ */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;; \
+ *) am__odir=.;; \
+esac; \
+test "x$$am__odir" = x"." || test -d "$$am__odir" \
+ || $(MKDIR_P) "$$am__odir" || exit $$?; \
+if test -f "./$$f"; then dir=./; \
+elif test -f "$$f"; then dir=; \
+else dir="$(srcdir)/"; fi; \
+tst=$$dir$$f; log='$@'; \
+if test -n '$(DISABLE_HARD_ERRORS)'; then \
+ am__enable_hard_errors=no; \
+else \
+ am__enable_hard_errors=yes; \
+fi; \
+case " $(XFAIL_TESTS) " in \
+ *[\ \ ]$$f[\ \ ]* | *[\ \ ]$$dir$$f[\ \ ]*) \
+ am__expect_failure=yes;; \
+ *) \
+ am__expect_failure=no;; \
+esac; \
+$(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT)
+# A shell command to get the names of the tests scripts with any registered
+# extension removed (i.e., equivalently, the names of the test logs, with
+# the '.log' extension removed). The result is saved in the shell variable
+# '$bases'. This honors runtime overriding of TESTS and TEST_LOGS. Sadly,
+# we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)",
+# since that might cause problem with VPATH rewrites for suffix-less tests.
+# See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'.
+am__set_TESTS_bases = \
+ bases='$(TEST_LOGS)'; \
+ bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
+ bases=`echo $$bases`
+RECHECK_LOGS = $(TEST_LOGS)
+AM_RECURSIVE_TARGETS = check recheck
+TEST_SUITE_LOG = test-suite.log
+TEST_EXTENSIONS = @EXEEXT@ .test
+LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
+LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
+am__set_b = \
+ case '$@' in \
+ */*) \
+ case '$*' in \
+ */*) b='$*';; \
+ *) b=`echo '$@' | sed 's/\.log$$//'`; \
+ esac;; \
+ *) \
+ b='$*';; \
+ esac
+am__test_logs1 = $(TESTS:=.log)
+am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
+TEST_LOGS = $(am__test_logs2:.test.log=.log)
+TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
+TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
+ $(TEST_LOG_FLAGS)
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DL_LIBS = @DL_LIBS@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYTHON = @PYTHON@
+PYTHON_CPPFLAGS = @PYTHON_CPPFLAGS@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_EXTRA_LDFLAGS = @PYTHON_EXTRA_LDFLAGS@
+PYTHON_EXTRA_LIBS = @PYTHON_EXTRA_LIBS@
+PYTHON_LDFLAGS = @PYTHON_LDFLAGS@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_SITE_PKG = @PYTHON_SITE_PKG@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libfstdir = @libfstdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CPPFLAGS = -I$(srcdir)/../include $(ICU_CPPFLAGS)
+LDADD = ../lib/libfst.la -lm $(DL_LIBS)
+fst_test_SOURCES = fst_test.cc fst_test.h
+weight_test_SOURCES = weight_test.cc weight-tester.h
+algo_test_SOURCES = algo_test.cc algo_test.h rand-fst.h
+algo_test_log_SOURCES = $(algo_test_SOURCES)
+algo_test_log_CPPFLAGS = -DTEST_LOG $(AM_CPPFLAGS)
+algo_test_tropical_SOURCES = $(algo_test_SOURCES)
+algo_test_tropical_CPPFLAGS = -DTEST_TROPICAL $(AM_CPPFLAGS)
+algo_test_minmax_SOURCES = $(algo_test_SOURCES)
+algo_test_minmax_CPPFLAGS = -DTEST_MINMAX $(AM_CPPFLAGS)
+algo_test_lexicographic_SOURCES = $(algo_test_SOURCES)
+algo_test_lexicographic_CPPFLAGS = -DTEST_LEXICOGRAPHIC $(AM_CPPFLAGS)
+algo_test_power_SOURCES = $(algo_test_SOURCES)
+algo_test_power_CPPFLAGS = -DTEST_POWER $(AM_CPPFLAGS)
+TESTS = $(check_PROGRAMS)
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .lo .log .o .obj .test .test$(EXEEXT) .trs
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/test/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign src/test/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+
+clean-checkPROGRAMS:
+ @list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \
+ echo " rm -f" $$list; \
+ rm -f $$list || exit $$?; \
+ test -n "$(EXEEXT)" || exit 0; \
+ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+ echo " rm -f" $$list; \
+ rm -f $$list
+
+algo_test_lexicographic$(EXEEXT): $(algo_test_lexicographic_OBJECTS) $(algo_test_lexicographic_DEPENDENCIES) $(EXTRA_algo_test_lexicographic_DEPENDENCIES)
+ @rm -f algo_test_lexicographic$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(algo_test_lexicographic_OBJECTS) $(algo_test_lexicographic_LDADD) $(LIBS)
+
+algo_test_log$(EXEEXT): $(algo_test_log_OBJECTS) $(algo_test_log_DEPENDENCIES) $(EXTRA_algo_test_log_DEPENDENCIES)
+ @rm -f algo_test_log$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(algo_test_log_OBJECTS) $(algo_test_log_LDADD) $(LIBS)
+
+algo_test_minmax$(EXEEXT): $(algo_test_minmax_OBJECTS) $(algo_test_minmax_DEPENDENCIES) $(EXTRA_algo_test_minmax_DEPENDENCIES)
+ @rm -f algo_test_minmax$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(algo_test_minmax_OBJECTS) $(algo_test_minmax_LDADD) $(LIBS)
+
+algo_test_power$(EXEEXT): $(algo_test_power_OBJECTS) $(algo_test_power_DEPENDENCIES) $(EXTRA_algo_test_power_DEPENDENCIES)
+ @rm -f algo_test_power$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(algo_test_power_OBJECTS) $(algo_test_power_LDADD) $(LIBS)
+
+algo_test_tropical$(EXEEXT): $(algo_test_tropical_OBJECTS) $(algo_test_tropical_DEPENDENCIES) $(EXTRA_algo_test_tropical_DEPENDENCIES)
+ @rm -f algo_test_tropical$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(algo_test_tropical_OBJECTS) $(algo_test_tropical_LDADD) $(LIBS)
+
+fst_test$(EXEEXT): $(fst_test_OBJECTS) $(fst_test_DEPENDENCIES) $(EXTRA_fst_test_DEPENDENCIES)
+ @rm -f fst_test$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(fst_test_OBJECTS) $(fst_test_LDADD) $(LIBS)
+
+weight_test$(EXEEXT): $(weight_test_OBJECTS) $(weight_test_DEPENDENCIES) $(EXTRA_weight_test_DEPENDENCIES)
+ @rm -f weight_test$(EXEEXT)
+ $(AM_V_CXXLD)$(CXXLINK) $(weight_test_OBJECTS) $(weight_test_LDADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_lexicographic-algo_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_log-algo_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_minmax-algo_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_power-algo_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/algo_test_tropical-algo_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fst_test.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/weight_test.Po@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+algo_test_lexicographic-algo_test.o: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_lexicographic-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo -c -o algo_test_lexicographic-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo $(DEPDIR)/algo_test_lexicographic-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_lexicographic-algo_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_lexicographic-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+
+algo_test_lexicographic-algo_test.obj: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_lexicographic-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo -c -o algo_test_lexicographic-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_lexicographic-algo_test.Tpo $(DEPDIR)/algo_test_lexicographic-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_lexicographic-algo_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_lexicographic_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_lexicographic-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+
+algo_test_log-algo_test.o: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_log-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_log-algo_test.Tpo -c -o algo_test_log-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_log-algo_test.Tpo $(DEPDIR)/algo_test_log-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_log-algo_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_log-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+
+algo_test_log-algo_test.obj: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_log-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_log-algo_test.Tpo -c -o algo_test_log-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_log-algo_test.Tpo $(DEPDIR)/algo_test_log-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_log-algo_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_log_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_log-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+
+algo_test_minmax-algo_test.o: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_minmax-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_minmax-algo_test.Tpo -c -o algo_test_minmax-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_minmax-algo_test.Tpo $(DEPDIR)/algo_test_minmax-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_minmax-algo_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_minmax-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+
+algo_test_minmax-algo_test.obj: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_minmax-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_minmax-algo_test.Tpo -c -o algo_test_minmax-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_minmax-algo_test.Tpo $(DEPDIR)/algo_test_minmax-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_minmax-algo_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_minmax_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_minmax-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+
+algo_test_power-algo_test.o: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_power-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_power-algo_test.Tpo -c -o algo_test_power-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_power-algo_test.Tpo $(DEPDIR)/algo_test_power-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_power-algo_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_power-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+
+algo_test_power-algo_test.obj: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_power-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_power-algo_test.Tpo -c -o algo_test_power-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_power-algo_test.Tpo $(DEPDIR)/algo_test_power-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_power-algo_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_power_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_power-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+
+algo_test_tropical-algo_test.o: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_tropical-algo_test.o -MD -MP -MF $(DEPDIR)/algo_test_tropical-algo_test.Tpo -c -o algo_test_tropical-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_tropical-algo_test.Tpo $(DEPDIR)/algo_test_tropical-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_tropical-algo_test.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_tropical-algo_test.o `test -f 'algo_test.cc' || echo '$(srcdir)/'`algo_test.cc
+
+algo_test_tropical-algo_test.obj: algo_test.cc
+@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT algo_test_tropical-algo_test.obj -MD -MP -MF $(DEPDIR)/algo_test_tropical-algo_test.Tpo -c -o algo_test_tropical-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/algo_test_tropical-algo_test.Tpo $(DEPDIR)/algo_test_tropical-algo_test.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='algo_test.cc' object='algo_test_tropical-algo_test.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(algo_test_tropical_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o algo_test_tropical-algo_test.obj `if test -f 'algo_test.cc'; then $(CYGPATH_W) 'algo_test.cc'; else $(CYGPATH_W) '$(srcdir)/algo_test.cc'; fi`
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+ID: $(am__tagged_files)
+ $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ set x; \
+ here=`pwd`; \
+ $(am__define_uniq_tagged_files); \
+ shift; \
+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ if test $$# -gt 0; then \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ "$$@" $$unique; \
+ else \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$unique; \
+ fi; \
+ fi
+ctags: ctags-am
+
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+ $(am__define_uniq_tagged_files); \
+ test -z "$(CTAGS_ARGS)$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && $(am__cd) $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+
+cscopelist-am: $(am__tagged_files)
+ list='$(am__tagged_files)'; \
+ case "$(srcdir)" in \
+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+ *) sdir=$(subdir)/$(srcdir) ;; \
+ esac; \
+ for i in $$list; do \
+ if test -f "$$i"; then \
+ echo "$(subdir)/$$i"; \
+ else \
+ echo "$$sdir/$$i"; \
+ fi; \
+ done >> $(top_builddir)/cscope.files
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+# Recover from deleted '.trs' file; this should ensure that
+# "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create
+# both 'foo.log' and 'foo.trs'. Break the recipe in two subshells
+# to avoid problems with "make -n".
+.log.trs:
+ rm -f $< $@
+ $(MAKE) $(AM_MAKEFLAGS) $<
+
+# Leading 'am--fnord' is there to ensure the list of targets does not
+# expand to empty, as could happen e.g. with make check TESTS=''.
+am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck)
+am--force-recheck:
+ @:
+
+$(TEST_SUITE_LOG): $(TEST_LOGS)
+ @$(am__set_TESTS_bases); \
+ am__f_ok () { test -f "$$1" && test -r "$$1"; }; \
+ redo_bases=`for i in $$bases; do \
+ am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \
+ done`; \
+ if test -n "$$redo_bases"; then \
+ redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \
+ redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \
+ if $(am__make_dryrun); then :; else \
+ rm -f $$redo_logs && rm -f $$redo_results || exit 1; \
+ fi; \
+ fi; \
+ if test -n "$$am__remaking_logs"; then \
+ echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
+ "recursion detected" >&2; \
+ else \
+ am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
+ fi; \
+ if $(am__make_dryrun); then :; else \
+ st=0; \
+ errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \
+ for i in $$redo_bases; do \
+ test -f $$i.trs && test -r $$i.trs \
+ || { echo "$$errmsg $$i.trs" >&2; st=1; }; \
+ test -f $$i.log && test -r $$i.log \
+ || { echo "$$errmsg $$i.log" >&2; st=1; }; \
+ done; \
+ test $$st -eq 0 || exit 1; \
+ fi
+ @$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \
+ ws='[ ]'; \
+ results=`for b in $$bases; do echo $$b.trs; done`; \
+ test -n "$$results" || results=/dev/null; \
+ all=` grep "^$$ws*:test-result:" $$results | wc -l`; \
+ pass=` grep "^$$ws*:test-result:$$ws*PASS" $$results | wc -l`; \
+ fail=` grep "^$$ws*:test-result:$$ws*FAIL" $$results | wc -l`; \
+ skip=` grep "^$$ws*:test-result:$$ws*SKIP" $$results | wc -l`; \
+ xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \
+ xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \
+ error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \
+ if test `expr $$fail + $$xpass + $$error` -eq 0; then \
+ success=true; \
+ else \
+ success=false; \
+ fi; \
+ br='==================='; br=$$br$$br$$br$$br; \
+ result_count () \
+ { \
+ if test x"$$1" = x"--maybe-color"; then \
+ maybe_colorize=yes; \
+ elif test x"$$1" = x"--no-color"; then \
+ maybe_colorize=no; \
+ else \
+ echo "$@: invalid 'result_count' usage" >&2; exit 4; \
+ fi; \
+ shift; \
+ desc=$$1 count=$$2; \
+ if test $$maybe_colorize = yes && test $$count -gt 0; then \
+ color_start=$$3 color_end=$$std; \
+ else \
+ color_start= color_end=; \
+ fi; \
+ echo "$${color_start}# $$desc $$count$${color_end}"; \
+ }; \
+ create_testsuite_report () \
+ { \
+ result_count $$1 "TOTAL:" $$all "$$brg"; \
+ result_count $$1 "PASS: " $$pass "$$grn"; \
+ result_count $$1 "SKIP: " $$skip "$$blu"; \
+ result_count $$1 "XFAIL:" $$xfail "$$lgn"; \
+ result_count $$1 "FAIL: " $$fail "$$red"; \
+ result_count $$1 "XPASS:" $$xpass "$$red"; \
+ result_count $$1 "ERROR:" $$error "$$mgn"; \
+ }; \
+ { \
+ echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" | \
+ $(am__rst_title); \
+ create_testsuite_report --no-color; \
+ echo; \
+ echo ".. contents:: :depth: 2"; \
+ echo; \
+ for b in $$bases; do echo $$b; done \
+ | $(am__create_global_log); \
+ } >$(TEST_SUITE_LOG).tmp || exit 1; \
+ mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG); \
+ if $$success; then \
+ col="$$grn"; \
+ else \
+ col="$$red"; \
+ test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG); \
+ fi; \
+ echo "$${col}$$br$${std}"; \
+ echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}"; \
+ echo "$${col}$$br$${std}"; \
+ create_testsuite_report --maybe-color; \
+ echo "$$col$$br$$std"; \
+ if $$success; then :; else \
+ echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}"; \
+ if test -n "$(PACKAGE_BUGREPORT)"; then \
+ echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}"; \
+ fi; \
+ echo "$$col$$br$$std"; \
+ fi; \
+ $$success || exit 1
+
+check-TESTS:
+ @list='$(RECHECK_LOGS)'; test -z "$$list" || rm -f $$list
+ @list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
+ @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+ @set +e; $(am__set_TESTS_bases); \
+ log_list=`for i in $$bases; do echo $$i.log; done`; \
+ trs_list=`for i in $$bases; do echo $$i.trs; done`; \
+ log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
+ $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
+ exit $$?;
+recheck: all $(check_PROGRAMS)
+ @test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+ @set +e; $(am__set_TESTS_bases); \
+ bases=`for i in $$bases; do echo $$i; done \
+ | $(am__list_recheck_tests)` || exit 1; \
+ log_list=`for i in $$bases; do echo $$i.log; done`; \
+ log_list=`echo $$log_list`; \
+ $(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \
+ am__force_recheck=am--force-recheck \
+ TEST_LOGS="$$log_list"; \
+ exit $$?
+fst_test.log: fst_test$(EXEEXT)
+ @p='fst_test$(EXEEXT)'; \
+ b='fst_test'; \
+ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+weight_test.log: weight_test$(EXEEXT)
+ @p='weight_test$(EXEEXT)'; \
+ b='weight_test'; \
+ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+algo_test_log.log: algo_test_log$(EXEEXT)
+ @p='algo_test_log$(EXEEXT)'; \
+ b='algo_test_log'; \
+ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+algo_test_tropical.log: algo_test_tropical$(EXEEXT)
+ @p='algo_test_tropical$(EXEEXT)'; \
+ b='algo_test_tropical'; \
+ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+algo_test_minmax.log: algo_test_minmax$(EXEEXT)
+ @p='algo_test_minmax$(EXEEXT)'; \
+ b='algo_test_minmax'; \
+ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+algo_test_lexicographic.log: algo_test_lexicographic$(EXEEXT)
+ @p='algo_test_lexicographic$(EXEEXT)'; \
+ b='algo_test_lexicographic'; \
+ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+algo_test_power.log: algo_test_power$(EXEEXT)
+ @p='algo_test_power$(EXEEXT)'; \
+ b='algo_test_power'; \
+ $(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+.test.log:
+ @p='$<'; \
+ $(am__set_b); \
+ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
+ --log-file $$b.log --trs-file $$b.trs \
+ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
+ "$$tst" $(AM_TESTS_FD_REDIRECT)
+@am__EXEEXT_TRUE@.test$(EXEEXT).log:
+@am__EXEEXT_TRUE@ @p='$<'; \
+@am__EXEEXT_TRUE@ $(am__set_b); \
+@am__EXEEXT_TRUE@ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
+@am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \
+@am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
+@am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT)
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+ $(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
+ $(MAKE) $(AM_MAKEFLAGS) check-TESTS
+check: check-am
+all-am: Makefile
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+ -test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
+ -test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs)
+ -test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-checkPROGRAMS clean-generic clean-libtool \
+ mostlyclean-am
+
+distclean: distclean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -rf ./$(DEPDIR)
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: check-am install-am install-strip
+
+.PHONY: CTAGS GTAGS TAGS all all-am check check-TESTS check-am clean \
+ clean-checkPROGRAMS clean-generic clean-libtool cscopelist-am \
+ ctags ctags-am distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags distdir dvi dvi-am html \
+ html-am info info-am install install-am install-data \
+ install-data-am install-dvi install-dvi-am install-exec \
+ install-exec-am install-html install-html-am install-info \
+ install-info-am install-man install-pdf install-pdf-am \
+ install-ps install-ps-am install-strip installcheck \
+ installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic mostlyclean mostlyclean-compile \
+ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+ recheck tags tags-am uninstall uninstall-am
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Regression test for various FST algorithms.
+
+#include "./algo_test.h"
+
+#include <cstdlib>
+
+#include <vector>
+
+// DEFINEs determine which semirings are tested; these are controlled by
+// the `defines` attributes of the associated build rules.
+
+DEFINE_int32(seed, -1, "random seed");
+DEFINE_int32(repeat, 25, "number of test repetitions");
+
+using fst::AlgoTester;
+using fst::ArcTpl;
+using fst::GallicArc;
+using fst::GallicWeight;
+using fst::LexicographicArc;
+using fst::LexicographicWeight;
+using fst::LogArc;
+using fst::LogWeight;
+using fst::MinMaxArc;
+using fst::MinMaxWeight;
+using fst::PowerWeight;
+using fst::STRING_LEFT;
+using fst::STRING_RIGHT;
+using fst::StdArc;
+using fst::StringArc;
+using fst::StringWeight;
+using fst::TropicalWeight;
+using fst::WeightGenerate;
+
+int main(int argc, char **argv) {
+ FLAGS_fst_verify_properties = true;
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(argv[0], &argc, &argv, true);
+
+ static const int kCacheGcLimit = 20;
+
+ srand(FLAGS_seed);
+ LOG(INFO) << "Seed = " << FLAGS_seed;
+
+ FLAGS_fst_default_cache_gc = rand() % 2;
+ FLAGS_fst_default_cache_gc_limit = rand() % kCacheGcLimit;
+ VLOG(1) << "default_cache_gc:" << FLAGS_fst_default_cache_gc;
+ VLOG(1) << "default_cache_gc_limit:" << FLAGS_fst_default_cache_gc_limit;
+
+#ifdef TEST_TROPICAL
+ using TropicalWeightGenerate = WeightGenerate<TropicalWeight>;
+ TropicalWeightGenerate tropical_generator(false);
+ AlgoTester<StdArc, TropicalWeightGenerate> tropical_tester(
+ tropical_generator, FLAGS_seed);
+ tropical_tester.Test();
+#endif // TEST_TROPICAL
+
+#ifdef TEST_LOG
+ using LogWeightGenerate = WeightGenerate<LogWeight>;
+ LogWeightGenerate log_generator(false);
+ AlgoTester<LogArc, LogWeightGenerate> log_tester(log_generator, FLAGS_seed);
+ log_tester.Test();
+#endif // TEST_LOG
+
+#ifdef TEST_MINMAX
+ using MinMaxWeightGenerate = WeightGenerate<MinMaxWeight>;
+ MinMaxWeightGenerate minmax_generator(false);
+ AlgoTester<MinMaxArc, MinMaxWeightGenerate> minmax_tester(minmax_generator,
+ FLAGS_seed);
+ minmax_tester.Test();
+#endif
+
+#ifdef TEST_LEFT_STRING
+ using StringWeightGenerate = WeightGenerate<StringWeight<int, STRING_LEFT>>;
+ StringWeightGenerate left_string_generator(false);
+ AlgoTester<StringArc<>, StringWeightGenerate> left_string_tester(
+ left_string_generator, FLAGS_seed);
+ left_string_tester.Test();
+#endif // TEST_LEFT_STRING
+
+#ifdef TEST_RIGHT_STRING
+ using StringWeightGenerate =
+ WeightGenerate<StringWeight<int, STRING_RIGHT>>;
+ StringWeightGenerate right_string_generator(false);
+ AlgoTester<StringArc<STRING_RIGHT>, StringWeightGenerate>
+ right_string_tester(right_string_generator, FLAGS_seed);
+ right_string_tester.Test();
+#endif // TEST_RIGHT_STRING
+
+#ifdef TEST_GALLIC
+ using StdGallicArc = GallicArc<StdArc>;
+ using TropicalGallicWeightGenerate =
+ WeightGenerate<GallicWeight<int, TropicalWeight>>;
+ TropicalGallicWeightGenerate tropical_gallic_generator(false);
+ AlgoTester<StdGallicArc, TropicalGallicWeightGenerate> gallic_tester(
+ tropical_gallic_generator, FLAGS_seed);
+ gallic_tester.Test();
+#endif // TEST_GALLIC
+
+#ifdef TEST_LEXICOGRAPHIC
+ using TropicalLexicographicArc =
+ LexicographicArc<TropicalWeight, TropicalWeight>;
+ using TropicalLexicographicWeightGenerate =
+ WeightGenerate<LexicographicWeight<TropicalWeight, TropicalWeight>>;
+ TropicalLexicographicWeightGenerate lexicographic_generator(false);
+ AlgoTester<TropicalLexicographicArc, TropicalLexicographicWeightGenerate>
+ lexicographic_tester(lexicographic_generator, FLAGS_seed);
+ lexicographic_tester.Test();
+#endif // TEST_LEXICOGRAPHIC
+
+#ifdef TEST_POWER
+ using TropicalCubeWeight = PowerWeight<TropicalWeight, 3>;
+ using TropicalCubeArc = ArcTpl<TropicalCubeWeight>;
+ using TropicalCubeWeightGenerate = WeightGenerate<TropicalCubeWeight>;
+ TropicalCubeWeightGenerate tropical_cube_generator(false);
+ AlgoTester<TropicalCubeArc, TropicalCubeWeightGenerate> tropical_cube_tester(
+ tropical_cube_generator, FLAGS_seed);
+ tropical_cube_tester.Test();
+#endif // TEST_POWER
+
+ std::cout << "PASS" << std::endl;
+
+ return 0;
+}
--- /dev/null
+// 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 <fst/fstlib.h>
+#include "./rand-fst.h"
+
+DECLARE_int32(repeat); // defined in ./algo_test.cc
+
+namespace fst {
+
+// Mapper to change input and output label of every transition into
+// epsilons.
+template <class A>
+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 <class Arc>
+void LookAheadCompose(const Fst<Arc> &ifst1, const Fst<Arc> &ifst2,
+ MutableFst<Arc> *ofst) {
+ Compose(ifst1, ifst2, ofst);
+}
+
+// Specialized and epsilon olabel acyclic - lookahead.
+void LookAheadCompose(const Fst<StdArc> &ifst1, const Fst<StdArc> &ifst2,
+ MutableFst<StdArc> *ofst) {
+ std::vector<StdArc::StateId> order;
+ bool acyclic;
+ TopOrderVisitor<StdArc> visitor(&order, &acyclic);
+ DfsVisit(ifst1, &visitor, OutputEpsilonArcFilter<StdArc>());
+ if (acyclic) { // no ifst1 output epsilon cycles?
+ StdOLabelLookAheadFst lfst1(ifst1);
+ StdVectorFst lfst2(ifst2);
+ LabelLookAheadRelabeler<StdArc>::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 Arc, class WeightGenerator>
+class WeightedTester {
+ public:
+ typedef typename Arc::Label Label;
+ typedef typename Arc::StateId StateId;
+ typedef typename Arc::Weight Weight;
+
+ WeightedTester(time_t seed, const Fst<Arc> &zero_fst, const Fst<Arc> &one_fst,
+ const Fst<Arc> &univ_fst, WeightGenerator *weight_generator)
+ : seed_(seed),
+ zero_fst_(zero_fst),
+ one_fst_(one_fst),
+ univ_fst_(univ_fst),
+ weight_generator_(weight_generator) {}
+
+ void Test(const Fst<Arc> &T1, const Fst<Arc> &T2, const Fst<Arc> &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<Arc> &T1, const Fst<Arc> &T2,
+ const Fst<Arc> &T3) {
+ {
+ VLOG(1) << "Check destructive and delayed union are equivalent.";
+ VectorFst<Arc> U1(T1);
+ Union(&U1, T2);
+ UnionFst<Arc> U2(T1, T2);
+ CHECK(Equiv(U1, U2));
+ }
+
+ {
+ VLOG(1) << "Check destructive and delayed concatenation are equivalent.";
+ VectorFst<Arc> C1(T1);
+ Concat(&C1, T2);
+ ConcatFst<Arc> C2(T1, T2);
+ CHECK(Equiv(C1, C2));
+ VectorFst<Arc> C3(T2);
+ Concat(T1, &C3);
+ CHECK(Equiv(C3, C2));
+ }
+
+ {
+ VLOG(1) << "Check destructive and delayed closure* are equivalent.";
+ VectorFst<Arc> C1(T1);
+ Closure(&C1, CLOSURE_STAR);
+ ClosureFst<Arc> C2(T1, CLOSURE_STAR);
+ CHECK(Equiv(C1, C2));
+ }
+
+ {
+ VLOG(1) << "Check destructive and delayed closure+ are equivalent.";
+ VectorFst<Arc> C1(T1);
+ Closure(&C1, CLOSURE_PLUS);
+ ClosureFst<Arc> C2(T1, CLOSURE_PLUS);
+ CHECK(Equiv(C1, C2));
+ }
+
+ {
+ VLOG(1) << "Check union is associative (destructive).";
+ VectorFst<Arc> U1(T1);
+ Union(&U1, T2);
+ Union(&U1, T3);
+
+ VectorFst<Arc> U3(T2);
+ Union(&U3, T3);
+ VectorFst<Arc> U4(T1);
+ Union(&U4, U3);
+
+ CHECK(Equiv(U1, U4));
+ }
+
+ {
+ VLOG(1) << "Check union is associative (delayed).";
+ UnionFst<Arc> U1(T1, T2);
+ UnionFst<Arc> U2(U1, T3);
+
+ UnionFst<Arc> U3(T2, T3);
+ UnionFst<Arc> U4(T1, U3);
+
+ CHECK(Equiv(U2, U4));
+ }
+
+ {
+ VLOG(1) << "Check union is associative (destructive delayed).";
+ UnionFst<Arc> U1(T1, T2);
+ Union(&U1, T3);
+
+ UnionFst<Arc> U3(T2, T3);
+ UnionFst<Arc> U4(T1, U3);
+
+ CHECK(Equiv(U1, U4));
+ }
+
+ {
+ VLOG(1) << "Check concatenation is associative (destructive).";
+ VectorFst<Arc> C1(T1);
+ Concat(&C1, T2);
+ Concat(&C1, T3);
+
+ VectorFst<Arc> C3(T2);
+ Concat(&C3, T3);
+ VectorFst<Arc> C4(T1);
+ Concat(&C4, C3);
+
+ CHECK(Equiv(C1, C4));
+ }
+
+ {
+ VLOG(1) << "Check concatenation is associative (delayed).";
+ ConcatFst<Arc> C1(T1, T2);
+ ConcatFst<Arc> C2(C1, T3);
+
+ ConcatFst<Arc> C3(T2, T3);
+ ConcatFst<Arc> C4(T1, C3);
+
+ CHECK(Equiv(C2, C4));
+ }
+
+ {
+ VLOG(1) << "Check concatenation is associative (destructive delayed).";
+ ConcatFst<Arc> C1(T1, T2);
+ Concat(&C1, T3);
+
+ ConcatFst<Arc> C3(T2, T3);
+ ConcatFst<Arc> C4(T1, C3);
+
+ CHECK(Equiv(C1, C4));
+ }
+
+ if (Weight::Properties() & kLeftSemiring) {
+ VLOG(1) << "Check concatenation left distributes"
+ << " over union (destructive).";
+
+ VectorFst<Arc> U1(T1);
+ Union(&U1, T2);
+ VectorFst<Arc> C1(T3);
+ Concat(&C1, U1);
+
+ VectorFst<Arc> C2(T3);
+ Concat(&C2, T1);
+ VectorFst<Arc> C3(T3);
+ Concat(&C3, T2);
+ VectorFst<Arc> U2(C2);
+ Union(&U2, C3);
+
+ CHECK(Equiv(C1, U2));
+ }
+
+ if (Weight::Properties() & kRightSemiring) {
+ VLOG(1) << "Check concatenation right distributes"
+ << " over union (destructive).";
+ VectorFst<Arc> U1(T1);
+ Union(&U1, T2);
+ VectorFst<Arc> C1(U1);
+ Concat(&C1, T3);
+
+ VectorFst<Arc> C2(T1);
+ Concat(&C2, T3);
+ VectorFst<Arc> C3(T2);
+ Concat(&C3, T3);
+ VectorFst<Arc> U2(C2);
+ Union(&U2, C3);
+
+ CHECK(Equiv(C1, U2));
+ }
+
+ if (Weight::Properties() & kLeftSemiring) {
+ VLOG(1) << "Check concatenation left distributes over union (delayed).";
+ UnionFst<Arc> U1(T1, T2);
+ ConcatFst<Arc> C1(T3, U1);
+
+ ConcatFst<Arc> C2(T3, T1);
+ ConcatFst<Arc> C3(T3, T2);
+ UnionFst<Arc> U2(C2, C3);
+
+ CHECK(Equiv(C1, U2));
+ }
+
+ if (Weight::Properties() & kRightSemiring) {
+ VLOG(1) << "Check concatenation right distributes over union (delayed).";
+ UnionFst<Arc> U1(T1, T2);
+ ConcatFst<Arc> C1(U1, T3);
+
+ ConcatFst<Arc> C2(T1, T3);
+ ConcatFst<Arc> C3(T2, T3);
+ UnionFst<Arc> U2(C2, C3);
+
+ CHECK(Equiv(C1, U2));
+ }
+
+ if (Weight::Properties() & kLeftSemiring) {
+ VLOG(1) << "Check T T* == T+ (destructive).";
+ VectorFst<Arc> S(T1);
+ Closure(&S, CLOSURE_STAR);
+ VectorFst<Arc> C(T1);
+ Concat(&C, S);
+
+ VectorFst<Arc> P(T1);
+ Closure(&P, CLOSURE_PLUS);
+
+ CHECK(Equiv(C, P));
+ }
+
+ if (Weight::Properties() & kRightSemiring) {
+ VLOG(1) << "Check T* T == T+ (destructive).";
+ VectorFst<Arc> S(T1);
+ Closure(&S, CLOSURE_STAR);
+ VectorFst<Arc> C(S);
+ Concat(&C, T1);
+
+ VectorFst<Arc> P(T1);
+ Closure(&P, CLOSURE_PLUS);
+
+ CHECK(Equiv(C, P));
+ }
+
+ if (Weight::Properties() & kLeftSemiring) {
+ VLOG(1) << "Check T T* == T+ (delayed).";
+ ClosureFst<Arc> S(T1, CLOSURE_STAR);
+ ConcatFst<Arc> C(T1, S);
+
+ ClosureFst<Arc> P(T1, CLOSURE_PLUS);
+
+ CHECK(Equiv(C, P));
+ }
+
+ if (Weight::Properties() & kRightSemiring) {
+ VLOG(1) << "Check T* T == T+ (delayed).";
+ ClosureFst<Arc> S(T1, CLOSURE_STAR);
+ ConcatFst<Arc> C(S, T1);
+
+ ClosureFst<Arc> P(T1, CLOSURE_PLUS);
+
+ CHECK(Equiv(C, P));
+ }
+ }
+
+ // Tests map-based operations.
+ void TestMap(const Fst<Arc> &T) {
+ {
+ VLOG(1) << "Check destructive and delayed projection are equivalent.";
+ VectorFst<Arc> P1(T);
+ Project(&P1, PROJECT_INPUT);
+ ProjectFst<Arc> P2(T, PROJECT_INPUT);
+ CHECK(Equiv(P1, P2));
+ }
+
+ {
+ VLOG(1) << "Check destructive and delayed inversion are equivalent.";
+ VectorFst<Arc> I1(T);
+ Invert(&I1);
+ InvertFst<Arc> I2(T);
+ CHECK(Equiv(I1, I2));
+ }
+
+ {
+ VLOG(1) << "Check Pi_1(T) = Pi_2(T^-1) (destructive).";
+ VectorFst<Arc> P1(T);
+ VectorFst<Arc> I1(T);
+ Project(&P1, PROJECT_INPUT);
+ Invert(&I1);
+ Project(&I1, PROJECT_OUTPUT);
+ CHECK(Equiv(P1, I1));
+ }
+
+ {
+ VLOG(1) << "Check Pi_2(T) = Pi_1(T^-1) (destructive).";
+ VectorFst<Arc> P1(T);
+ VectorFst<Arc> I1(T);
+ Project(&P1, PROJECT_OUTPUT);
+ Invert(&I1);
+ Project(&I1, PROJECT_INPUT);
+ CHECK(Equiv(P1, I1));
+ }
+
+ {
+ VLOG(1) << "Check Pi_1(T) = Pi_2(T^-1) (delayed).";
+ ProjectFst<Arc> P1(T, PROJECT_INPUT);
+ InvertFst<Arc> I1(T);
+ ProjectFst<Arc> P2(I1, PROJECT_OUTPUT);
+ CHECK(Equiv(P1, P2));
+ }
+
+ {
+ VLOG(1) << "Check Pi_2(T) = Pi_1(T^-1) (delayed).";
+ ProjectFst<Arc> P1(T, PROJECT_OUTPUT);
+ InvertFst<Arc> I1(T);
+ ProjectFst<Arc> P2(I1, PROJECT_INPUT);
+ CHECK(Equiv(P1, P2));
+ }
+
+ {
+ VLOG(1) << "Check destructive relabeling";
+ static const int kNumLabels = 10;
+ // set up relabeling pairs
+ std::vector<Label> labelset(kNumLabels);
+ for (size_t i = 0; i < kNumLabels; ++i) labelset[i] = i;
+ for (size_t i = 0; i < kNumLabels; ++i) {
+ swap(labelset[i], labelset[rand() % kNumLabels]);
+ }
+
+ std::vector<std::pair<Label, Label>> ipairs1(kNumLabels);
+ std::vector<std::pair<Label, Label>> opairs1(kNumLabels);
+ for (size_t i = 0; i < kNumLabels; ++i) {
+ ipairs1[i] = std::make_pair(i, labelset[i]);
+ opairs1[i] = std::make_pair(labelset[i], i);
+ }
+ VectorFst<Arc> R(T);
+ Relabel(&R, ipairs1, opairs1);
+
+ std::vector<std::pair<Label, Label>> ipairs2(kNumLabels);
+ std::vector<std::pair<Label, Label>> opairs2(kNumLabels);
+ for (size_t i = 0; i < kNumLabels; ++i) {
+ ipairs2[i] = std::make_pair(labelset[i], i);
+ opairs2[i] = std::make_pair(i, labelset[i]);
+ }
+ Relabel(&R, ipairs2, opairs2);
+ CHECK(Equiv(R, T));
+
+ VLOG(1) << "Check on-the-fly relabeling";
+ RelabelFst<Arc> Rdelay(T, ipairs1, opairs1);
+
+ RelabelFst<Arc> RRdelay(Rdelay, ipairs2, opairs2);
+ CHECK(Equiv(RRdelay, T));
+ }
+
+ {
+ VLOG(1) << "Check encoding/decoding (destructive).";
+ VectorFst<Arc> D(T);
+ uint32 encode_props = 0;
+ if (rand() % 2) encode_props |= kEncodeLabels;
+ if (rand() % 2) encode_props |= kEncodeWeights;
+ EncodeMapper<Arc> encoder(encode_props, ENCODE);
+ Encode(&D, &encoder);
+ Decode(&D, encoder);
+ CHECK(Equiv(D, T));
+ }
+
+ {
+ VLOG(1) << "Check encoding/decoding (delayed).";
+ uint32 encode_props = 0;
+ if (rand() % 2) encode_props |= kEncodeLabels;
+ if (rand() % 2) encode_props |= kEncodeWeights;
+ EncodeMapper<Arc> encoder(encode_props, ENCODE);
+ EncodeFst<Arc> E(T, &encoder);
+ VectorFst<Arc> Encoded(E);
+ DecodeFst<Arc> D(Encoded, encoder);
+ CHECK(Equiv(D, T));
+ }
+
+ {
+ VLOG(1) << "Check gallic mappers (constructive).";
+ ToGallicMapper<Arc> to_mapper;
+ FromGallicMapper<Arc> from_mapper;
+ VectorFst<GallicArc<Arc>> G;
+ VectorFst<Arc> F;
+ ArcMap(T, &G, to_mapper);
+ ArcMap(G, &F, from_mapper);
+ CHECK(Equiv(T, F));
+ }
+
+ {
+ VLOG(1) << "Check gallic mappers (delayed).";
+ ToGallicMapper<Arc> to_mapper;
+ FromGallicMapper<Arc> from_mapper;
+ ArcMapFst<Arc, GallicArc<Arc>, ToGallicMapper<Arc>> G(T, to_mapper);
+ ArcMapFst<GallicArc<Arc>, Arc, FromGallicMapper<Arc>> F(G, from_mapper);
+ CHECK(Equiv(T, F));
+ }
+ }
+
+ // Tests compose-based operations.
+ void TestCompose(const Fst<Arc> &T1, const Fst<Arc> &T2, const Fst<Arc> &T3) {
+ if (!(Weight::Properties() & kCommutative)) return;
+
+ VectorFst<Arc> S1(T1);
+ VectorFst<Arc> S2(T2);
+ VectorFst<Arc> S3(T3);
+
+ ILabelCompare<Arc> icomp;
+ OLabelCompare<Arc> ocomp;
+
+ ArcSort(&S1, ocomp);
+ ArcSort(&S2, ocomp);
+ ArcSort(&S3, icomp);
+
+ {
+ VLOG(1) << "Check composition is associative.";
+ ComposeFst<Arc> C1(S1, S2);
+ ComposeFst<Arc> C2(C1, S3);
+ ComposeFst<Arc> C3(S2, S3);
+ ComposeFst<Arc> C4(S1, C3);
+
+ CHECK(Equiv(C2, C4));
+ }
+
+ {
+ VLOG(1) << "Check composition left distributes over union.";
+ UnionFst<Arc> U1(S2, S3);
+ ComposeFst<Arc> C1(S1, U1);
+
+ ComposeFst<Arc> C2(S1, S2);
+ ComposeFst<Arc> C3(S1, S3);
+ UnionFst<Arc> U2(C2, C3);
+
+ CHECK(Equiv(C1, U2));
+ }
+
+ {
+ VLOG(1) << "Check composition right distributes over union.";
+ UnionFst<Arc> U1(S1, S2);
+ ComposeFst<Arc> C1(U1, S3);
+
+ ComposeFst<Arc> C2(S1, S3);
+ ComposeFst<Arc> C3(S2, S3);
+ UnionFst<Arc> U2(C2, C3);
+
+ CHECK(Equiv(C1, U2));
+ }
+
+ VectorFst<Arc> A1(S1);
+ VectorFst<Arc> A2(S2);
+ VectorFst<Arc> A3(S3);
+ Project(&A1, PROJECT_OUTPUT);
+ Project(&A2, PROJECT_INPUT);
+ Project(&A3, PROJECT_INPUT);
+
+ {
+ VLOG(1) << "Check intersection is commutative.";
+ IntersectFst<Arc> I1(A1, A2);
+ IntersectFst<Arc> I2(A2, A1);
+ CHECK(Equiv(I1, I2));
+ }
+
+ {
+ VLOG(1) << "Check all epsilon filters leads to equivalent results.";
+ typedef Matcher<Fst<Arc>> M;
+ ComposeFst<Arc> C1(S1, S2);
+ ComposeFst<Arc> C2(
+ S1, S2, ComposeFstOptions<Arc, M, AltSequenceComposeFilter<M>>());
+ ComposeFst<Arc> C3(S1, S2,
+ ComposeFstOptions<Arc, M, MatchComposeFilter<M>>());
+
+ CHECK(Equiv(C1, C2));
+ CHECK(Equiv(C1, C3));
+
+ if ((Weight::Properties() & kIdempotent) ||
+ S1.Properties(kNoOEpsilons, false) ||
+ S2.Properties(kNoIEpsilons, false)) {
+ ComposeFst<Arc> C4(
+ S1, S2, ComposeFstOptions<Arc, M, TrivialComposeFilter<M>>());
+ CHECK(Equiv(C1, C4));
+ }
+
+ if (S1.Properties(kNoOEpsilons, false) &&
+ S2.Properties(kNoIEpsilons, false)) {
+ ComposeFst<Arc> C5(S1, S2,
+ ComposeFstOptions<Arc, M, NullComposeFilter<M>>());
+ CHECK(Equiv(C1, C5));
+ }
+ }
+
+ {
+ VLOG(1) << "Check look-ahead filters lead to equivalent results.";
+ VectorFst<Arc> C1, C2;
+ Compose(S1, S2, &C1);
+ LookAheadCompose(S1, S2, &C2);
+ CHECK(Equiv(C1, C2));
+ }
+ }
+
+ // Tests sorting operations
+ void TestSort(const Fst<Arc> &T) {
+ ILabelCompare<Arc> icomp;
+ OLabelCompare<Arc> ocomp;
+
+ {
+ VLOG(1) << "Check arc sorted Fst is equivalent to its input.";
+ VectorFst<Arc> S1(T);
+ ArcSort(&S1, icomp);
+ CHECK(Equiv(T, S1));
+ }
+
+ {
+ VLOG(1) << "Check destructive and delayed arcsort are equivalent.";
+ VectorFst<Arc> S1(T);
+ ArcSort(&S1, icomp);
+ ArcSortFst<Arc, ILabelCompare<Arc>> S2(T, icomp);
+ CHECK(Equiv(S1, S2));
+ }
+
+ {
+ VLOG(1) << "Check ilabel sorting vs. olabel sorting with inversions.";
+ VectorFst<Arc> S1(T);
+ VectorFst<Arc> S2(T);
+ ArcSort(&S1, icomp);
+ Invert(&S2);
+ ArcSort(&S2, ocomp);
+ Invert(&S2);
+ CHECK(Equiv(S1, S2));
+ }
+
+ {
+ VLOG(1) << "Check topologically sorted Fst is equivalent to its input.";
+ VectorFst<Arc> S1(T);
+ TopSort(&S1);
+ CHECK(Equiv(T, S1));
+ }
+
+ {
+ VLOG(1) << "Check reverse(reverse(T)) = T";
+ for (int i = 0; i < 2; ++i) {
+ VectorFst<ReverseArc<Arc>> R1;
+ VectorFst<Arc> R2;
+ bool require_superinitial = i == 1;
+ Reverse(T, &R1, require_superinitial);
+ Reverse(R1, &R2, require_superinitial);
+ CHECK(Equiv(T, R2));
+ }
+ }
+ }
+
+ // Tests optimization operations
+ void TestOptimize(const Fst<Arc> &T) {
+ uint64 tprops = T.Properties(kFstProperties, true);
+ uint64 wprops = Weight::Properties();
+
+ VectorFst<Arc> A(T);
+ Project(&A, PROJECT_INPUT);
+ {
+ VLOG(1) << "Check connected FST is equivalent to its input.";
+ VectorFst<Arc> C1(T);
+ Connect(&C1);
+ CHECK(Equiv(T, C1));
+ }
+
+ if ((wprops & kSemiring) == kSemiring &&
+ (tprops & kAcyclic || wprops & kIdempotent)) {
+ VLOG(1) << "Check epsilon-removed FST is equivalent to its input.";
+ VectorFst<Arc> R1(T);
+ RmEpsilon(&R1);
+ CHECK(Equiv(T, R1));
+
+ VLOG(1) << "Check destructive and delayed epsilon removal"
+ << "are equivalent.";
+ RmEpsilonFst<Arc> R2(T);
+ CHECK(Equiv(R1, R2));
+
+ VLOG(1) << "Check an FST with a large proportion"
+ << " of epsilon transitions:";
+ // Maps all transitions of T to epsilon-transitions and append
+ // a non-epsilon transition.
+ VectorFst<Arc> U;
+ ArcMap(T, &U, EpsMapper<Arc>());
+ VectorFst<Arc> V;
+ V.SetStart(V.AddState());
+ Arc arc(1, 1, Weight::One(), V.AddState());
+ V.AddArc(V.Start(), arc);
+ V.SetFinal(arc.nextstate, Weight::One());
+ Concat(&U, V);
+ // Check that epsilon-removal preserves the shortest-distance
+ // from the initial state to the final states.
+ std::vector<Weight> d;
+ ShortestDistance(U, &d, true);
+ Weight w = U.Start() < d.size() ? d[U.Start()] : Weight::Zero();
+ VectorFst<Arc> U1(U);
+ RmEpsilon(&U1);
+ ShortestDistance(U1, &d, true);
+ Weight w1 = U1.Start() < d.size() ? d[U1.Start()] : Weight::Zero();
+ CHECK(ApproxEqual(w, w1, kTestDelta));
+ RmEpsilonFst<Arc> U2(U);
+ ShortestDistance(U2, &d, true);
+ Weight w2 = U2.Start() < d.size() ? d[U2.Start()] : Weight::Zero();
+ CHECK(ApproxEqual(w, w2, kTestDelta));
+ }
+
+ if ((wprops & kSemiring) == kSemiring && tprops & kAcyclic) {
+ VLOG(1) << "Check determinized FSA is equivalent to its input.";
+ DeterminizeFst<Arc> D(A);
+ CHECK(Equiv(A, D));
+
+ {
+ VLOG(1) << "Check determinized FST is equivalent to its input.";
+ DeterminizeFstOptions<Arc> opts;
+ opts.type = DETERMINIZE_NONFUNCTIONAL;
+ DeterminizeFst<Arc> DT(T, opts);
+ CHECK(Equiv(T, DT));
+ }
+
+ if ((wprops & (kPath | kCommutative)) == (kPath | kCommutative)) {
+ VLOG(1) << "Check pruning in determinization";
+ VectorFst<Arc> P;
+ Weight threshold = (*weight_generator_)();
+ DeterminizeOptions<Arc> opts;
+ opts.weight_threshold = threshold;
+ Determinize(A, &P, opts);
+ CHECK(P.Properties(kIDeterministic, true));
+ CHECK(PruneEquiv(A, P, threshold));
+ }
+
+ if ((wprops & kPath) == kPath) {
+ VLOG(1) << "Check min-determinization";
+
+ // Ensures no input epsilons
+ VectorFst<Arc> R(T);
+ std::vector<std::pair<Label, Label>> ipairs, opairs;
+ ipairs.push_back(std::pair<Label, Label>(0, 1));
+ Relabel(&R, ipairs, opairs);
+
+ VectorFst<Arc> M;
+ DeterminizeOptions<Arc> opts;
+ opts.type = DETERMINIZE_DISAMBIGUATE;
+ Determinize(R, &M, opts);
+ CHECK(M.Properties(kIDeterministic, true));
+ CHECK(MinRelated(M, R));
+ }
+
+ int n;
+ {
+ VLOG(1) << "Check size(min(det(A))) <= size(det(A))"
+ << " and min(det(A)) equiv det(A)";
+ VectorFst<Arc> M(D);
+ n = M.NumStates();
+ Minimize(&M);
+ CHECK(Equiv(D, M));
+ CHECK(M.NumStates() <= n);
+ n = M.NumStates();
+ }
+
+ if (n && (wprops & kIdempotent) == kIdempotent &&
+ A.Properties(kNoEpsilons, true)) {
+ VLOG(1) << "Check that Revuz's algorithm leads to the"
+ << " same number of states as Brozozowski's algorithm";
+
+ // Skip test if A is the empty machine or contains epsilons or
+ // if the semiring is not idempotent (to avoid floating point
+ // errors)
+ VectorFst<Arc> R;
+ Reverse(A, &R);
+ RmEpsilon(&R);
+ DeterminizeFst<Arc> DR(R);
+ VectorFst<Arc> RD;
+ Reverse(DR, &RD);
+ DeterminizeFst<Arc> DRD(RD);
+ VectorFst<Arc> M(DRD);
+ CHECK_EQ(n + 1, M.NumStates()); // Accounts for the epsilon transition
+ // to the initial state
+ }
+ }
+
+ if ((wprops & kSemiring) == kSemiring && tprops & kAcyclic) {
+ VLOG(1) << "Check disambiguated FSA is equivalent to its input.";
+ VectorFst<Arc> R(A), D;
+ RmEpsilon(&R);
+ Disambiguate(R, &D);
+ CHECK(Equiv(R, D));
+ VLOG(1) << "Check disambiguated FSA is unambiguous";
+ CHECK(Unambiguous(D));
+
+ /* TODO(riley): find out why this fails
+ if ((wprops & (kPath | kCommutative)) == (kPath | kCommutative)) {
+ VLOG(1) << "Check pruning in disambiguation";
+ VectorFst<Arc> P;
+ Weight threshold = (*weight_generator_)();
+ DisambiguateOptions<Arc> opts;
+ opts.weight_threshold = threshold;
+ Disambiguate(R, &P, opts);
+ CHECK(Unambiguous(P));
+ CHECK(PruneEquiv(A, P, threshold));
+ }
+ */
+ }
+
+ if (Arc::Type() == LogArc::Type() || Arc::Type() == StdArc::Type()) {
+ VLOG(1) << "Check reweight(T) equiv T";
+ std::vector<Weight> potential;
+ VectorFst<Arc> RI(T);
+ VectorFst<Arc> RF(T);
+ while (potential.size() < RI.NumStates())
+ potential.push_back((*weight_generator_)());
+
+ Reweight(&RI, potential, REWEIGHT_TO_INITIAL);
+ CHECK(Equiv(T, RI));
+
+ Reweight(&RF, potential, REWEIGHT_TO_FINAL);
+ CHECK(Equiv(T, RF));
+ }
+
+ if ((wprops & kIdempotent) || (tprops & kAcyclic)) {
+ VLOG(1) << "Check pushed FST is equivalent to input FST.";
+ // Pushing towards the final state.
+ if (wprops & kRightSemiring) {
+ VectorFst<Arc> P1;
+ Push<Arc, REWEIGHT_TO_FINAL>(T, &P1, kPushLabels);
+ CHECK(Equiv(T, P1));
+
+ VectorFst<Arc> P2;
+ Push<Arc, REWEIGHT_TO_FINAL>(T, &P2, kPushWeights);
+ CHECK(Equiv(T, P2));
+
+ VectorFst<Arc> P3;
+ Push<Arc, REWEIGHT_TO_FINAL>(T, &P3, kPushLabels | kPushWeights);
+ CHECK(Equiv(T, P3));
+ }
+
+ // Pushing towards the initial state.
+ if (wprops & kLeftSemiring) {
+ VectorFst<Arc> P1;
+ Push<Arc, REWEIGHT_TO_INITIAL>(T, &P1, kPushLabels);
+ CHECK(Equiv(T, P1));
+
+ VectorFst<Arc> P2;
+ Push<Arc, REWEIGHT_TO_INITIAL>(T, &P2, kPushWeights);
+ CHECK(Equiv(T, P2));
+ VectorFst<Arc> P3;
+ Push<Arc, REWEIGHT_TO_INITIAL>(T, &P3, kPushLabels | kPushWeights);
+ CHECK(Equiv(T, P3));
+ }
+ }
+
+ if ((wprops & (kPath | kCommutative)) == (kPath | kCommutative)) {
+ VLOG(1) << "Check pruning algorithm";
+ {
+ VLOG(1) << "Check equiv. of constructive and destructive algorithms";
+ Weight thresold = (*weight_generator_)();
+ VectorFst<Arc> P1(T);
+ Prune(&P1, thresold);
+ VectorFst<Arc> P2;
+ Prune(T, &P2, thresold);
+ CHECK(Equiv(P1, P2));
+ }
+
+ {
+ VLOG(1) << "Check prune(reverse) equiv reverse(prune)";
+ Weight thresold = (*weight_generator_)();
+ VectorFst<ReverseArc<Arc>> R;
+ VectorFst<Arc> P1(T);
+ VectorFst<Arc> P2;
+ Prune(&P1, thresold);
+ Reverse(T, &R);
+ Prune(&R, thresold.Reverse());
+ Reverse(R, &P2);
+ CHECK(Equiv(P1, P2));
+ }
+ {
+ VLOG(1) << "Check: ShortestDistance(A - prune(A))"
+ << " > ShortestDistance(A) times Threshold";
+ Weight threshold = (*weight_generator_)();
+ VectorFst<Arc> P;
+ Prune(A, &P, threshold);
+ CHECK(PruneEquiv(A, P, threshold));
+ }
+ }
+ if (tprops & kAcyclic) {
+ VLOG(1) << "Check synchronize(T) equiv T";
+ SynchronizeFst<Arc> S(T);
+ CHECK(Equiv(T, S));
+ }
+ }
+
+ // Tests search operations
+ void TestSearch(const Fst<Arc> &T) {
+ uint64 wprops = Weight::Properties();
+
+ VectorFst<Arc> A(T);
+ Project(&A, PROJECT_INPUT);
+
+ if ((wprops & (kPath | kRightSemiring)) == (kPath | kRightSemiring)) {
+ VLOG(1) << "Check 1-best weight.";
+ VectorFst<Arc> path;
+ ShortestPath(T, &path);
+ Weight tsum = ShortestDistance(T);
+ Weight psum = ShortestDistance(path);
+ CHECK(ApproxEqual(tsum, psum, kTestDelta));
+ }
+
+ if ((wprops & (kPath | kSemiring)) == (kPath | kSemiring)) {
+ VLOG(1) << "Check n-best weights";
+ VectorFst<Arc> R(A);
+ RmEpsilon(&R);
+ int nshortest = rand() % kNumRandomShortestPaths + 2;
+ VectorFst<Arc> paths;
+ ShortestPath(R, &paths, nshortest, true, false, Weight::Zero(),
+ kNumShortestStates);
+ std::vector<Weight> distance;
+ ShortestDistance(paths, &distance, true);
+ StateId pstart = paths.Start();
+ if (pstart != kNoStateId) {
+ ArcIterator<Fst<Arc>> piter(paths, pstart);
+ for (; !piter.Done(); piter.Next()) {
+ StateId s = piter.Value().nextstate;
+ Weight nsum = s < distance.size()
+ ? Times(piter.Value().weight, distance[s])
+ : Weight::Zero();
+ VectorFst<Arc> path;
+ ShortestPath(R, &path);
+ Weight dsum = ShortestDistance(path);
+ CHECK(ApproxEqual(nsum, dsum, kTestDelta));
+ ArcMap(&path, RmWeightMapper<Arc>());
+ VectorFst<Arc> S;
+ Difference(R, path, &S);
+ R = S;
+ }
+ }
+ }
+ }
+
+ // Tests if two FSTS are equivalent by checking if random
+ // strings from one FST are transduced the same by both FSTs.
+ template <class A>
+ bool Equiv(const Fst<A> &fst1, const Fst<A> &fst2) {
+ VLOG(1) << "Check FSTs for sanity (including property bits).";
+ CHECK(Verify(fst1));
+ CHECK(Verify(fst2));
+
+ // Ensures seed used once per instantiation.
+ static UniformArcSelector<A> uniform_selector(seed_);
+ RandGenOptions<UniformArcSelector<A>> opts(uniform_selector,
+ kRandomPathLength);
+ return RandEquivalent(fst1, fst2, kNumRandomPaths, kTestDelta, opts);
+ }
+
+ // Tests FSA is unambiguous
+ bool Unambiguous(const Fst<Arc> &fst) {
+ VectorFst<StdArc> sfst, dfst;
+ VectorFst<LogArc> lfst1, lfst2;
+ Map(fst, &sfst, RmWeightMapper<Arc, StdArc>());
+ Determinize(sfst, &dfst);
+ Map(fst, &lfst1, RmWeightMapper<Arc, LogArc>());
+ Map(dfst, &lfst2, RmWeightMapper<StdArc, LogArc>());
+ 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 <class A>
+ bool MinRelated(const Fst<A> &fst1, const Fst<A> &fst2) {
+ // Same domain
+ VectorFst<Arc> P1(fst1), P2(fst2);
+ Project(&P1, PROJECT_INPUT);
+ Project(&P2, PROJECT_INPUT);
+ if (!Equiv(P1, P2)) {
+ LOG(ERROR) << "Inputs not equivalent";
+ return false;
+ }
+
+ // Ensures seed used once per instantiation.
+ static UniformArcSelector<A> uniform_selector(seed_);
+ RandGenOptions<UniformArcSelector<A>> opts(uniform_selector,
+ kRandomPathLength);
+
+ VectorFst<Arc> path, paths1, paths2;
+ for (ssize_t n = 0; n < kNumRandomPaths; ++n) {
+ RandGen(fst1, &path, opts);
+ Invert(&path);
+ Map(&path, RmWeightMapper<Arc>());
+ 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 <class A>
+ bool PruneEquiv(const Fst<A> &fst, const Fst<A> &pfst, Weight threshold) {
+ VLOG(1) << "Check FSTs for sanity (including property bits).";
+ CHECK(Verify(fst));
+ CHECK(Verify(pfst));
+
+ DifferenceFst<Arc> D(fst, DeterminizeFst<Arc>(RmEpsilonFst<Arc>(
+ ArcMapFst<Arc, Arc, RmWeightMapper<Arc>>(
+ pfst, RmWeightMapper<Arc>()))));
+ Weight sum1 = Times(ShortestDistance(fst), threshold);
+ Weight sum2 = ShortestDistance(D);
+ return ApproxEqual(Plus(sum1, sum2), sum1, kTestDelta);
+ }
+
+ // Random seed.
+ int seed_;
+ // FST with no states
+ VectorFst<Arc> zero_fst_;
+ // FST with one state that accepts epsilon.
+ VectorFst<Arc> one_fst_;
+ // FST with one state that accepts all strings.
+ VectorFst<Arc> univ_fst_;
+ // Generates weights used in testing.
+ WeightGenerator *weight_generator_;
+ // Maximum random path length.
+ static const int kRandomPathLength;
+ // Number of random paths to explore.
+ static const int kNumRandomPaths;
+ // Maximum number of nshortest paths.
+ static const int kNumRandomShortestPaths;
+ // Maximum number of nshortest states.
+ static const int kNumShortestStates;
+ // Delta for equivalence tests.
+ static const float kTestDelta;
+
+ WeightedTester(const WeightedTester &) = delete;
+ WeightedTester &operator=(const WeightedTester &) = delete;
+};
+
+template <class A, class WG>
+const int WeightedTester<A, WG>::kRandomPathLength = 25;
+
+template <class A, class WG>
+const int WeightedTester<A, WG>::kNumRandomPaths = 100;
+
+template <class A, class WG>
+const int WeightedTester<A, WG>::kNumRandomShortestPaths = 100;
+
+template <class A, class WG>
+const int WeightedTester<A, WG>::kNumShortestStates = 10000;
+
+template <class A, class WG>
+const float WeightedTester<A, WG>::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 Arc>
+class UnweightedTester {
+ public:
+ UnweightedTester(const Fst<Arc> &zero_fsa, const Fst<Arc> &one_fsa,
+ const Fst<Arc> &univ_fsa) {}
+
+ void Test(const Fst<Arc> &A1, const Fst<Arc> &A2, const Fst<Arc> &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<StdArc> {
+ public:
+ typedef StdArc Arc;
+ typedef Arc::Label Label;
+ typedef Arc::StateId StateId;
+ typedef Arc::Weight Weight;
+
+ UnweightedTester(const Fst<Arc> &zero_fsa, const Fst<Arc> &one_fsa,
+ const Fst<Arc> &univ_fsa)
+ : zero_fsa_(zero_fsa), one_fsa_(one_fsa), univ_fsa_(univ_fsa) {}
+
+ void Test(const Fst<Arc> &A1, const Fst<Arc> &A2, const Fst<Arc> &A3) {
+ TestRational(A1, A2, A3);
+ TestIntersect(A1, A2, A3);
+ TestOptimize(A1);
+ }
+
+ private:
+ // Tests rational operations with identities
+ void TestRational(const Fst<Arc> &A1, const Fst<Arc> &A2,
+ const Fst<Arc> &A3) {
+ {
+ VLOG(1) << "Check the union contains its arguments (destructive).";
+ VectorFst<Arc> U(A1);
+ Union(&U, A2);
+
+ CHECK(Subset(A1, U));
+ CHECK(Subset(A2, U));
+ }
+
+ {
+ VLOG(1) << "Check the union contains its arguments (delayed).";
+ UnionFst<Arc> U(A1, A2);
+
+ CHECK(Subset(A1, U));
+ CHECK(Subset(A2, U));
+ }
+
+ {
+ VLOG(1) << "Check if A^n c A* (destructive).";
+ VectorFst<Arc> C(one_fsa_);
+ int n = rand() % 5;
+ for (int i = 0; i < n; ++i) Concat(&C, A1);
+
+ VectorFst<Arc> S(A1);
+ Closure(&S, CLOSURE_STAR);
+ CHECK(Subset(C, S));
+ }
+
+ {
+ VLOG(1) << "Check if A^n c A* (delayed).";
+ int n = rand() % 5;
+ Fst<Arc> *C = new VectorFst<Arc>(one_fsa_);
+ for (int i = 0; i < n; ++i) {
+ ConcatFst<Arc> *F = new ConcatFst<Arc>(*C, A1);
+ delete C;
+ C = F;
+ }
+ ClosureFst<Arc> S(A1, CLOSURE_STAR);
+ CHECK(Subset(*C, S));
+ delete C;
+ }
+ }
+
+ // Tests intersect-based operations.
+ void TestIntersect(const Fst<Arc> &A1, const Fst<Arc> &A2,
+ const Fst<Arc> &A3) {
+ VectorFst<Arc> S1(A1);
+ VectorFst<Arc> S2(A2);
+ VectorFst<Arc> S3(A3);
+
+ ILabelCompare<Arc> comp;
+
+ ArcSort(&S1, comp);
+ ArcSort(&S2, comp);
+ ArcSort(&S3, comp);
+
+ {
+ VLOG(1) << "Check the intersection is contained in its arguments.";
+ IntersectFst<Arc> I1(S1, S2);
+ CHECK(Subset(I1, S1));
+ CHECK(Subset(I1, S2));
+ }
+
+ {
+ VLOG(1) << "Check union distributes over intersection.";
+ IntersectFst<Arc> I1(S1, S2);
+ UnionFst<Arc> U1(I1, S3);
+
+ UnionFst<Arc> U2(S1, S3);
+ UnionFst<Arc> U3(S2, S3);
+ ArcSortFst<Arc, ILabelCompare<Arc>> S4(U3, comp);
+ IntersectFst<Arc> I2(U2, S4);
+
+ CHECK(Equiv(U1, I2));
+ }
+
+ VectorFst<Arc> C1;
+ VectorFst<Arc> C2;
+ Complement(S1, &C1);
+ Complement(S2, &C2);
+ ArcSort(&C1, comp);
+ ArcSort(&C2, comp);
+
+ {
+ VLOG(1) << "Check S U S' = Sigma*";
+ UnionFst<Arc> U(S1, C1);
+ CHECK(Equiv(U, univ_fsa_));
+ }
+
+ {
+ VLOG(1) << "Check S n S' = {}";
+ IntersectFst<Arc> I(S1, C1);
+ CHECK(Equiv(I, zero_fsa_));
+ }
+
+ {
+ VLOG(1) << "Check (S1' U S2') == (S1 n S2)'";
+ UnionFst<Arc> U(C1, C2);
+
+ IntersectFst<Arc> I(S1, S2);
+ VectorFst<Arc> C3;
+ Complement(I, &C3);
+ CHECK(Equiv(U, C3));
+ }
+
+ {
+ VLOG(1) << "Check (S1' n S2') == (S1 U S2)'";
+ IntersectFst<Arc> I(C1, C2);
+
+ UnionFst<Arc> U(S1, S2);
+ VectorFst<Arc> C3;
+ Complement(U, &C3);
+ CHECK(Equiv(I, C3));
+ }
+ }
+
+ // Tests optimization operations
+ void TestOptimize(const Fst<Arc> &A) {
+ {
+ VLOG(1) << "Check determinized FSA is equivalent to its input.";
+ DeterminizeFst<Arc> D(A);
+ CHECK(Equiv(A, D));
+ }
+
+ {
+ VLOG(1) << "Check disambiguated FSA is equivalent to its input.";
+ VectorFst<Arc> 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<Arc> R(A);
+ DeterminizeFst<Arc> D(R);
+ VectorFst<Arc> M(D);
+ Minimize(&M);
+ CHECK(Equiv(A, M));
+ n = M.NumStates();
+ }
+
+ if (n) { // Skip test if A is the empty machine
+ VLOG(1) << "Check that Hopcroft's and Revuz's algorithms lead to the"
+ << " same number of states as Brozozowski's algorithm";
+ VectorFst<Arc> R;
+ Reverse(A, &R);
+ RmEpsilon(&R);
+ DeterminizeFst<Arc> DR(R);
+ VectorFst<Arc> RD;
+ Reverse(DR, &RD);
+ DeterminizeFst<Arc> DRD(RD);
+ VectorFst<Arc> 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<Arc> &fsa1, const Fst<Arc> &fsa2) {
+ VLOG(1) << "Check FSAs for sanity (including property bits).";
+ CHECK(Verify(fsa1));
+ CHECK(Verify(fsa2));
+
+ VectorFst<Arc> vfsa1(fsa1);
+ VectorFst<Arc> vfsa2(fsa2);
+ RmEpsilon(&vfsa1);
+ RmEpsilon(&vfsa2);
+ DeterminizeFst<Arc> dfa1(vfsa1);
+ DeterminizeFst<Arc> 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<Arc> comp;
+ VectorFst<Arc> sdfa1(dfa1);
+ ArcSort(&sdfa1, comp);
+ VectorFst<Arc> sdfa2(dfa2);
+ ArcSort(&sdfa2, comp);
+
+ DifferenceFst<Arc> dfsa1(sdfa1, sdfa2);
+ DifferenceFst<Arc> dfsa2(sdfa2, sdfa1);
+
+ VectorFst<Arc> ufsa(dfsa1);
+ Union(&ufsa, dfsa2);
+ Connect(&ufsa);
+ bool equiv2 = ufsa.NumStates() == 0;
+
+ // Check two equivalence tests match
+ CHECK((equiv1 && equiv2) || (!equiv1 && !equiv2));
+
+ return equiv1;
+ }
+
+ // Tests if FSA1 is a subset of FSA2 (disregarding weights).
+ bool Subset(const Fst<Arc> &fsa1, const Fst<Arc> &fsa2) {
+ VLOG(1) << "Check FSAs (incl. property bits) for sanity";
+ CHECK(Verify(fsa1));
+ CHECK(Verify(fsa2));
+
+ VectorFst<StdArc> vfsa1;
+ VectorFst<StdArc> vfsa2;
+ RmEpsilon(&vfsa1);
+ RmEpsilon(&vfsa2);
+ ILabelCompare<StdArc> comp;
+ ArcSort(&vfsa1, comp);
+ ArcSort(&vfsa2, comp);
+ IntersectFst<StdArc> ifsa(vfsa1, vfsa2);
+ DeterminizeFst<StdArc> dfa1(vfsa1);
+ DeterminizeFst<StdArc> dfa2(ifsa);
+ return Equivalent(dfa1, dfa2);
+ }
+
+ // Returns complement Fsa
+ void Complement(const Fst<Arc> &ifsa, MutableFst<Arc> *ofsa) {
+ RmEpsilonFst<Arc> rfsa(ifsa);
+ DeterminizeFst<Arc> dfa(rfsa);
+ DifferenceFst<Arc> cfsa(univ_fsa_, dfa);
+ *ofsa = cfsa;
+ }
+
+ // FSA with no states
+ VectorFst<Arc> zero_fsa_;
+
+ // FSA with one state that accepts epsilon.
+ VectorFst<Arc> one_fsa_;
+
+ // FSA with one state that accepts all strings.
+ VectorFst<Arc> univ_fsa_;
+};
+
+// This class tests a variety of identities and properties that must
+// hold for various FST algorithms. It randomly generates FSTs, using
+// function object 'weight_generator' to select weights. 'WeightTester'
+// and 'UnweightedTester' are then called.
+template <class Arc, class WeightGenerator>
+class AlgoTester {
+ public:
+ typedef typename Arc::Label Label;
+ typedef typename Arc::StateId StateId;
+ typedef typename Arc::Weight Weight;
+
+ AlgoTester(WeightGenerator generator, int seed)
+ : weight_generator_(generator) {
+ one_fst_.AddState();
+ one_fst_.SetStart(0);
+ one_fst_.SetFinal(0, Weight::One());
+
+ univ_fst_.AddState();
+ univ_fst_.SetStart(0);
+ univ_fst_.SetFinal(0, Weight::One());
+ for (int i = 0; i < kNumRandomLabels; ++i)
+ univ_fst_.AddArc(0, Arc(i, i, Weight::One(), 0));
+
+ weighted_tester_ = new WeightedTester<Arc, WeightGenerator>(
+ seed, zero_fst_, one_fst_, univ_fst_, &weight_generator_);
+
+ unweighted_tester_ =
+ new UnweightedTester<Arc>(zero_fst_, one_fst_, univ_fst_);
+ }
+
+ ~AlgoTester() {
+ delete weighted_tester_;
+ delete unweighted_tester_;
+ }
+
+ void MakeRandFst(MutableFst<Arc> *fst) {
+ RandFst<Arc, WeightGenerator>(kNumRandomStates, kNumRandomArcs,
+ kNumRandomLabels, kAcyclicProb,
+ &weight_generator_, fst);
+ }
+
+ void Test() {
+ VLOG(1) << "weight type = " << Weight::Type();
+
+ for (int i = 0; i < FLAGS_repeat; ++i) {
+ // Random transducers
+ VectorFst<Arc> T1;
+ VectorFst<Arc> T2;
+ VectorFst<Arc> T3;
+ MakeRandFst(&T1);
+ MakeRandFst(&T2);
+ MakeRandFst(&T3);
+ weighted_tester_->Test(T1, T2, T3);
+
+ VectorFst<Arc> A1(T1);
+ VectorFst<Arc> A2(T2);
+ VectorFst<Arc> A3(T3);
+ Project(&A1, PROJECT_OUTPUT);
+ Project(&A2, PROJECT_INPUT);
+ Project(&A3, PROJECT_INPUT);
+ ArcMap(&A1, rm_weight_mapper_);
+ ArcMap(&A2, rm_weight_mapper_);
+ ArcMap(&A3, rm_weight_mapper_);
+ unweighted_tester_->Test(A1, A2, A3);
+ }
+ }
+
+ private:
+ // Generates weights used in testing.
+ WeightGenerator weight_generator_;
+
+ // FST with no states
+ VectorFst<Arc> zero_fst_;
+
+ // FST with one state that accepts epsilon.
+ VectorFst<Arc> one_fst_;
+
+ // FST with one state that accepts all strings.
+ VectorFst<Arc> univ_fst_;
+
+ // Tests weighted FSTs
+ WeightedTester<Arc, WeightGenerator> *weighted_tester_;
+
+ // Tests unweighted FSTs
+ UnweightedTester<Arc> *unweighted_tester_;
+
+ // Mapper to remove weights from an Fst
+ RmWeightMapper<Arc> 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 <class A, class G>
+const int AlgoTester<A, G>::kNumRandomStates = 10;
+
+template <class A, class G>
+const int AlgoTester<A, G>::kNumRandomArcs = 25;
+
+template <class A, class G>
+const int AlgoTester<A, G>::kNumRandomLabels = 5;
+
+template <class A, class G>
+const float AlgoTester<A, G>::kAcyclicProb = .25;
+
+template <class A, class G>
+const int AlgoTester<A, G>::kRandomPathLength = 25;
+
+template <class A, class G>
+const int AlgoTester<A, G>::kNumRandomPaths = 100;
+
+} // namespace fst
+
+#endif // FST_TEST_ALGO_TEST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Regression test for FST classes.
+
+#include "./fst_test.h"
+
+#include <utility>
+
+#include <fst/compact-fst.h>
+#include <fst/const-fst.h>
+#include <fst/edit-fst.h>
+#include <fst/matcher-fst.h>
+
+namespace fst {
+namespace {
+
+// A user-defined arc type.
+struct CustomArc {
+ typedef short Label;
+ typedef ProductWeight<TropicalWeight, LogWeight> Weight;
+ typedef int64 StateId;
+
+ CustomArc(Label i, Label o, Weight w, StateId s)
+ : ilabel(i), olabel(o), weight(std::move(w)), nextstate(s) {}
+ CustomArc() {}
+
+ static const string &Type() { // Arc type name
+ static const string type = "my";
+ return type;
+ }
+
+ Label ilabel; // Transition input label
+ Label olabel; // Transition output label
+ Weight weight; // Transition weight
+ StateId nextstate; // Transition destination state
+};
+
+// A user-defined compactor for test FST.
+template <class A>
+class CustomCompactor {
+ public:
+ typedef A Arc;
+ typedef typename A::Label Label;
+ typedef typename A::StateId StateId;
+ typedef typename A::Weight Weight;
+ typedef std::pair<Label, Weight> Element;
+
+ Element Compact(StateId s, const A &arc) const {
+ return std::make_pair(arc.ilabel, arc.weight);
+ }
+
+ Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const {
+ return p.first == kNoLabel ? Arc(kNoLabel, kNoLabel, p.second, kNoStateId)
+ : Arc(p.first, 0, p.second, s);
+ }
+
+ ssize_t Size() const { return -1; }
+
+ uint64 Properties() const { return 0ULL; }
+
+ bool Compatible(const Fst<A> &fst) const { return true; }
+
+ static const string &Type() {
+ static const string type = "my";
+ return type;
+ }
+
+ bool Write(std::ostream &strm) const { return true; }
+
+ static CustomCompactor *Read(std::istream &strm) {
+ return new CustomCompactor;
+ }
+};
+
+REGISTER_FST(VectorFst, CustomArc);
+REGISTER_FST(ConstFst, CustomArc);
+static fst::FstRegisterer<CompactFst<StdArc, CustomCompactor<StdArc>>>
+ CompactFst_StdArc_CustomCompactor_registerer;
+static fst::FstRegisterer<CompactFst<CustomArc, CustomCompactor<CustomArc>>>
+ CompactFst_CustomArc_CustomCompactor_registerer;
+static fst::FstRegisterer<ConstFst<StdArc, uint16>>
+ ConstFst_StdArc_uint16_registerer;
+static fst::FstRegisterer<
+ CompactFst<StdArc, CustomCompactor<StdArc>, uint16>>
+ CompactFst_StdArc_CustomCompactor_uint16_registerer;
+
+} // namespace
+} // namespace fst
+
+using fst::FstTester;
+using fst::VectorFst;
+using fst::ConstFst;
+using fst::MatcherFst;
+using fst::CompactFst;
+using fst::Fst;
+using fst::StdArc;
+using fst::CustomArc;
+using fst::CustomCompactor;
+using fst::StdArcLookAheadFst;
+using fst::EditFst;
+
+int main(int argc, char **argv) {
+ FLAGS_fst_verify_properties = true;
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(argv[0], &argc, &argv, true);
+
+ // VectorFst<StdArc> tests
+ {
+ FstTester<VectorFst<StdArc>> 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<StdArc> tests
+ {
+ FstTester<ConstFst<StdArc>> std_const_tester;
+ std_const_tester.TestBase();
+ std_const_tester.TestExpanded();
+ std_const_tester.TestCopy();
+ std_const_tester.TestIO();
+ }
+
+ // CompactFst<StdArc, CustomCompactor<StdArc>>
+ {
+ FstTester<CompactFst<StdArc, CustomCompactor<StdArc>>> std_compact_tester;
+ std_compact_tester.TestBase();
+ std_compact_tester.TestExpanded();
+ std_compact_tester.TestCopy();
+ std_compact_tester.TestIO();
+ }
+
+ // VectorFst<CustomArc> tests
+ {
+ FstTester<VectorFst<CustomArc>> 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<CustomArc> tests
+ {
+ FstTester<ConstFst<CustomArc>> std_const_tester;
+ std_const_tester.TestBase();
+ std_const_tester.TestExpanded();
+ std_const_tester.TestCopy();
+ std_const_tester.TestIO();
+ }
+
+ // CompactFst<CustomArc, CustomCompactor<CustomArc>>
+ {
+ FstTester<CompactFst<CustomArc, CustomCompactor<CustomArc>>>
+ std_compact_tester;
+ std_compact_tester.TestBase();
+ std_compact_tester.TestExpanded();
+ std_compact_tester.TestCopy();
+ std_compact_tester.TestIO();
+ }
+
+ // ConstFst<StdArc, uint16> tests
+ {
+ FstTester<ConstFst<StdArc, uint16>> std_const_tester;
+ std_const_tester.TestBase();
+ std_const_tester.TestExpanded();
+ std_const_tester.TestCopy();
+ std_const_tester.TestIO();
+ }
+
+ // CompactFst<StdArc, CustomCompactor<StdArc>, uint16>
+ {
+ FstTester<CompactFst<StdArc, CustomCompactor<StdArc>, uint16>>
+ std_compact_tester;
+ std_compact_tester.TestBase();
+ std_compact_tester.TestExpanded();
+ std_compact_tester.TestCopy();
+ std_compact_tester.TestIO();
+ }
+
+ // FstTester<StdArcLookAheadFst>
+ {
+ FstTester<StdArcLookAheadFst> std_matcher_tester;
+ std_matcher_tester.TestBase();
+ std_matcher_tester.TestExpanded();
+ std_matcher_tester.TestCopy();
+ }
+
+ // EditFst<StdArc> tests
+ {
+ FstTester<EditFst<StdArc>> 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;
+}
--- /dev/null
+// 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 <fst/equal.h>
+#include <fstream>
+#include <fst/matcher.h>
+#include <fst/vector-fst.h>
+#include <fst/verify.h>
+
+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 F>
+class FstTester {
+ public:
+ typedef typename F::Arc Arc;
+ typedef typename Arc::StateId StateId;
+ typedef typename Arc::Weight Weight;
+ typedef typename Arc::Label Label;
+
+ FstTester() {
+ VectorFst<Arc> vfst;
+ InitFst(&vfst, 128);
+ testfst_ = new F(vfst);
+ }
+
+ explicit FstTester(F *testfst) : testfst_(testfst) {}
+
+ ~FstTester() { delete testfst_; }
+
+ // This verifies the contents described in InitFst() using
+ // methods defined in a generic Fst.
+ template <class G>
+ void TestBase(const G &fst) const {
+ CHECK(Verify(fst));
+ CHECK_EQ(fst.Start(), 0);
+ StateId ns = 0;
+ StateIterator<G> siter(fst);
+ Matcher<G> matcher(fst, MATCH_INPUT);
+ MatchType match_type = matcher.Type(true);
+ for (; !siter.Done(); siter.Next()) {
+ }
+ for (siter.Reset(); !siter.Done(); siter.Next()) {
+ StateId s = siter.Value();
+ matcher.SetState(s);
+ CHECK_EQ(fst.Final(s), NthWeight(s));
+ size_t na = 0;
+ ArcIterator<G> aiter(fst, s);
+ for (; !aiter.Done(); aiter.Next()) {
+ }
+ for (aiter.Reset(); !aiter.Done(); aiter.Next()) {
+ ++na;
+ const Arc &arc = aiter.Value();
+ CHECK_EQ(arc.ilabel, na);
+ CHECK_EQ(arc.olabel, 0);
+ CHECK_EQ(arc.weight, NthWeight(na));
+ CHECK_EQ(arc.nextstate, s);
+ if (match_type == MATCH_INPUT) {
+ CHECK(matcher.Find(arc.ilabel));
+ CHECK_EQ(matcher.Value().ilabel, arc.ilabel);
+ }
+ }
+ CHECK_EQ(na, s);
+ CHECK_EQ(na, aiter.Position());
+ CHECK_EQ(fst.NumArcs(s), s);
+ CHECK_EQ(fst.NumInputEpsilons(s), 0);
+ CHECK_EQ(fst.NumOutputEpsilons(s), s);
+ CHECK(!matcher.Find(s + 1)); // out-of-range
+ CHECK(!matcher.Find(kNoLabel)); // no explicit epsilons
+ CHECK(matcher.Find(0));
+ CHECK_EQ(matcher.Value().ilabel, kNoLabel); // implicit epsilon loop
+ ++ns;
+ }
+ CHECK(fst.Properties(kNotAcceptor, true));
+ CHECK(fst.Properties(kOEpsilons, true));
+ }
+
+ void TestBase() const { TestBase(*testfst_); }
+
+ // This verifies methods specfic to an ExpandedFst.
+ template <class G>
+ void TestExpanded(const G &fst) const {
+ StateId ns = 0;
+ for (StateIterator<G> 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 <class G>
+ void TestMutable(G *fst) const {
+ for (StateIterator<G> siter(*fst); !siter.Done(); siter.Next()) {
+ StateId s = siter.Value();
+ size_t na = 0;
+ size_t ni = fst->NumInputEpsilons(s);
+ MutableArcIterator<G> 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<G> siter(*cfst2); !siter.Done(); siter.Next()) {
+ StateId s = siter.Value();
+ cfst2->DeleteArcs(s);
+ CHECK_EQ(cfst2->NumArcs(s), 0);
+ CHECK_EQ(cfst2->NumInputEpsilons(s), 0);
+ CHECK_EQ(cfst2->NumOutputEpsilons(s), 0);
+ }
+ delete cfst2;
+ }
+
+ void TestMutable() { TestMutable(testfst_); }
+
+ // This verifies the copy methods.
+ template <class G>
+ void TestAssign(G *fst) const {
+ // Assignment from G
+ G afst1;
+ afst1 = *fst;
+ CHECK(Equal(*fst, afst1));
+
+ // Assignment from Fst
+ G afst2;
+ afst2 = *static_cast<const Fst<Arc> *>(fst);
+ CHECK(Equal(*fst, afst2));
+
+ // Assignment from self
+ afst2.operator=(afst2);
+ CHECK(Equal(*fst, afst2));
+ }
+
+ void TestAssign() { TestAssign(testfst_); }
+
+ // This verifies the copy methods.
+ template <class G>
+ void TestCopy(const G &fst) const {
+ // Copy from G
+ G c1fst(fst);
+ TestBase(c1fst);
+
+ // Copy from Fst
+ const G c2fst(static_cast<const Fst<Arc> &>(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 <class G>
+ void TestIO(const G &fst) const {
+ const string filename = FLAGS_tmpdir + "/test.fst";
+ const string aligned = FLAGS_tmpdir + "/aligned.fst";
+ {
+ // write/read
+ CHECK(fst.Write(filename));
+ G *ffst = G::Read(filename);
+ CHECK(ffst);
+ TestBase(*ffst);
+ delete ffst;
+ }
+
+ {
+ // generic read/cast/test
+ Fst<Arc> *gfst = Fst<Arc>::Read(filename);
+ CHECK(gfst);
+ G *dfst = static_cast<G *>(gfst);
+ TestBase(*dfst);
+
+ // generic write/read/test
+ CHECK(gfst->Write(filename));
+ Fst<Arc> *hfst = Fst<Arc>::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.c_str());
+ FstWriteOptions opts;
+ opts.source = aligned;
+ opts.align = true;
+ CHECK(fst.Write(ostr, opts));
+ }
+ std::ifstream istr(aligned.c_str());
+ 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.c_str());
+ FstWriteOptions opts;
+ opts.source = aligned;
+ opts.align = false;
+ CHECK(fst.Write(ostr, opts));
+ }
+ std::ifstream istr(aligned.c_str());
+ 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<Arc> *efst = ExpandedFst<Arc>::Read(filename);
+ CHECK(efst);
+ TestBase(*efst);
+ TestExpanded(*efst);
+ delete efst;
+ }
+
+ // mutable write/read/test
+ if (fst.Properties(kMutable, false)) {
+ MutableFst<Arc> *mfst = MutableFst<Arc>::Read(filename);
+ CHECK(mfst);
+ TestBase(*mfst);
+ TestExpanded(*mfst);
+ TestMutable(mfst);
+ delete mfst;
+ }
+ }
+
+ void TestIO() const { TestIO(*testfst_); }
+
+ private:
+ // This constructs test FSTs. Given a mutable FST, will leave
+ // the FST as follows:
+ // (I) NumStates() = nstates
+ // (II) Start() = 0
+ // (III) Final(s) = NthWeight(s)
+ // (IV) For state s:
+ // (a) NumArcs(s) == s
+ // (b) For ith arc of s:
+ // (1) ilabel = i
+ // (2) olabel = 0
+ // (3) weight = NthWeight(i)
+ // (4) nextstate = s
+ void InitFst(MutableFst<Arc> *fst, size_t nstates) const {
+ fst->DeleteStates();
+ CHECK_GT(nstates, 0);
+
+ for (StateId s = 0; s < nstates; ++s) {
+ fst->AddState();
+ fst->SetFinal(s, NthWeight(s));
+ for (size_t i = 1; i <= s; ++i) {
+ Arc arc(i, 0, NthWeight(i), s);
+ fst->AddArc(s, arc);
+ }
+ }
+
+ fst->SetStart(0);
+ }
+
+ // Generates One() + ... + One() (n times)
+ Weight NthWeight(int n) const {
+ Weight w = Weight::Zero();
+ for (int i = 0; i < n; ++i) w = Plus(w, Weight::One());
+ return w;
+ }
+
+ F *testfst_; // what we're testing
+};
+
+} // namespace fst
+
+#endif // FST_TEST_FST_TEST_H_
--- /dev/null
+#ifndef FST_TEST_RAND_FST_H_
+#define FST_TEST_RAND_FST_H_
+
+#include <fst/mutable-fst.h>
+#include <fst/verify.h>
+
+namespace fst {
+
+// Generates a random FST.
+template <class Arc, class WeightGenerator>
+void RandFst(const int num_random_states, const int num_random_arcs,
+ const int num_random_labels, const float acyclic_prob,
+ WeightGenerator *weight_generator, MutableFst<Arc> *fst) {
+ typedef typename Arc::Label Label;
+ typedef typename Arc::StateId StateId;
+ typedef typename Arc::Weight Weight;
+
+ // Determines direction of the arcs wrt state numbering. This way we
+ // can force acyclicity when desired.
+ enum ArcDirection {
+ ANY_DIRECTION = 0,
+ FORWARD_DIRECTION = 1,
+ REVERSE_DIRECTION = 2,
+ NUM_DIRECTIONS = 3
+ };
+
+ ArcDirection arc_direction = ANY_DIRECTION;
+ if (rand() / (RAND_MAX + 1.0) < acyclic_prob)
+ arc_direction = rand() % 2 ? FORWARD_DIRECTION : REVERSE_DIRECTION;
+
+ fst->DeleteStates();
+ StateId ns = rand() % num_random_states;
+
+ if (ns == 0) return;
+ for (StateId s = 0; s < ns; ++s) fst->AddState();
+
+ StateId start = rand() % ns;
+ fst->SetStart(start);
+
+ size_t na = rand() % num_random_arcs;
+ for (size_t n = 0; n < na; ++n) {
+ StateId s = rand() % ns;
+ Arc arc;
+ arc.ilabel = rand() % num_random_labels;
+ arc.olabel = rand() % num_random_labels;
+ arc.weight = (*weight_generator)();
+ arc.nextstate = rand() % ns;
+
+ if ((arc_direction == FORWARD_DIRECTION ||
+ arc_direction == REVERSE_DIRECTION) &&
+ s == arc.nextstate) {
+ continue; // skips self-loops
+ }
+
+ if ((arc_direction == FORWARD_DIRECTION && s > arc.nextstate) ||
+ (arc_direction == REVERSE_DIRECTION && s < arc.nextstate)) {
+ StateId t = s; // reverses arcs
+ s = arc.nextstate;
+ arc.nextstate = t;
+ }
+
+ fst->AddArc(s, arc);
+ }
+
+ StateId nf = rand() % (ns + 1);
+ for (StateId n = 0; n < nf; ++n) {
+ StateId s = rand() % ns;
+ Weight final = (*weight_generator)();
+ fst->SetFinal(s, final);
+ }
+ VLOG(1) << "Check FST for sanity (including property bits).";
+ CHECK(Verify(*fst));
+
+ // Get/compute all properties.
+ uint64 props = fst->Properties(kFstProperties, true);
+
+ // Select random set of properties to be unknown.
+ uint64 mask = 0;
+ for (int n = 0; n < 8; ++n) {
+ mask |= rand() & 0xff;
+ mask <<= 8;
+ }
+ mask &= ~kTrinaryProperties;
+ fst->SetProperties(props & ~mask, mask);
+}
+
+} // namespace fst
+
+#endif // FST_TEST_RAND_FST_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Utility class for regression testing of FST weights.
+
+#ifndef FST_TEST_WEIGHT_TESTER_H_
+#define FST_TEST_WEIGHT_TESTER_H_
+
+#include <iostream>
+#include <sstream>
+
+#include <utility>
+
+#include <fst/weight.h>
+
+namespace fst {
+
+// This class tests a variety of identities and properties that must
+// hold for the Weight class to be well-defined. It calls function object
+// WEIGHT_GENERATOR to select weights that are used in the tests.
+template <class Weight, class WeightGenerator>
+class WeightTester {
+ public:
+ WeightTester(WeightGenerator generator)
+ : weight_generator_(std::move(generator)) {}
+
+ void Test(int iterations, bool test_division = true) {
+ for (int i = 0; i < iterations; ++i) {
+ // Selects the test weights.
+ const Weight w1(weight_generator_());
+ const Weight w2(weight_generator_());
+ const Weight w3(weight_generator_());
+
+ VLOG(1) << "weight type = " << Weight::Type();
+ VLOG(1) << "w1 = " << w1;
+ VLOG(1) << "w2 = " << w2;
+ VLOG(1) << "w3 = " << w3;
+
+ TestSemiring(w1, w2, w3);
+ if (test_division) TestDivision(w1, w2);
+ TestReverse(w1, w2);
+ TestEquality(w1, w2, w3);
+ TestIO(w1);
+ TestCopy(w1);
+ }
+ }
+
+ private:
+ // Note in the tests below we use ApproxEqual rather than == and add
+ // kDelta to inequalities where the weights might be inexact.
+
+ // Tests (Plus, Times, Zero, One) defines a commutative semiring.
+ void TestSemiring(Weight w1, Weight w2, Weight w3) {
+ // Checks that the operations are closed.
+ CHECK(Plus(w1, w2).Member());
+ CHECK(Times(w1, w2).Member());
+
+ // Checks that the operations are associative.
+ CHECK(ApproxEqual(Plus(w1, Plus(w2, w3)), Plus(Plus(w1, w2), w3)));
+ CHECK(ApproxEqual(Times(w1, Times(w2, w3)), Times(Times(w1, w2), w3)));
+
+ // Checks the identity elements.
+ CHECK(Plus(w1, Weight::Zero()) == w1);
+ CHECK(Plus(Weight::Zero(), w1) == w1);
+ CHECK(Times(w1, Weight::One()) == w1);
+ CHECK(Times(Weight::One(), w1) == w1);
+
+ // Check the no weight element.
+ CHECK(!Weight::NoWeight().Member());
+ CHECK(!Plus(w1, Weight::NoWeight()).Member());
+ CHECK(!Plus(Weight::NoWeight(), w1).Member());
+ CHECK(!Times(w1, Weight::NoWeight()).Member());
+ CHECK(!Times(Weight::NoWeight(), w1).Member());
+
+ // Checks that the operations commute.
+ CHECK(ApproxEqual(Plus(w1, w2), Plus(w2, w1)));
+
+ if (Weight::Properties() & kCommutative)
+ CHECK(ApproxEqual(Times(w1, w2), Times(w2, w1)));
+
+ // Checks Zero() is the annihilator.
+ CHECK(Times(w1, Weight::Zero()) == Weight::Zero());
+ CHECK(Times(Weight::Zero(), w1) == Weight::Zero());
+
+ // Check Power(w, 0) is Weight::One()
+ CHECK(Power(w1, 0) == Weight::One());
+
+ // Check Power(w, 1) is w
+ CHECK(Power(w1, 1) == w1);
+
+ // Check Power(w, 3) is Times(w, Times(w, w))
+ CHECK(Power(w1, 3) == Times(w1, Times(w1, w1)));
+
+ // Checks distributivity.
+ if (Weight::Properties() & kLeftSemiring) {
+ CHECK(ApproxEqual(Times(w1, Plus(w2, w3)),
+ Plus(Times(w1, w2), Times(w1, w3))));
+ }
+ if (Weight::Properties() & kRightSemiring)
+ CHECK(ApproxEqual(Times(Plus(w1, w2), w3),
+ Plus(Times(w1, w3), Times(w2, w3))));
+
+ if (Weight::Properties() & kIdempotent) CHECK(Plus(w1, w1) == w1);
+
+ if (Weight::Properties() & kPath)
+ CHECK(Plus(w1, w2) == w1 || Plus(w1, w2) == w2);
+
+ // Ensure weights form a left or right semiring.
+ CHECK(Weight::Properties() & (kLeftSemiring | kRightSemiring));
+
+ // Check when Times() is commutative that it is marked as a semiring.
+ if (Weight::Properties() & kCommutative)
+ CHECK(Weight::Properties() & kSemiring);
+ }
+
+ // Tests division operation.
+ void TestDivision(Weight w1, Weight w2) {
+ Weight p = Times(w1, w2);
+
+ if (Weight::Properties() & kLeftSemiring) {
+ Weight d = Divide(p, w1, DIVIDE_LEFT);
+ if (d.Member()) CHECK(ApproxEqual(p, Times(w1, d)));
+ CHECK(!Divide(w1, Weight::NoWeight(), DIVIDE_LEFT).Member());
+ CHECK(!Divide(Weight::NoWeight(), w1, DIVIDE_LEFT).Member());
+ }
+
+ if (Weight::Properties() & kRightSemiring) {
+ Weight d = Divide(p, w2, DIVIDE_RIGHT);
+ if (d.Member()) CHECK(ApproxEqual(p, Times(d, w2)));
+ CHECK(!Divide(w1, Weight::NoWeight(), DIVIDE_RIGHT).Member());
+ CHECK(!Divide(Weight::NoWeight(), w1, DIVIDE_RIGHT).Member());
+ }
+
+ if (Weight::Properties() & kCommutative) {
+ Weight d = Divide(p, w1, DIVIDE_RIGHT);
+ if (d.Member()) CHECK(ApproxEqual(p, Times(d, w1)));
+ }
+ }
+
+ // Tests reverse operation.
+ void TestReverse(Weight w1, Weight w2) {
+ typedef typename Weight::ReverseWeight ReverseWeight;
+
+ ReverseWeight rw1 = w1.Reverse();
+ ReverseWeight rw2 = w2.Reverse();
+
+ CHECK(rw1.Reverse() == w1);
+ CHECK(Plus(w1, w2).Reverse() == Plus(rw1, rw2));
+ CHECK(Times(w1, w2).Reverse() == Times(rw2, rw1));
+ }
+
+ // Tests == is an equivalence relation.
+ void TestEquality(Weight w1, Weight w2, Weight w3) {
+ // Checks reflexivity.
+ CHECK(w1 == w1);
+
+ // Checks symmetry.
+ CHECK((w1 == w2) == (w2 == w1));
+
+ // Checks transitivity.
+ if (w1 == w2 && w2 == w3) CHECK(w1 == w3);
+ }
+
+ // Tests binary serialization and textual I/O.
+ void TestIO(Weight w) {
+ // Tests binary I/O
+ {
+ std::ostringstream os;
+ w.Write(os);
+ os.flush();
+ std::istringstream is(os.str());
+ Weight v;
+ v.Read(is);
+ CHECK_EQ(w, v);
+ }
+
+ // Tests textual I/O.
+ {
+ std::ostringstream os;
+ os << w;
+ std::istringstream is(os.str());
+ Weight v(Weight::One());
+ is >> v;
+ CHECK(ApproxEqual(w, v));
+ }
+ }
+
+ // Tests copy constructor and assignment operator
+ void TestCopy(Weight w) {
+ Weight x = w;
+ CHECK(w == x);
+
+ x = Weight(w);
+ CHECK(w == x);
+
+ x.operator=(x);
+ CHECK(w == x);
+ }
+
+ // Generates weights used in testing.
+ WeightGenerator weight_generator_;
+};
+
+} // namespace fst
+
+#endif // FST_TEST_WEIGHT_TESTER_H_
--- /dev/null
+// See www.openfst.org for extensive documentation on this weighted
+// finite-state transducer library.
+//
+// Regression test for FST weights.
+
+#include <cstdlib>
+#include <ctime>
+
+#include <fst/expectation-weight.h>
+#include <fst/float-weight.h>
+#include <fst/lexicographic-weight.h>
+#include <fst/power-weight.h>
+#include <fst/product-weight.h>
+#include <fst/signed-log-weight.h>
+#include <fst/sparse-power-weight.h>
+#include <fst/string-weight.h>
+#include <fst/union-weight.h>
+#include "./weight-tester.h"
+
+DEFINE_int32(seed, -1, "random seed");
+DEFINE_int32(repeat, 10000, "number of test repetitions");
+
+namespace {
+
+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::SignedLogWeightTpl;
+using fst::SparsePowerWeight;
+using fst::StringWeight;
+using fst::STRING_LEFT;
+using fst::STRING_RIGHT;
+using fst::TropicalWeight;
+using fst::TropicalWeightTpl;
+using fst::UnionWeight;
+using fst::WeightGenerate;
+using fst::WeightTester;
+
+template <class T>
+void TestTemplatedWeights(int repeat) {
+ using TropicalWeightGenerate = WeightGenerate<TropicalWeightTpl<T>>;
+ TropicalWeightGenerate tropical_generate;
+ WeightTester<TropicalWeightTpl<T>, TropicalWeightGenerate> tropical_tester(
+ tropical_generate);
+ tropical_tester.Test(repeat);
+
+ using LogWeightGenerate = WeightGenerate<LogWeightTpl<T>>;
+ LogWeightGenerate log_generate;
+ WeightTester<LogWeightTpl<T>, LogWeightGenerate> log_tester(log_generate);
+ log_tester.Test(repeat);
+
+ using MinMaxWeightGenerate = WeightGenerate<MinMaxWeightTpl<T>>;
+ MinMaxWeightGenerate minmax_generate(true);
+ WeightTester<MinMaxWeightTpl<T>, MinMaxWeightGenerate> minmax_tester(
+ minmax_generate);
+ minmax_tester.Test(repeat);
+
+ using SignedLogWeightGenerate = WeightGenerate<SignedLogWeightTpl<T>>;
+ SignedLogWeightGenerate signedlog_generate;
+ WeightTester<SignedLogWeightTpl<T>, SignedLogWeightGenerate>
+ signedlog_tester(signedlog_generate);
+ signedlog_tester.Test(repeat);
+}
+
+} // namespace
+
+int main(int argc, char **argv) {
+ std::set_new_handler(FailedNewHandler);
+ SET_FLAGS(argv[0], &argc, &argv, true);
+
+ LOG(INFO) << "Seed = " << FLAGS_seed;
+ srand(FLAGS_seed);
+
+ TestTemplatedWeights<float>(FLAGS_repeat);
+ TestTemplatedWeights<double>(FLAGS_repeat);
+ FLAGS_fst_weight_parentheses = "()";
+ TestTemplatedWeights<float>(FLAGS_repeat);
+ TestTemplatedWeights<double>(FLAGS_repeat);
+ FLAGS_fst_weight_parentheses = "";
+
+ // Makes sure type names for templated weights are consistent.
+ CHECK(TropicalWeight::Type() == "tropical");
+ CHECK(TropicalWeightTpl<double>::Type() != TropicalWeightTpl<float>::Type());
+ CHECK(LogWeight::Type() == "log");
+ CHECK(LogWeightTpl<double>::Type() != LogWeightTpl<float>::Type());
+ TropicalWeightTpl<double> w(15.0);
+ TropicalWeight tw(15.0);
+
+ using LeftStringWeight = StringWeight<int>;
+ using LeftStringWeightGenerate = WeightGenerate<LeftStringWeight>;
+ LeftStringWeightGenerate left_string_generate;
+ WeightTester<LeftStringWeight, LeftStringWeightGenerate> left_string_tester(
+ left_string_generate);
+ left_string_tester.Test(FLAGS_repeat);
+
+ using RightStringWeight = StringWeight<int, STRING_RIGHT>;
+ using RightStringWeightGenerate = WeightGenerate<RightStringWeight>;
+ RightStringWeightGenerate right_string_generate;
+ WeightTester<RightStringWeight, RightStringWeightGenerate>
+ right_string_tester(right_string_generate);
+ right_string_tester.Test(FLAGS_repeat);
+
+ // COMPOSITE WEIGHTS AND TESTERS - DEFINITIONS
+
+ using TropicalGallicWeight = GallicWeight<int, TropicalWeight>;
+ using TropicalGallicWeightGenerate = WeightGenerate<TropicalGallicWeight>;
+ TropicalGallicWeightGenerate tropical_gallic_generate(true);
+ WeightTester<TropicalGallicWeight, TropicalGallicWeightGenerate>
+ tropical_gallic_tester(tropical_gallic_generate);
+
+ using TropicalGenGallicWeight = GallicWeight<int, TropicalWeight, GALLIC>;
+ using TropicalGenGallicWeightGenerate =
+ WeightGenerate<TropicalGenGallicWeight>;
+ TropicalGenGallicWeightGenerate tropical_gen_gallic_generate(false);
+ WeightTester<TropicalGenGallicWeight, TropicalGenGallicWeightGenerate>
+ tropical_gen_gallic_tester(tropical_gen_gallic_generate);
+
+ using TropicalProductWeight = ProductWeight<TropicalWeight, TropicalWeight>;
+ using TropicalProductWeightGenerate = WeightGenerate<TropicalProductWeight>;
+ TropicalProductWeightGenerate tropical_product_generate;
+ WeightTester<TropicalProductWeight, TropicalProductWeightGenerate>
+ tropical_product_tester(tropical_product_generate);
+
+ using TropicalLexicographicWeight =
+ LexicographicWeight<TropicalWeight, TropicalWeight>;
+ using TropicalLexicographicWeightGenerate =
+ WeightGenerate<TropicalLexicographicWeight>;
+ TropicalLexicographicWeightGenerate tropical_lexicographic_generate;
+ WeightTester<TropicalLexicographicWeight,
+ TropicalLexicographicWeightGenerate>
+ tropical_lexicographic_tester(tropical_lexicographic_generate);
+
+ using TropicalCubeWeight = PowerWeight<TropicalWeight, 3>;
+ using TropicalCubeWeightGenerate = WeightGenerate<TropicalCubeWeight>;
+ TropicalCubeWeightGenerate tropical_cube_generate;
+ WeightTester<TropicalCubeWeight, TropicalCubeWeightGenerate>
+ tropical_cube_tester(tropical_cube_generate);
+
+ using FirstNestedProductWeight =
+ ProductWeight<TropicalProductWeight, TropicalWeight>;
+ using FirstNestedProductWeightGenerate =
+ WeightGenerate<FirstNestedProductWeight>;
+ FirstNestedProductWeightGenerate first_nested_product_generate;
+ WeightTester<FirstNestedProductWeight, FirstNestedProductWeightGenerate>
+ first_nested_product_tester(first_nested_product_generate);
+
+ using SecondNestedProductWeight =
+ ProductWeight<TropicalWeight, TropicalProductWeight>;
+ using SecondNestedProductWeightGenerate =
+ WeightGenerate<SecondNestedProductWeight>;
+ SecondNestedProductWeightGenerate second_nested_product_generate;
+ WeightTester<SecondNestedProductWeight, SecondNestedProductWeightGenerate>
+ second_nested_product_tester(second_nested_product_generate);
+
+ using NestedProductCubeWeight = PowerWeight<FirstNestedProductWeight, 3>;
+ using NestedProductCubeWeightGenerate =
+ WeightGenerate<NestedProductCubeWeight>;
+ NestedProductCubeWeightGenerate nested_product_cube_generate;
+ WeightTester<NestedProductCubeWeight, NestedProductCubeWeightGenerate>
+ nested_product_cube_tester(nested_product_cube_generate);
+
+ using SparseNestedProductCubeWeight =
+ SparsePowerWeight<NestedProductCubeWeight, size_t>;
+ using SparseNestedProductCubeWeightGenerate =
+ WeightGenerate<SparseNestedProductCubeWeight>;
+ SparseNestedProductCubeWeightGenerate sparse_nested_product_cube_generate;
+ WeightTester<SparseNestedProductCubeWeight,
+ SparseNestedProductCubeWeightGenerate>
+ sparse_nested_product_cube_tester(sparse_nested_product_cube_generate);
+
+ using LogSparsePowerWeight = SparsePowerWeight<LogWeight, size_t>;
+ using LogSparsePowerWeightGenerate = WeightGenerate<LogSparsePowerWeight>;
+ LogSparsePowerWeightGenerate log_sparse_power_generate;
+ WeightTester<LogSparsePowerWeight, LogSparsePowerWeightGenerate>
+ log_sparse_power_tester(log_sparse_power_generate);
+
+ using LogLogExpectationWeight = ExpectationWeight<LogWeight, LogWeight>;
+ using LogLogExpectationWeightGenerate =
+ WeightGenerate<LogLogExpectationWeight>;
+ LogLogExpectationWeightGenerate log_log_expectation_generate;
+ WeightTester<LogLogExpectationWeight, LogLogExpectationWeightGenerate>
+ log_log_expectation_tester(log_log_expectation_generate);
+
+ using LogLogSparseExpectationWeight =
+ ExpectationWeight<LogWeight, LogSparsePowerWeight>;
+ using LogLogSparseExpectationWeightGenerate =
+ WeightGenerate<LogLogSparseExpectationWeight>;
+ LogLogSparseExpectationWeightGenerate log_log_sparse_expectation_generate;
+ WeightTester<LogLogSparseExpectationWeight,
+ LogLogSparseExpectationWeightGenerate>
+ log_log_sparse_expectation_tester(log_log_sparse_expectation_generate);
+
+ struct UnionWeightOptions {
+ using Compare = NaturalLess<TropicalWeight>;
+
+ struct Merge {
+ TropicalWeight operator()(const TropicalWeight &w1,
+ const TropicalWeight &w2) const {
+ return w1;
+ }
+ };
+
+ using ReverseOptions = UnionWeightOptions;
+ };
+
+ using TropicalUnionWeight = UnionWeight<TropicalWeight, UnionWeightOptions>;
+ using TropicalUnionWeightGenerate = WeightGenerate<TropicalUnionWeight>;
+ TropicalUnionWeightGenerate tropical_union_generate;
+ WeightTester<TropicalUnionWeight, TropicalUnionWeightGenerate>
+ 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);
+
+ std::cout << "PASS" << std::endl;
+
+ return 0;
+}
--- /dev/null
+#! /bin/sh
+# test-driver - basic testsuite driver script.
+
+scriptversion=2013-07-13.22; # UTC
+
+# Copyright (C) 2011-2013 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# 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 <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+# 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 <<END
+Usage:
+ test-driver --test-name=NAME --log-file=PATH --trs-file=PATH
+ [--expect-failure={yes|no}] [--color-tests={yes|no}]
+ [--enable-hard-errors={yes|no}] [--]
+ TEST-SCRIPT [TEST-SCRIPT-ARGUMENTS]
+The '--test-name', '--log-file' and '--trs-file' options are mandatory.
+END
+}
+
+test_name= # Used for reporting.
+log_file= # Where to save the output of the test script.
+trs_file= # Where to save the metadata of the test run.
+expect_failure=no
+color_tests=no
+enable_hard_errors=yes
+while test $# -gt 0; do
+ case $1 in
+ --help) print_usage; exit $?;;
+ --version) echo "test-driver $scriptversion"; exit $?;;
+ --test-name) test_name=$2; shift;;
+ --log-file) log_file=$2; shift;;
+ --trs-file) trs_file=$2; shift;;
+ --color-tests) color_tests=$2; shift;;
+ --expect-failure) expect_failure=$2; shift;;
+ --enable-hard-errors) enable_hard_errors=$2; shift;;
+ --) shift; break;;
+ -*) usage_error "invalid option: '$1'";;
+ *) break;;
+ esac
+ shift
+done
+
+missing_opts=
+test x"$test_name" = x && missing_opts="$missing_opts --test-name"
+test x"$log_file" = x && missing_opts="$missing_opts --log-file"
+test x"$trs_file" = x && missing_opts="$missing_opts --trs-file"
+if test x"$missing_opts" != x; then
+ usage_error "the following mandatory options are missing:$missing_opts"
+fi
+
+if test $# -eq 0; then
+ usage_error "missing argument"
+fi
+
+if test $color_tests = yes; then
+ # Keep this in sync with 'lib/am/check.am:$(am__tty_colors)'.
+ red='\e[0;31m' # Red.
+ grn='\e[0;32m' # Green.
+ lgn='\e[1;32m' # Light green.
+ blu='\e[1;34m' # Blue.
+ mgn='\e[0;35m' # Magenta.
+ std='\e[m' # No color.
+else
+ red= grn= lgn= blu= mgn= std=
+fi
+
+do_exit='rm -f $log_file $trs_file; (exit $st); exit $st'
+trap "st=129; $do_exit" 1
+trap "st=130; $do_exit" 2
+trap "st=141; $do_exit" 13
+trap "st=143; $do_exit" 15
+
+# Test script is run here.
+"$@" >$log_file 2>&1
+estatus=$?
+if test $enable_hard_errors = no && test $estatus -eq 99; then
+ estatus=1
+fi
+
+case $estatus:$expect_failure in
+ 0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
+ 0:*) col=$grn res=PASS recheck=no gcopy=no;;
+ 77:*) col=$blu res=SKIP recheck=no gcopy=yes;;
+ 99:*) col=$mgn res=ERROR recheck=yes gcopy=yes;;
+ *:yes) col=$lgn res=XFAIL recheck=no gcopy=yes;;
+ *:*) col=$red res=FAIL recheck=yes gcopy=yes;;
+esac
+
+# Report outcome to console.
+echo "${col}${res}${std}: $test_name"
+
+# Register the test result, and other relevant metadata.
+echo ":test-result: $res" > $trs_file
+echo ":global-test-result: $res" >> $trs_file
+echo ":recheck: $recheck" >> $trs_file
+echo ":copy-in-global-log: $gcopy" >> $trs_file
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
projects / platform / upstream / openfst.git / commitdiff