ooxml_crypt 0.1.0

data/vendor/cybozulib/include/sais.hxx

@@ -0,0 +1,364 @@
+/*
+ * sais.hxx for sais-lite
+ * Copyright (c) 2008-2009 Yuta Mori All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _SAIS_HXX
+#define _SAIS_HXX 1
+#ifdef __cplusplus
+
+#ifdef __INTEL_COMPILER
+#pragma warning(disable : 383 981 1418)
+// for icc 64-bit
+//#define __builtin_vsnprintf(a, b, c, d) __builtin_vsnprintf(a, b, c, (char *)d)
+#endif
+
+#include <iterator>
+#ifdef _OPENMP
+# include <omp.h>
+#endif
+
+namespace saisxx_private {
+
+/* find the start or end of each bucket */
+template<typename string_type, typename bucket_type, typename index_type>
+void
+getCounts(const string_type T, bucket_type C, index_type n, index_type k) {
+#ifdef _OPENMP
+  bucket_type D;
+  index_type i, j, p, sum, first, last;
+  int thnum, maxthreads = omp_get_max_threads();
+#pragma omp parallel default(shared) private(D, i, thnum, first, last)
+  {
+    thnum = omp_get_thread_num();
+    D = C + thnum * k;
+    first = n / maxthreads * thnum;
+    last = (thnum < (maxthreads - 1)) ? n / maxthreads * (thnum + 1) : n;
+    for(i = 0; i < k; ++i) { D[i] = 0; }
+    for(i = first; i < last; ++i) { ++D[T[i]]; }
+  }
+  if(1 < maxthreads) {
+#pragma omp parallel for default(shared) private(i, j, p, sum)
+    for(i = 0; i < k; ++i) {
+      for(j = 1, p = i + k, sum = C[i]; j < maxthreads; ++j, p += k) {
+        sum += C[p];
+      }
+      C[i] = sum;
+    }
+  }
+#else
+  index_type i;
+  for(i = 0; i < k; ++i) { C[i] = 0; }
+  for(i = 0; i < n; ++i) { ++C[T[i]]; }
+#endif
+}
+template<typename bucket_type, typename index_type>
+void
+getBuckets(const bucket_type C, bucket_type B, index_type k, bool end) {
+  index_type i, sum = 0;
+  if(end) { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum; } }
+  else { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum - C[i]; } }
+}
+
+/* compute SA and BWT */
+template<typename string_type, typename sarray_type,
+         typename bucket_type, typename index_type>
+void
+induceSA(string_type T, sarray_type SA, bucket_type C, bucket_type B,
+         index_type n, index_type k) {
+typedef typename std::iterator_traits<string_type>::value_type char_type;
+  sarray_type b;
+  index_type i, j;
+  char_type c0, c1;
+  /* compute SAl */
+  if(C == B) { getCounts(T, C, n, k); }
+  getBuckets(C, B, k, false); /* find starts of buckets */
+  b = SA + B[c1 = T[j = n - 1]];
+  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
+  for(i = 0; i < n; ++i) {
+    j = SA[i], SA[i] = ~j;
+    if(0 < j) {
+      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
+      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
+    }
+  }
+  /* compute SAs */
+  if(C == B) { getCounts(T, C, n, k); }
+  getBuckets(C, B, k, true); /* find ends of buckets */
+  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
+    if(0 < (j = SA[i])) {
+      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
+      *--b = ((j == 0) || (T[j - 1] > c1)) ? ~j : j;
+    } else {
+      SA[i] = ~j;
+    }
+  }
+}
+template<typename string_type, typename sarray_type,
+         typename bucket_type, typename index_type>
+int
+computeBWT(string_type T, sarray_type SA, bucket_type C, bucket_type B,
+           index_type n, index_type k) {
+typedef typename std::iterator_traits<string_type>::value_type char_type;
+  sarray_type b;
+  index_type i, j, pidx = -1;
+  char_type c0, c1;
+  /* compute SAl */
+  if(C == B) { getCounts(T, C, n, k); }
+  getBuckets(C, B, k, false); /* find starts of buckets */
+  b = SA + B[c1 = T[j = n - 1]];
+  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
+  for(i = 0; i < n; ++i) {
+    if(0 < (j = SA[i])) {
+      SA[i] = ~(c0 = T[--j]);
+      if(c0 != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
+      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
+    } else if(j != 0) {
+      SA[i] = ~j;
+    }
+  }
+  /* compute SAs */
+  if(C == B) { getCounts(T, C, n, k); }
+  getBuckets(C, B, k, true); /* find ends of buckets */
+  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
+    if(0 < (j = SA[i])) {
+      SA[i] = (c0 = T[--j]);
+      if(c0 != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
+      *--b = ((0 < j) && (T[j - 1] > c1)) ? ~((index_type)T[j - 1]) : j;
+    } else if(j != 0) {
+      SA[i] = ~j;
+    } else {
+      pidx = i;
+    }
+  }
+  return pidx;
+}
+
+/* find the suffix array SA of T[0..n-1] in {0..k}^n
+   use a working space (excluding s and SA) of at most 2n+O(1) for a constant alphabet */
+template<typename string_type, typename sarray_type, typename index_type>
+int
+suffixsort(string_type T, sarray_type SA,
+           index_type fs, index_type n, index_type k,
+           bool isbwt) {
+typedef typename std::iterator_traits<string_type>::value_type char_type;
+  sarray_type RA;
+  index_type i, j, m, p, q, plen, qlen, name, pidx = 0;
+  bool diff;
+  int c;
+#ifdef _OPENMP
+  int maxthreads = omp_get_max_threads();
+#else
+# define maxthreads 1
+#endif
+  char_type c0, c1;
+
+  /* stage 1: reduce the problem by at least 1/2
+     sort all the S-substrings */
+  if(fs < (maxthreads * k)) {
+    index_type *C, *B;
+    if((C = new index_type[maxthreads * k]) == 0) { return -2; }
+    B = (1 < maxthreads) ? C + k : C;
+    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
+#ifdef _OPENMP
+#pragma omp parallel for default(shared) private(i)
+#endif
+    for(i = 0; i < n; ++i) { SA[i] = 0; }
+    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
+      if((c0 = T[i]) < (c1 + c)) { c = 1; }
+      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
+    }
+    induceSA(T, SA, C, B, n, k);
+    delete [] C;
+  } else {
+    sarray_type C, B;
+    C = SA + n;
+    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
+    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
+#ifdef _OPENMP
+#pragma omp parallel for default(shared) private(i)
+#endif
+    for(i = 0; i < n; ++i) { SA[i] = 0; }
+    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
+      if((c0 = T[i]) < (c1 + c)) { c = 1; }
+      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
+    }
+    induceSA(T, SA, C, B, n, k);
+  }
+
+  /* compact all the sorted substrings into the first m items of SA
+     2*m must be not larger than n (proveable) */
+#ifdef _OPENMP
+#pragma omp parallel for default(shared) private(i, j, p, c0, c1)
+  for(i = 0; i < n; ++i) {
+    p = SA[i];
+    if((0 < p) && (T[p - 1] > (c0 = T[p]))) {
+      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
+      if((j < n) && (c0 < c1)) { SA[i] = ~p; }
+    }
+  }
+  for(i = 0, m = 0; i < n; ++i) { if((p = SA[i]) < 0) { SA[m++] = ~p; } }
+#else
+  for(i = 0, m = 0; i < n; ++i) {
+    p = SA[i];
+    if((0 < p) && (T[p - 1] > (c0 = T[p]))) {
+      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
+      if((j < n) && (c0 < c1)) { SA[m++] = p; }
+    }
+  }
+#endif
+  j = m + (n >> 1);
+#ifdef _OPENMP
+#pragma omp parallel for default(shared) private(i)
+#endif
+  for(i = m; i < j; ++i) { SA[i] = 0; } /* init the name array buffer */
+  /* store the length of all substrings */
+  for(i = n - 2, j = n, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
+    if((c0 = T[i]) < (c1 + c)) { c = 1; }
+    else if(c != 0) { SA[m + ((i + 1) >> 1)] = j - i - 1; j = i + 1; c = 0; }
+  }
+  /* find the lexicographic names of all substrings */
+  for(i = 0, name = 0, q = n, qlen = 0; i < m; ++i) {
+    p = SA[i], plen = SA[m + (p >> 1)], diff = true;
+    if(plen == qlen) {
+      for(j = 0; (j < plen) && (T[p + j] == T[q + j]); ++j) { }
+      if(j == plen) { diff = false; }
+    }
+    if(diff != false) { ++name, q = p, qlen = plen; }
+    SA[m + (p >> 1)] = name;
+  }
+
+  /* stage 2: solve the reduced problem
+     recurse if names are not yet unique */
+  if(name < m) {
+    RA = SA + n + fs - m;
+    for(i = m + (n >> 1) - 1, j = m - 1; m <= i; --i) {
+      if(SA[i] != 0) { RA[j--] = SA[i] - 1; }
+    }
+    if(suffixsort(RA, SA, fs + n - m * 2, m, name, false) != 0) { return -2; }
+    for(i = n - 2, j = m - 1, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
+      if((c0 = T[i]) < (c1 + c)) { c = 1; }
+      else if(c != 0) { RA[j--] = i + 1, c = 0; } /* get p1 */
+    }
+#ifdef _OPENMP
+#pragma omp parallel for default(shared) private(i)
+#endif
+    for(i = 0; i < m; ++i) { SA[i] = RA[SA[i]]; } /* get index in s */
+  }
+
+  /* stage 3: induce the result for the original problem */
+  if(fs < (maxthreads * k)) {
+    index_type *B, *C;
+    if((C = new index_type[maxthreads * k]) == 0) { return -2; }
+    B = (1 < maxthreads) ? C + k : C;
+    /* put all left-most S characters into their buckets */
+    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
+#ifdef _OPENMP
+#pragma omp parallel for default(shared) private(i)
+#endif
+    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
+    for(i = m - 1; 0 <= i; --i) {
+      j = SA[i], SA[i] = 0;
+      SA[--B[T[j]]] = j;
+    }
+    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
+    else { pidx = computeBWT(T, SA, C, B, n, k); }
+    delete [] C;
+  } else {
+    sarray_type C, B;
+    C = SA + n;
+    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
+    /* put all left-most S characters into their buckets */
+    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
+#ifdef _OPENMP
+#pragma omp parallel for default(shared) private(i)
+#endif
+    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
+    for(i = m - 1; 0 <= i; --i) {
+      j = SA[i], SA[i] = 0;
+      SA[--B[T[j]]] = j;
+    }
+    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
+    else { pidx = computeBWT(T, SA, C, B, n, k); }
+  }
+
+  return pidx;
+#ifndef _OPENMP
+# undef maxthreads
+#endif
+}
+
+} /* namespace saisxx_private */
+
+
+/**
+ * @brief Constructs the suffix array of a given string in linear time.
+ * @param T[0..n-1] The input string. (random access iterator)
+ * @param SA[0..n-1] The output array of suffixes. (random access iterator)
+ * @param n The length of the given string.
+ * @param k The alphabet size.
+ * @return 0 if no error occurred, -1 or -2 otherwise.
+ */
+template<typename string_type, typename sarray_type, typename index_type>
+int
+saisxx(string_type T, sarray_type SA, index_type n, index_type k = 256) {
+  int err;
+  if((n < 0) || (k <= 0)) { return -1; }
+  if(n <= 1) { if(n == 1) { SA[0] = 0; } return 0; }
+  try { err = saisxx_private::suffixsort(T, SA, 0, n, k, false); }
+  catch(...) { err = -2; }
+  return err;
+}
+
+/**
+ * @brief Constructs the burrows-wheeler transformed string of a given string in linear time.
+ * @param T[0..n-1] The input string. (random access iterator)
+ * @param U[0..n-1] The output string. (random access iterator)
+ * @param A[0..n-1] The temporary array. (random access iterator)
+ * @param n The length of the given string.
+ * @param k The alphabet size.
+ * @return The primary index if no error occurred, -1 or -2 otherwise.
+ */
+template<typename string_type, typename sarray_type, typename index_type>
+index_type
+saisxx_bwt(string_type T, string_type U, sarray_type A, index_type n, index_type k = 256) {
+typedef typename std::iterator_traits<string_type>::value_type char_type;
+  index_type i, pidx;
+  if((n < 0) || (k <= 0)) { return -1; }
+  if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }
+  try {
+    pidx = saisxx_private::suffixsort(T, A, 0, n, k, true);
+    if(0 <= pidx) {
+      U[0] = T[n - 1];
+      for(i = 0; i < pidx; ++i) { U[i + 1] = (char_type)A[i]; }
+      for(i += 1; i < n; ++i) { U[i] = (char_type)A[i]; }
+      pidx += 1;
+    }
+  } catch(...) { pidx = -2; }
+  return pidx;
+}
+
+
+#endif /* __cplusplus */
+#endif /* _SAIS_HXX */

data/vendor/cybozulib/misc/make_select8tbl.cpp

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <cybozu/inttype.hpp>
+
+inline uint64_t select8(uint64_t v, size_t r)
+{
+	size_t count = 0;
+	for (int i = 0; i <  64; i++) {
+		if (v & (uint64_t(1) << i))
+			count++;
+		if (count == r)
+			return i;
+	}
+	return 64;
+}
+
+int main()
+{
+	for (int x = 0; x < 256; x++) {
+		printf("{");
+		for (int i = 0; i < 8; i++) {
+			printf("%d, ", select8(x, i));
+		}
+		printf("},\n");
+	}
+}

data/vendor/cybozulib/mk.bat

@@ -0,0 +1,37 @@
+@echo off
+
+if /i "%1"=="release" (
+	set mode=Release
+	set suf=
+) else (
+	set mode=Debug
+	set suf=d
+)
+
+if /i "%PROCESSOR_ARCHITECTURE%" == "AMD64" (
+	set mode="%mode%|x64"
+) else (
+	set mode="%mode%|Win32"
+)
+
+@echo.
+@echo ******** Building project(%mode%) ********
+@echo.
+mkdir bin lib include
+devenv cybozulib.sln /Build %mode%
+@rem for /F "usebackq" %%p in (`"dir /S /B *.vcproj"`) do devenv %%p /Build %mode%
+@echo.
+@echo ******** Unit test ********
+@echo.
+rm -rf result.txt
+for %%e in (bin\*_test%suf%.exe) do (%%e | grep "ctest:name") >> result.txt
+grep -v "ng=0, exception=0" result.txt
+if %ERRORLEVEL% == 0 goto sample
+echo "all unit tests are ok"
+:sample
+@echo.
+@echo ******** Run sample ********
+@echo.
+bin\exception_smpl%suf%.exe
+
+:end

data/vendor/cybozulib/readme.md

@@ -0,0 +1,29 @@
+[![Build Status](https://github.com/herumi/cybozulib/actions/workflows/main.yml/badge.svg)](https://github.com/herumi/cybozulib/actions/workflows/main.yml)
+
+# cybozulib
+
+# Abstract
+This is a tiny C++ library for Windows and Linux.
+
+# How to use
+
+directory position
+
+```
+<work dir>/cybozulib
+          /cybozulib_ext ; necessary for Windows if openssl, gmp are used
+```
+
+# License
+[BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause)
+
+# Author
+
+MITSUNARI Shigeo(herumi@nifty.com)
+
+# Disclaimer
+This OSS is my own personal work and does not have any relationship with Cybozu Labs, Inc.,
+Cybozu Inc. or any other organization which I belong to.
+
+# sais.hxx
+sais.hxx is written by Yuta Mori.

data/vendor/cybozulib/release.props

@@ -0,0 +1,12 @@
+����<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup />
+</Project>

data/vendor/cybozulib/sample/Makefile

@@ -0,0 +1,30 @@
+include ../common.mk
+
+TARGET=$(TEST_FILE)
+LIBS=
+
+SRC=$(wildcard *smpl.cpp)
+ifneq ($(HAS_EIGEN),1)
+	SRC:=$(filter-out svd_bench_smpl.cpp,$(SRC))
+	SRC:=$(filter-out svd_smpl.cpp,$(SRC))
+endif
+ifneq ($(HAS_MECAB),1)
+	SRC:=$(filter-out mecab_smpl.cpp,$(SRC))
+endif
+
+all: $(TARGET)
+
+test: $(TARGET)
+	@$(SAMPLE_TEST)
+
+$(OBJDIR):
+	@$(MKDIR) $(OBJDIR)
+
+clean:
+	$(CLEAN)
+
+$(LIBS):
+	$(MAKE) -C ../src
+
+-include $(DEPEND_FILE)
+

data/vendor/cybozulib/sample/csucvector_smpl.cpp

@@ -0,0 +1,42 @@
+#include <cybozu/csucvector.hpp>
+#include <cybozu/mmap.hpp>
+#include <sstream>
+
+void test(const std::string& inName)
+{
+	cybozu::Mmap m(inName);
+	const uint64_t *blk = reinterpret_cast<const uint64_t*>(m.get());
+	cybozu::CSucVector cv2(blk, m.size() * 8);
+	cybozu::CSucVector cv;
+	{
+		std::stringstream ss;
+		cv2.save(ss);
+		cv.load(ss);
+		const int inSize = (int)m.size();
+		const int outSize = (int)ss.str().size();
+		printf("rate = %.2f%% %d / %d\n", outSize * 100.0 / inSize, outSize, inSize);
+	}
+	cybozu::BitVector bv;
+	bv.resize(m.size() * 8);
+	for (size_t i = 0, n = bv.size(); i < n; i++) {
+		if (cv.get(i)) bv.set(i);
+	}
+	const uint64_t *p = bv.getBlock();
+	for (size_t i = 0, n = bv.getBlockSize(); i < n; i++) {
+		if (p[i] != blk[i]) {
+			printf("err i=%d %llx %llx\n", (int)i, (long long)blk[i], (long long)p[i]);
+			exit(1);
+		}
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	argc--, argv++;
+	if (argc != 1) {
+		fprintf(stderr, "csucvector_smp.exe\n");
+		return 1;
+	}
+	const std::string inName(argv[0]);
+	test(inName);
+}

data/vendor/cybozulib/sample/data/svd/org/test1.S

@@ -0,0 +1,4 @@
+# V D 3
+6.7146909
+2.6076661
+2.0280541

data/vendor/cybozulib/sample/data/svd/org/test1.U

@@ -0,0 +1,4 @@
+# M D 3 3
+-0.78453644 0.49844637 0.3688547
+-0.039141616 0.55385323 -0.83169377
+-0.61884612 -0.66693164 -0.41500804

data/vendor/cybozulib/sample/data/svd/org/test1.V

@@ -0,0 +1,6 @@
+# M D 5 3
+-0.44267941 0.31768159 0.34099487
+-0.65168122 0.25307007 0.31823742
+-0.0058292506 0.21239423 -0.41009446
+-0.1284973 0.61593502 -0.63831276
+-0.60232963 -0.64073918 -0.45478213

data/vendor/cybozulib/sample/data/svd/test1

@@ -0,0 +1,4 @@
+# M D 3 5
+ 3 4 0 1 2
+ 0 0 1 2 0
+ 1 2 0 0 4

data/vendor/cybozulib/sample/data/svd/test2

@@ -0,0 +1,4 @@
+# M S 3 5
+0:3 1:4 3:1 4:2
+2:1 3:2
+0:1 1:2 4:4

data/vendor/cybozulib/sample/desymbol.cpp

@@ -0,0 +1,127 @@
+/*
+	convert <addr> to <file:line addr>
+	input stdin
+	output stdout
+	sudo apt-get install libbfd-dev
+	build this with -lbfd
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <fstream>
+#include <cybozu/bfd.hpp>
+#include <cybozu/stacktrace.hpp>
+#include <cybozu/atoi.hpp>
+#include <cybozu/option.hpp>
+#include <cybozu/string_operation.hpp>
+
+/*
+	find "[0x" ([0-9a-f]+) "]"
+*/
+const void* findAddr(const std::string& str)
+{
+	size_t p = str.find("[0x");
+	if (p == std::string::npos) return 0;
+	size_t q = str.find("]", p + 3);
+	if (q == std::string::npos) return 0;
+	bool b;
+	size_t addr = cybozu::hextoi(&b, &str[p + 3], q - p - 3);
+	if (!b) return 0;
+	return (const void*)addr;
+}
+
+void decode(std::string& str, cybozu::Bfd& bfd)
+{
+	const void *addr = findAddr(str);
+	if (addr == 0) return;
+	std::string file;
+	std::string func;
+	int line;
+	if (!bfd.getInfo(&file, &func, &line, addr)) return;
+	cybozu::Demangle(func, func);
+	str = file + ':' + cybozu::itoa(line) + ' ' + func + ' ' + str;
+}
+
+bool tryDecodeOnelineAndPut(const std::string& str, cybozu::Bfd& bfd)
+{
+	const std::string oneline = "<<<STACKTRACE>>> ";
+	if (str.find(oneline) != 0) return false;
+	printf("<<<STACKTRACE\n");
+	std::istringstream iss(str.substr(oneline.size()));
+	std::string addrStr;
+	while (iss >> addrStr) {
+		if (addrStr.find("0x") != 0) break;
+		bool b;
+		size_t addr = cybozu::hextoi(&b, &addrStr[2], addrStr.size() - 2);
+		if (!b) break;
+		std::string file;
+		std::string func;
+		int line;
+		if (bfd.getInfo(&file, &func, &line, (const void*)addr)) {
+			cybozu::Demangle(func, func);
+			printf("%s:%d %s ", file.c_str(), line, func.c_str());
+		}
+		printf("%s\n", addrStr.c_str());
+	}
+	printf(">>>STACKTRACE\n");
+	return true;
+}
+
+int main(int argc, char **argv)
+	try
+{
+	cybozu::Option opt;
+	bool doCheckAll = false;
+	std::string exeName;
+	std::string textName;
+	opt.appendBoolOpt(&doCheckAll, "a", ": check all text");
+	opt.appendOpt(&textName, "-", "f", ": text file");
+	opt.appendParam(&exeName, "exe", ": exec file");
+	opt.appendHelp("h", ": put this message");
+	if (!opt.parse(argc, argv)) {
+		opt.usage();
+		return 1;
+	}
+	const std::string beginStackTrace = "<<<STACKTRACE";
+	const std::string endStackTrace = ">>>STACKTRACE";
+	bool inStackTrace = false;
+	cybozu::Bfd bfd(exeName);
+	std::string line;
+	std::istream *pis = 0;
+	std::ifstream ifs;
+	if (textName == "-") {
+		pis = &std::cin;
+	} else {
+		ifs.open(textName.c_str(), std::ios::binary);
+		pis = &ifs;
+	}
+	fprintf(stderr, "textName=%s, exeName=%s\n", textName.c_str(), exeName.c_str());
+	while (std::getline(*pis, line)) {
+		cybozu::Strip(line);
+		if (tryDecodeOnelineAndPut(line, bfd)) {
+			continue;
+		}
+		bool doDecode = false;
+		if (doCheckAll) {
+			doDecode = true;
+		} else {
+			if (inStackTrace) {
+				if (line.find(endStackTrace) == 0) {
+					inStackTrace = false;
+				} else {
+					doDecode = true;
+				}
+			} else {
+				if (line.find(beginStackTrace) == 0) {
+					inStackTrace = true;
+				}
+			}
+		}
+		if (doDecode) {
+			decode(line, bfd);
+		}
+		printf("%s\n", line.c_str());
+	}
+} catch (std::exception& e) {
+	printf("ERR %s\n", e.what());
+}