Compare commits
43
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2353d034b2 | ||
|
|
ccc3e1f401 | ||
|
|
ff8924ce16 | ||
|
|
b9d2d1f666 | ||
|
|
4f58a59f4d | ||
|
|
584370127a | ||
|
|
528a4f5945 | ||
|
|
c4062e09b9 | ||
|
|
70e04d6a8e | ||
|
|
bcd594ed69 | ||
|
|
3c4fcb1594 | ||
|
|
b52fc1043b | ||
|
|
b34af08f67 | ||
|
|
e01398c9db | ||
|
|
dffba62e13 | ||
|
|
2b4d51f697 | ||
|
|
0dab2b18d7 | ||
|
|
3e0a118886 | ||
|
|
c72ed135e4 | ||
|
|
3ea0199e03 | ||
|
|
abed751e96 | ||
|
|
141bb78e96 | ||
|
|
30afc86af1 | ||
|
|
6df393c902 | ||
|
|
f951d0241c | ||
|
|
cc724f105d | ||
|
|
a4756fde3f | ||
|
|
15be4e7915 | ||
|
|
53a3f47076 | ||
|
|
175dbc4e25 | ||
|
|
c1f11855e3 | ||
|
|
76e72a301d | ||
|
|
a1626adb7e | ||
|
|
d1a07cbdc1 | ||
|
|
8c1e7175ec | ||
|
|
fc6df0fdc1 | ||
|
|
78271b179a | ||
|
|
d3abe3a468 | ||
|
|
41b859325b | ||
|
|
6a0bdf6063 | ||
|
|
36c250a03d | ||
|
|
260879a5c3 | ||
|
|
8537b93a43 |
No files matched your search
@@ -18,6 +18,7 @@ jq.1
|
||||
|
||||
# Generated source
|
||||
src/builtin.inc
|
||||
*.pc
|
||||
|
||||
# Autotools junk
|
||||
.libs
|
||||
@@ -49,3 +50,4 @@ tests/*.trs
|
||||
cscope.in.out
|
||||
cscope.out
|
||||
cscope.po.out
|
||||
jq.dSYM
|
||||
+12
-8
@@ -17,6 +17,7 @@ jobs:
|
||||
stage: test
|
||||
os: linux
|
||||
compiler: gcc
|
||||
python: 3.6
|
||||
|
||||
addons:
|
||||
apt:
|
||||
@@ -27,13 +28,13 @@ jobs:
|
||||
|
||||
before_install:
|
||||
- uname -s
|
||||
- rvm install ruby-1.9.3-p551
|
||||
- rvm use 1.9.3
|
||||
- rm src/{lexer,parser}.{c,h}
|
||||
- sed -i.bak '/^AM_INIT_AUTOMAKE(\[-Wno-portability 1\.14\])$/s/14/11/' modules/oniguruma/configure.ac
|
||||
|
||||
install:
|
||||
- bundle install --gemfile=docs/Gemfile
|
||||
- pyenv global 3.6
|
||||
- pip3 install pipenv
|
||||
- pushd docs && pipenv sync && popd
|
||||
- wget http://ftp.debian.org/debian/pool/main/b/bison/bison_3.0.2.dfsg-2_amd64.deb
|
||||
- ar p bison_3.0.2.dfsg-2_amd64.deb data.tar.xz | tar xJ
|
||||
- if [ -n "$COVERAGE" ]; then pip install --user cpp-coveralls; fi
|
||||
@@ -104,14 +105,12 @@ jobs:
|
||||
- uname -s
|
||||
- brew update
|
||||
- brew install flex bison
|
||||
- rvm install ruby-1.9.3-p551
|
||||
- rvm use 1.9.3
|
||||
- gem install bundler
|
||||
- rm src/{lexer,parser}.{c,h}
|
||||
- sed -i.bak '/^AM_INIT_AUTOMAKE(\[-Wno-portability 1\.14\])$/s/14/11/' modules/oniguruma/configure.ac
|
||||
|
||||
install:
|
||||
- bundle install --gemfile=docs/Gemfile
|
||||
- pip3 install pipenv
|
||||
- pushd docs && pipenv sync && popd
|
||||
- if [ -n "$COVERAGE" ]; then pip install --user cpp-coveralls; fi
|
||||
|
||||
|
||||
@@ -136,7 +135,9 @@ jobs:
|
||||
|
||||
install:
|
||||
- sudo sh alpine-chroot-install -b v3.7 -a "$ARCH"
|
||||
-p 'build-base automake autoconf bison libtool oniguruma-dev'
|
||||
-p 'build-base automake autoconf bison git libtool oniguruma-dev python3 python3-dev libxml2-dev libxslt-dev'
|
||||
- /alpine/enter-chroot pip3 install pipenv
|
||||
- alpine sh -c 'cd docs && pipenv sync'
|
||||
|
||||
before_script:
|
||||
- autoreconf -if
|
||||
@@ -146,6 +147,9 @@ jobs:
|
||||
- alpine make
|
||||
- alpine make check
|
||||
|
||||
after_failure:
|
||||
- cat test-suite.log
|
||||
- cat tests/*.log
|
||||
|
||||
# Build release binary statically linked with musl libc on Alpine Linux
|
||||
# (inside chroot). If building a tagged commit, then deploy release
|
||||
|
||||
@@ -68,3 +68,41 @@ WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
|
||||
REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
|
||||
OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
|
||||
|
||||
|
||||
|
||||
jq uses parts of the open source C library "decNumber", which is distribured
|
||||
under the following license:
|
||||
|
||||
|
||||
ICU License - ICU 1.8.1 and later
|
||||
|
||||
COPYRIGHT AND PERMISSION NOTICE
|
||||
|
||||
Copyright (c) 1995-2005 International Business Machines Corporation and others
|
||||
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, and/or sell copies of the Software, and to permit persons
|
||||
to whom the Software is furnished to do so, provided that the above
|
||||
copyright notice(s) and this permission notice appear in all copies of
|
||||
the Software and that both the above copyright notice(s) and this
|
||||
permission notice appear in supporting documentation.
|
||||
|
||||
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
|
||||
OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
||||
INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
||||
FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
||||
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
||||
WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of a copyright holder
|
||||
shall not be used in advertising or otherwise to promote the sale, use
|
||||
or other dealings in this Software without prior written authorization
|
||||
of the copyright holder.
|
||||
|
||||
+22
-21
@@ -1,4 +1,9 @@
|
||||
FROM debian:8
|
||||
FROM debian:9
|
||||
|
||||
ENV DEBIAN_FRONTEND=noninteractive \
|
||||
DEBCONF_NONINTERACTIVE_SEEN=true \
|
||||
LC_ALL=C.UTF-8 \
|
||||
LANG=C.UTF-8
|
||||
|
||||
COPY . /app
|
||||
|
||||
@@ -13,29 +18,23 @@ RUN apt-get update && \
|
||||
git \
|
||||
bison \
|
||||
flex \
|
||||
ruby \
|
||||
wget \
|
||||
ruby-dev && \
|
||||
wget https://github.com/kkos/oniguruma/archive/v5.9.6.tar.gz -O onig-5.9.6.tar.gz && \
|
||||
sha512sum onig-5.9.6.tar.gz | grep 6b048d345e148c9da38af7a8df76d4a358eb3d4db91fa7834076e511f526a63544284f212b0d56badbbd33112c8b458a5fff02bfbbda012ecfe478bc436ea679 && \
|
||||
tar zxvf onig-5.9.6.tar.gz && \
|
||||
(cd oniguruma-5.9.6 && \
|
||||
touch NEWS ChangeLog && \
|
||||
autoreconf -i && \
|
||||
./configure --prefix=/usr/local && \
|
||||
make && \
|
||||
make install ) && \
|
||||
gem install bundler && \
|
||||
(cd /app/docs && bundle install) && \
|
||||
python3 \
|
||||
python3-pip \
|
||||
wget && \
|
||||
pip3 install pipenv && \
|
||||
(cd /app/docs && pipenv sync) && \
|
||||
(cd /app && \
|
||||
git submodule init && \
|
||||
git submodule update && \
|
||||
autoreconf -i && \
|
||||
./configure --disable-valgrind --enable-all-static --prefix=/usr/local && \
|
||||
make -j8 && \
|
||||
make check && \
|
||||
make install && \
|
||||
make distclean ) && \
|
||||
(cd oniguruma-5.9.6 && \
|
||||
make install ) && \
|
||||
(cd /app/modules/oniguruma && \
|
||||
make uninstall ) && \
|
||||
(cd /app && \
|
||||
make distclean ) && \
|
||||
apt-get purge -y \
|
||||
build-essential \
|
||||
autoconf \
|
||||
@@ -43,10 +42,12 @@ RUN apt-get update && \
|
||||
bison \
|
||||
git \
|
||||
flex \
|
||||
ruby \
|
||||
ruby-dev && \
|
||||
python3 \
|
||||
python3-pip && \
|
||||
apt-get autoremove -y && \
|
||||
rm -rf oniguruma-5.9.6 && \
|
||||
rm -rf /app/modules/oniguruma/* && \
|
||||
rm -rf /app/modules/oniguruma/.git && \
|
||||
rm -rf /app/modules/oniguruma/.gitignore && \
|
||||
rm -rf /var/lib/apt/lists/* /var/lib/gems
|
||||
|
||||
ENTRYPOINT ["/usr/local/bin/jq"]
|
||||
|
||||
+23
-12
@@ -11,6 +11,8 @@ LIBJQ_SRC = src/builtin.c src/bytecode.c src/compile.c src/execute.c \
|
||||
src/jq_test.c src/jv.c src/jv_alloc.c src/jv_aux.c \
|
||||
src/jv_dtoa.c src/jv_file.c src/jv_parse.c src/jv_print.c \
|
||||
src/jv_unicode.c src/linker.c src/locfile.c src/util.c \
|
||||
src/decNumber/decContext.c src/decNumber/decNumber.c \
|
||||
src/jv_dtoa_tsd.c \
|
||||
${LIBJQ_INCS}
|
||||
|
||||
### C build options
|
||||
@@ -128,7 +130,11 @@ endif
|
||||
|
||||
### Tests (make check)
|
||||
|
||||
if ENABLE_DOCS
|
||||
TESTS = tests/optionaltest tests/mantest tests/jqtest tests/onigtest tests/shtest tests/utf8test tests/base64test
|
||||
else
|
||||
TESTS = tests/optionaltest tests/jqtest tests/onigtest tests/shtest tests/utf8test tests/base64test
|
||||
endif
|
||||
TESTS_ENVIRONMENT = NO_VALGRIND=$(NO_VALGRIND)
|
||||
|
||||
|
||||
@@ -136,8 +142,8 @@ TESTS_ENVIRONMENT = NO_VALGRIND=$(NO_VALGRIND)
|
||||
|
||||
man_MANS = jq.1
|
||||
if ENABLE_DOCS
|
||||
jq.1: $(srcdir)/docs/content/3.manual/manual.yml
|
||||
$(AM_V_GEN) ( cd ${abs_srcdir}/docs; '$(BUNDLER)' exec rake manpage ) > $@ || { rm -f $@; false; }
|
||||
jq.1: $(srcdir)/docs/content/manual/manual.yml
|
||||
$(AM_V_GEN) ( cd ${abs_srcdir}/docs; pipenv run python build_manpage.py ) > $@ || { rm -f $@; false; }
|
||||
jq.1.prebuilt: jq.1
|
||||
$(AM_V_GEN) cp jq.1 $@ || { rm -f $@; false; }
|
||||
else
|
||||
@@ -165,34 +171,39 @@ install-binaries: $(BUILT_SOURCES)
|
||||
$(MAKE) $(AM_MAKEFLAGS) install-exec
|
||||
|
||||
DOC_FILES = docs/content docs/public docs/templates docs/site.yml \
|
||||
docs/Gemfile docs/Gemfile.lock docs/Rakefile docs/README.md \
|
||||
jq.1.prebuilt
|
||||
docs/Pipfile docs/Pipfile.lock docs/build_manpage.py \
|
||||
docs/build_manpage.py docs/README.md jq.1.prebuilt
|
||||
|
||||
EXTRA_DIST = $(DOC_FILES) $(man_MANS) $(TESTS) $(TEST_LOG_COMPILER) \
|
||||
jq.1.prebuilt jq.spec src/lexer.c src/lexer.h src/parser.c \
|
||||
src/parser.h src/version.h src/builtin.jq \
|
||||
scripts/version tests/jq.test tests/modules/.jq \
|
||||
src/parser.h src/version.h src/builtin.jq scripts/version \
|
||||
libjq.pc \
|
||||
tests/base64.test tests/jq-f-test.sh tests/jq.test \
|
||||
tests/modules/a.jq tests/modules/b/b.jq tests/modules/c/c.jq \
|
||||
tests/modules/c/d.jq tests/modules/data.json \
|
||||
tests/modules/home1/.jq tests/modules/home2/.jq/g.jq \
|
||||
tests/modules/lib/jq/e/e.jq tests/modules/lib/jq/f.jq \
|
||||
tests/modules/shadow1.jq tests/modules/shadow2.jq \
|
||||
tests/modules/syntaxerror/syntaxerror.jq \
|
||||
tests/modules/test_bind_order.jq \
|
||||
tests/modules/test_bind_order0.jq \
|
||||
tests/modules/test_bind_order1.jq \
|
||||
tests/modules/test_bind_order2.jq tests/onig.supp \
|
||||
tests/modules/test_bind_order2.jq \
|
||||
tests/onig.supp tests/local.supp \
|
||||
tests/onig.test tests/setup tests/torture/input0.json \
|
||||
tests/optional.test tests/optionaltest \
|
||||
tests/utf8-truncate.jq tests/utf8test \
|
||||
tests/base64.test tests/base64test \
|
||||
tests/jq-f-test.sh tests/shtest
|
||||
|
||||
|
||||
tests/utf8-truncate.jq tests/utf8test \
|
||||
tests/base64.test tests/base64test \
|
||||
tests/jq-f-test.sh tests/shtest
|
||||
|
||||
# README.md is expected in Github projects, good stuff in it, so we'll
|
||||
# distribute it and install it with the package in the doc directory.
|
||||
docdir = ${datadir}/doc/${PACKAGE}
|
||||
dist_doc_DATA = README.md COPYING AUTHORS README
|
||||
|
||||
pkgconfigdir = $(libdir)/pkgconfig
|
||||
pkgconfig_DATA = libjq.pc
|
||||
|
||||
RELEASE ?= 1
|
||||
rpm: dist jq.spec
|
||||
@echo "Packaging jq as an RPM ..."
|
||||
|
||||
+10
-9
@@ -1,26 +1,27 @@
|
||||
environment:
|
||||
matrix:
|
||||
- MSYSTEM: MINGW64
|
||||
PATH: C:\msys64\usr\bin;C:\msys64\mingw64\bin;C:\Windows\System32;C:\Windows;%PATH%
|
||||
PATH: C:\Python36;C:\Python36\Scripts;C:\msys64\usr\bin;C:\msys64\mingw64\bin;C:\Windows\System32;C:\Windows;%PATH%
|
||||
- MSYSTEM: MINGW32
|
||||
PATH: C:\msys64\usr\bin;C:\msys64\mingw32\bin;C:\Windows\System32;C:\Windows;%PATH%
|
||||
PATH: C:\Python36;C:\Python36\Scripts;C:\msys64\usr\bin;C:\msys64\mingw32\bin;C:\Windows\System32;C:\Windows;%PATH%
|
||||
|
||||
clone_script:
|
||||
- bash -lc "git clone -q --branch=$APPVEYOR_REPO_BRANCH https://github.com/${APPVEYOR_REPO_NAME}.git $APPVEYOR_BUILD_FOLDER"
|
||||
- bash -lc "cd $APPVEYOR_BUILD_FOLDER && git checkout -qf $APPVEYOR_REPO_BRANCH"
|
||||
- bash -lc "git clone -q --branch=${APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH:-$APPVEYOR_REPO_BRANCH} https://github.com/${APPVEYOR_PULL_REQUEST_HEAD_REPO_NAME:-$APPVEYOR_REPO_NAME}.git $APPVEYOR_BUILD_FOLDER"
|
||||
- bash -lc "cd $APPVEYOR_BUILD_FOLDER && git checkout -qf ${APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH:APPVEYOR_REPO_BRANCH}"
|
||||
- bash -lc "cd $APPVEYOR_BUILD_FOLDER && git submodule update --init --recursive"
|
||||
|
||||
install:
|
||||
# update mysy2
|
||||
# update msys2
|
||||
- C:\msys64\usr\bin\bash -lc "pacman --needed --noconfirm -Sy pacman-mirrors"
|
||||
- C:\msys64\usr\bin\bash -lc "pacman --noconfirm -Sy"
|
||||
- C:\msys64\usr\bin\bash -lc "pacman --noconfirm -S autoconf automake bison flex"
|
||||
- C:\msys64\usr\bin\bash -lc "pacman --noconfirm -S git"
|
||||
- C:\msys64\usr\bin\bash -lc "pacman --noconfirm -Su"
|
||||
- C:\msys64\usr\bin\bash -lc "pacman --noconfirm -S autoconf automake bison flex git"
|
||||
- C:\msys64\usr\bin\bash -lc "pip3 install --upgrade pipenv"
|
||||
- C:\msys64\usr\bin\bash -lc "cd $APPVEYOR_BUILD_FOLDER/docs && pipenv sync"
|
||||
|
||||
build_script:
|
||||
- bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && autoreconf -i"
|
||||
- bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && ./configure --with-oniguruma=builtin --disable-shared --enable-static --enable-all-static"
|
||||
- bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && make -j8"
|
||||
- bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && make"
|
||||
- bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && cat jq.1 | groff -mandoc -Thtml > jq.html"
|
||||
- 7z a jq-package.zip jq.1 jq.html jq.exe
|
||||
- bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && pwd && ls -la"
|
||||
|
||||
+23
-23
@@ -74,7 +74,7 @@ dnl Code coverage
|
||||
AC_ARG_ENABLE([gcov],
|
||||
AC_HELP_STRING([--enable-gcov], [enable gcov code coverage tool]))
|
||||
|
||||
dnl Don't attempt to build docs if there's no Ruby lying around
|
||||
dnl Don't attempt to build docs if python deps aren't installed
|
||||
AC_ARG_ENABLE([docs],
|
||||
AC_HELP_STRING([--disable-docs], [don't build docs]))
|
||||
|
||||
@@ -86,30 +86,38 @@ dnl Enable building all static
|
||||
AC_ARG_ENABLE([all-static],
|
||||
AC_HELP_STRING([--enable-all-static], [link jq with static libraries only]))
|
||||
|
||||
AS_IF([test "x$enable_docs" != "xno"],[
|
||||
AC_CHECK_PROGS(bundle_cmd, bundle)
|
||||
AS_IF([test "x$enable_docs" = "xyes"],[
|
||||
AC_CHECK_PROGS(pipenv_cmd, pipenv)
|
||||
|
||||
AC_CACHE_CHECK([for Ruby dependencies], [jq_cv_ruby_deps],
|
||||
[jq_cv_ruby_deps=yes;
|
||||
AS_IF([test "x$bundle_cmd" = "x" || \
|
||||
! bmsg="`cd ${srcdir}/docs; "$bundle_cmd" check 2>/dev/null`"],[
|
||||
AC_MSG_WARN([$bmsg])
|
||||
AC_CACHE_CHECK([for Python dependencies], [jq_cv_python_deps],
|
||||
[jq_cv_python_deps=yes;
|
||||
AS_IF([test "x$pipenv_cmd" = "x" || \
|
||||
! bmsg="`cd ${srcdir}/docs; LC_ALL=$LANG "$pipenv_cmd" check`"],[
|
||||
AC_MSG_ERROR([$bmsg])
|
||||
cat <<EOF
|
||||
*****************************************************************
|
||||
* Ruby dependencies for building jq documentation not found. *
|
||||
* Python dependencies for building jq documentation not found. *
|
||||
* You can still build, install and hack on jq, but the manpage *
|
||||
* will not be rebuilt and some of the tests will not run. *
|
||||
* See docs/README.md for how to install the docs dependencies. *
|
||||
*****************************************************************
|
||||
EOF
|
||||
jq_cv_ruby_deps=no
|
||||
jq_cv_python_deps=no
|
||||
])])
|
||||
|
||||
if test "x$jq_cv_ruby_deps" != "xyes"; then
|
||||
if test "x$jq_cv_python_deps" != "xyes"; then
|
||||
enable_docs=no
|
||||
fi
|
||||
])
|
||||
|
||||
dnl Disable decNumber support
|
||||
AC_ARG_ENABLE([decnum],
|
||||
AC_HELP_STRING([--disable-decnum], [disable decnum support]))
|
||||
|
||||
AS_IF([test "x$enable_decnum" != "xno"],[
|
||||
AC_DEFINE([USE_DECNUM],1)
|
||||
])
|
||||
|
||||
AM_CONDITIONAL([ENABLE_VALGRIND], [test "x$enable_valgrind" != xno])
|
||||
AM_CONDITIONAL([ENABLE_ASAN], [test "x$enable_asan" = xyes])
|
||||
AM_CONDITIONAL([ENABLE_UBSAN], [test "x$enable_ubsan" = xyes])
|
||||
@@ -136,17 +144,9 @@ AC_CHECK_MEMBER([struct tm.tm_gmtoff], [AC_DEFINE([HAVE_TM_TM_GMT_OFF],1,[Define
|
||||
AC_CHECK_MEMBER([struct tm.__tm_gmtoff], [AC_DEFINE([HAVE_TM___TM_GMT_OFF],1,[Define to 1 if the system has the __tm_gmt_off field in struct tm])],
|
||||
[], [[#include <time.h>]])
|
||||
|
||||
AC_ARG_ENABLE([pthread-tls],
|
||||
[AC_HELP_STRING([--enable-pthread-tls],
|
||||
[Enable use of pthread thread local storage])],
|
||||
[],
|
||||
[enable_pthread_tls=no])
|
||||
|
||||
if test $enable_pthread_tls = yes; then
|
||||
AC_FIND_FUNC([pthread_key_create], [pthread], [#include <pthread.h>], [NULL, NULL])
|
||||
AC_FIND_FUNC([pthread_once], [pthread], [#include <pthread.h>], [NULL, NULL])
|
||||
AC_FIND_FUNC([atexit], [pthread], [#include <stdlib.h>], [NULL])
|
||||
fi
|
||||
AC_FIND_FUNC([pthread_key_create], [pthread], [#include <pthread.h>], [NULL, NULL])
|
||||
AC_FIND_FUNC([pthread_once], [pthread], [#include <pthread.h>], [NULL, NULL])
|
||||
AC_FIND_FUNC([atexit], [pthread], [#include <stdlib.h>], [NULL])
|
||||
|
||||
dnl libm math.h functions
|
||||
AC_CHECK_MATH_FUNC(acos)
|
||||
@@ -279,6 +279,6 @@ AM_CONDITIONAL([BUILD_ONIGURUMA], [test "x$build_oniguruma" = xyes])
|
||||
AC_SUBST([BUNDLER], ["$bundle_cmd"])
|
||||
|
||||
AC_CONFIG_MACRO_DIR([config/m4])
|
||||
AC_CONFIG_FILES([Makefile])
|
||||
AC_CONFIG_FILES([Makefile libjq.pc])
|
||||
AC_OUTPUT
|
||||
|
||||
@@ -1,6 +1,3 @@
|
||||
.DS_Store
|
||||
.sass-cache
|
||||
output/*
|
||||
|
||||
# Autogenerated from public/css/base.scss
|
||||
public/css/base.css
|
||||
@@ -1,7 +0,0 @@
|
||||
source "https://rubygems.org"
|
||||
|
||||
gem "rake"
|
||||
gem "bonsai"
|
||||
gem "maruku"
|
||||
gem "ronn"
|
||||
gem "mustache", "<1.0" # to support ruby <2.0
|
||||
@@ -1,63 +0,0 @@
|
||||
GEM
|
||||
remote: https://rubygems.org/
|
||||
specs:
|
||||
activesupport (4.2.3)
|
||||
i18n (~> 0.7)
|
||||
json (~> 1.7, >= 1.7.7)
|
||||
minitest (~> 5.1)
|
||||
thread_safe (~> 0.3, >= 0.3.4)
|
||||
tzinfo (~> 1.1)
|
||||
addressable (2.3.8)
|
||||
bonsai (1.4.9)
|
||||
activesupport (>= 3.0.3)
|
||||
builder (>= 3.0.0)
|
||||
i18n (>= 0.5.0)
|
||||
launchy (>= 0.3.7)
|
||||
liquid (>= 2.2.2)
|
||||
maruku (>= 0.6.0)
|
||||
rack
|
||||
sass
|
||||
sinatra (>= 1.0)
|
||||
tilt (>= 1.3)
|
||||
watch (>= 0.1.0)
|
||||
yui-compressor
|
||||
builder (3.2.2)
|
||||
hpricot (0.8.6)
|
||||
i18n (0.7.0)
|
||||
json (1.8.3)
|
||||
launchy (2.4.3)
|
||||
addressable (~> 2.3)
|
||||
liquid (3.0.6)
|
||||
maruku (0.7.2)
|
||||
minitest (5.8.0)
|
||||
mustache (0.99.8)
|
||||
rack (1.6.4)
|
||||
rack-protection (1.5.3)
|
||||
rack
|
||||
rake (10.4.2)
|
||||
rdiscount (2.1.8)
|
||||
ronn (0.7.3)
|
||||
hpricot (>= 0.8.2)
|
||||
mustache (>= 0.7.0)
|
||||
rdiscount (>= 1.5.8)
|
||||
sass (3.4.16)
|
||||
sinatra (1.4.6)
|
||||
rack (~> 1.4)
|
||||
rack-protection (~> 1.4)
|
||||
tilt (>= 1.3, < 3)
|
||||
thread_safe (0.3.5)
|
||||
tilt (2.0.1)
|
||||
tzinfo (1.2.2)
|
||||
thread_safe (~> 0.1)
|
||||
watch (0.1.0)
|
||||
yui-compressor (0.12.0)
|
||||
|
||||
PLATFORMS
|
||||
ruby
|
||||
|
||||
DEPENDENCIES
|
||||
bonsai
|
||||
maruku
|
||||
mustache (< 1.0)
|
||||
rake
|
||||
ronn
|
||||
@@ -0,0 +1,12 @@
|
||||
[[source]]
|
||||
name = "pypi"
|
||||
url = "https://pypi.org/simple"
|
||||
verify_ssl = true
|
||||
|
||||
[dev-packages]
|
||||
|
||||
[packages]
|
||||
jinja2 = "*"
|
||||
pyyaml = "*"
|
||||
markdown = "*"
|
||||
lxml = "*"
|
||||
Generated
+117
@@ -0,0 +1,117 @@
|
||||
{
|
||||
"_meta": {
|
||||
"hash": {
|
||||
"sha256": "16a9ef323592a417142c30be17e58c3cf36dc2bfdbf4757106a796b22262a1ce"
|
||||
},
|
||||
"pipfile-spec": 6,
|
||||
"requires": {},
|
||||
"sources": [
|
||||
{
|
||||
"name": "pypi",
|
||||
"url": "https://pypi.org/simple",
|
||||
"verify_ssl": true
|
||||
}
|
||||
]
|
||||
},
|
||||
"default": {
|
||||
"jinja2": {
|
||||
"hashes": [
|
||||
"sha256:74c935a1b8bb9a3947c50a54766a969d4846290e1e788ea44c1392163723c3bd",
|
||||
"sha256:f84be1bb0040caca4cea721fcbbbbd61f9be9464ca236387158b0feea01914a4"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==2.10"
|
||||
},
|
||||
"lxml": {
|
||||
"hashes": [
|
||||
"sha256:0537eee4902e8bf4f41bfee8133f7edf96533dd175930a12086d6a40d62376b2",
|
||||
"sha256:0562ec748abd230ab87d73384e08fa784f9b9cee89e28696087d2d22c052cc27",
|
||||
"sha256:09e91831e749fbf0f24608694e4573be0ef51430229450c39c83176cc2e2d353",
|
||||
"sha256:1ae4c0722fc70c0d4fba43ae33c2885f705e96dce1db41f75ae14a2d2749b428",
|
||||
"sha256:1c630c083d782cbaf1f7f37f6cac87bda9cff643cf2803a5f180f30d97955cef",
|
||||
"sha256:2fe74e3836bd8c0fa7467ffae05545233c7f37de1eb765cacfda15ad20c6574a",
|
||||
"sha256:37af783c2667ead34a811037bda56a0b142ac8438f7ed29ae93f82ddb812fbd6",
|
||||
"sha256:3f2d9eafbb0b24a33f56acd16f39fc935756524dcb3172892721c54713964c70",
|
||||
"sha256:47d8365a8ef14097aa4c65730689be51851b4ade677285a3b2daa03b37893e26",
|
||||
"sha256:510e904079bc56ea784677348e151e1156040dbfb736f1d8ea4b9e6d0ab2d9f4",
|
||||
"sha256:58d0851da422bba31c7f652a7e9335313cf94a641aa6d73b8f3c67602f75b593",
|
||||
"sha256:7940d5c2185ffb989203dacbb28e6ae88b4f1bb25d04e17f94b0edd82232bcbd",
|
||||
"sha256:7cf39bb3a905579836f7a8f3a45320d9eb22f16ab0c1e112efb940ced4d057a5",
|
||||
"sha256:9563a23c1456c0ab550c087833bc13fcc61013a66c6420921d5b70550ea312bf",
|
||||
"sha256:95b392952935947e0786a90b75cc33388549dcb19af716b525dae65b186138fc",
|
||||
"sha256:983129f3fd3cef5c3cf067adcca56e30a169656c00fcc6c648629dbb850b27fa",
|
||||
"sha256:a0b75b1f1854771844c647c464533def3e0a899dd094a85d1d4ed72ecaaee93d",
|
||||
"sha256:b5db89cc0ef624f3a81214b7961a99f443b8c91e88188376b6b322fd10d5b118",
|
||||
"sha256:c0a7751ba1a4bfbe7831920d98cee3ce748007eab8dfda74593d44079568219a",
|
||||
"sha256:c0c5a7d4aafcc30c9b6d8613a362567e32e5f5b708dc41bc3a81dac56f8af8bb",
|
||||
"sha256:d4d63d85eacc6cb37b459b16061e1f100d154bee89dc8d8f9a6128a5a538e92e",
|
||||
"sha256:da5e7e941d6e71c9c9a717c93725cda0708c2474f532e3680ac5e39ec57d224d",
|
||||
"sha256:dccad2b3c583f036f43f80ac99ee212c2fa9a45151358d55f13004d095e683b2",
|
||||
"sha256:df46307d39f2aeaafa1d25309b8a8d11738b73e9861f72d4d0a092528f498baa",
|
||||
"sha256:e70b5e1cb48828ddd2818f99b1662cb9226dc6f57d07fc75485405c77da17436",
|
||||
"sha256:ea825562b8cd057cbc9810d496b8b5dec37a1e2fc7b27bc7c1e72ce94462a09a"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==4.3.1"
|
||||
},
|
||||
"markdown": {
|
||||
"hashes": [
|
||||
"sha256:c00429bd503a47ec88d5e30a751e147dcb4c6889663cd3e2ba0afe858e009baa",
|
||||
"sha256:d02e0f9b04c500cde6637c11ad7c72671f359b87b9fe924b2383649d8841db7c"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==3.0.1"
|
||||
},
|
||||
"markupsafe": {
|
||||
"hashes": [
|
||||
"sha256:048ef924c1623740e70204aa7143ec592504045ae4429b59c30054cb31e3c432",
|
||||
"sha256:130f844e7f5bdd8e9f3f42e7102ef1d49b2e6fdf0d7526df3f87281a532d8c8b",
|
||||
"sha256:19f637c2ac5ae9da8bfd98cef74d64b7e1bb8a63038a3505cd182c3fac5eb4d9",
|
||||
"sha256:1b8a7a87ad1b92bd887568ce54b23565f3fd7018c4180136e1cf412b405a47af",
|
||||
"sha256:1c25694ca680b6919de53a4bb3bdd0602beafc63ff001fea2f2fc16ec3a11834",
|
||||
"sha256:1f19ef5d3908110e1e891deefb5586aae1b49a7440db952454b4e281b41620cd",
|
||||
"sha256:1fa6058938190ebe8290e5cae6c351e14e7bb44505c4a7624555ce57fbbeba0d",
|
||||
"sha256:31cbb1359e8c25f9f48e156e59e2eaad51cd5242c05ed18a8de6dbe85184e4b7",
|
||||
"sha256:3e835d8841ae7863f64e40e19477f7eb398674da6a47f09871673742531e6f4b",
|
||||
"sha256:4e97332c9ce444b0c2c38dd22ddc61c743eb208d916e4265a2a3b575bdccb1d3",
|
||||
"sha256:525396ee324ee2da82919f2ee9c9e73b012f23e7640131dd1b53a90206a0f09c",
|
||||
"sha256:52b07fbc32032c21ad4ab060fec137b76eb804c4b9a1c7c7dc562549306afad2",
|
||||
"sha256:52ccb45e77a1085ec5461cde794e1aa037df79f473cbc69b974e73940655c8d7",
|
||||
"sha256:5c3fbebd7de20ce93103cb3183b47671f2885307df4a17a0ad56a1dd51273d36",
|
||||
"sha256:5e5851969aea17660e55f6a3be00037a25b96a9b44d2083651812c99d53b14d1",
|
||||
"sha256:5edfa27b2d3eefa2210fb2f5d539fbed81722b49f083b2c6566455eb7422fd7e",
|
||||
"sha256:7d263e5770efddf465a9e31b78362d84d015cc894ca2c131901a4445eaa61ee1",
|
||||
"sha256:83381342bfc22b3c8c06f2dd93a505413888694302de25add756254beee8449c",
|
||||
"sha256:857eebb2c1dc60e4219ec8e98dfa19553dae33608237e107db9c6078b1167856",
|
||||
"sha256:98e439297f78fca3a6169fd330fbe88d78b3bb72f967ad9961bcac0d7fdd1550",
|
||||
"sha256:bf54103892a83c64db58125b3f2a43df6d2cb2d28889f14c78519394feb41492",
|
||||
"sha256:d9ac82be533394d341b41d78aca7ed0e0f4ba5a2231602e2f05aa87f25c51672",
|
||||
"sha256:e982fe07ede9fada6ff6705af70514a52beb1b2c3d25d4e873e82114cf3c5401",
|
||||
"sha256:edce2ea7f3dfc981c4ddc97add8a61381d9642dc3273737e756517cc03e84dd6",
|
||||
"sha256:efdc45ef1afc238db84cb4963aa689c0408912a0239b0721cb172b4016eb31d6",
|
||||
"sha256:f137c02498f8b935892d5c0172560d7ab54bc45039de8805075e19079c639a9c",
|
||||
"sha256:f82e347a72f955b7017a39708a3667f106e6ad4d10b25f237396a7115d8ed5fd",
|
||||
"sha256:fb7c206e01ad85ce57feeaaa0bf784b97fa3cad0d4a5737bc5295785f5c613a1"
|
||||
],
|
||||
"version": "==1.1.0"
|
||||
},
|
||||
"pyyaml": {
|
||||
"hashes": [
|
||||
"sha256:3d7da3009c0f3e783b2c873687652d83b1bbfd5c88e9813fb7e5b03c0dd3108b",
|
||||
"sha256:3ef3092145e9b70e3ddd2c7ad59bdd0252a94dfe3949721633e41344de00a6bf",
|
||||
"sha256:40c71b8e076d0550b2e6380bada1f1cd1017b882f7e16f09a65be98e017f211a",
|
||||
"sha256:558dd60b890ba8fd982e05941927a3911dc409a63dcb8b634feaa0cda69330d3",
|
||||
"sha256:a7c28b45d9f99102fa092bb213aa12e0aaf9a6a1f5e395d36166639c1f96c3a1",
|
||||
"sha256:aa7dd4a6a427aed7df6fb7f08a580d68d9b118d90310374716ae90b710280af1",
|
||||
"sha256:bc558586e6045763782014934bfaf39d48b8ae85a2713117d16c39864085c613",
|
||||
"sha256:d46d7982b62e0729ad0175a9bc7e10a566fc07b224d2c79fafb5e032727eaa04",
|
||||
"sha256:d5eef459e30b09f5a098b9cea68bebfeb268697f78d647bd255a085371ac7f3f",
|
||||
"sha256:e01d3203230e1786cd91ccfdc8f8454c8069c91bee3962ad93b87a4b2860f537",
|
||||
"sha256:e170a9e6fcfd19021dd29845af83bb79236068bf5fd4df3327c1be18182b2531"
|
||||
],
|
||||
"index": "pypi",
|
||||
"version": "==3.13"
|
||||
}
|
||||
},
|
||||
"develop": {}
|
||||
}
|
||||
+10
-15
@@ -2,24 +2,19 @@ Documentation
|
||||
=============
|
||||
|
||||
The jq website, manpages and some of the tests are generated from this
|
||||
directory. The directory holds a [Bonsai](http://tinytree.info)
|
||||
website, and the manual is a YAML file in `content/3.manual`.
|
||||
directory. The manual is a YAML file in `content/manual`.
|
||||
|
||||
To build the documentation (including building the jq manpage), you'll
|
||||
need a working Ruby setup. The easiest way to get one is to install
|
||||
RVM and Ruby 1.9.3 like so:
|
||||
need python3 and pipenv. You can install pipenv like so:
|
||||
|
||||
\curl -L https://get.rvm.io | bash -s stable --ruby=1.9.3
|
||||
pip install pipenv
|
||||
|
||||
After that finishes installing, you'll need to make sure RVM is on
|
||||
your path by doing `source $HOME/.rvm/scripts/rvm`, or just opening a
|
||||
new shell. See <https://rvm.io> for more info on RVM.
|
||||
Though, you may need to say pip3 instead, depending on your system. Once
|
||||
you have pipenv installed, you can install the dependencies by running
|
||||
`pipenv install` from the `docs` directory.
|
||||
|
||||
Once RVM is installed, you can install all the dependencies for jq's
|
||||
documentation build by running this from the `docs` directory:
|
||||
Once this is done, rerun `./configure` in the jq root directory and then
|
||||
the Makefile will be able to generate the jq manpage.
|
||||
|
||||
bundle install
|
||||
|
||||
When bundle manages to install the dependencies, rerun `./configure`
|
||||
in the jq root directory and then the Makefile will be able to
|
||||
generate the jq manpage.
|
||||
To build the website, run `pipenv run ./build_website.py` from inside
|
||||
the `docs` directory.
|
||||
@@ -1,24 +0,0 @@
|
||||
current_dir = File.dirname(__FILE__)
|
||||
rakefile_manual = File.expand_path(File.join(current_dir, "Rakefile.manual"))
|
||||
rakefile_website = File.expand_path(File.join(current_dir, "Rakefile.website"))
|
||||
|
||||
desc "Build the manpage from the bonsai source of the manual"
|
||||
task :manpage do
|
||||
system %(#{$0} -f #{rakefile_manual} manpage)
|
||||
end
|
||||
|
||||
desc "Collect jq unit test cases from the bonsai source of the manual"
|
||||
task :mantests do
|
||||
system %(#{$0} -f #{rakefile_manual} mantests)
|
||||
end
|
||||
|
||||
desc "Build the website from the bonsai sources"
|
||||
task :build do
|
||||
system %(#{$0} -f #{rakefile_website} build)
|
||||
end
|
||||
|
||||
desc "Serve a live view of the website on http://localhost:5000/jq/"
|
||||
task :serve do
|
||||
system %(#{$0} -f #{rakefile_website} serve)
|
||||
end
|
||||
|
||||
@@ -1,49 +0,0 @@
|
||||
require 'ronn'
|
||||
require 'tempfile'
|
||||
require 'yaml'
|
||||
|
||||
def load_manual
|
||||
YAML::load(File.open("content/3.manual/manual.yml"))
|
||||
end
|
||||
|
||||
task :manpage do
|
||||
Tempfile.open "manpage" do |f|
|
||||
manual = load_manual
|
||||
f.puts manual['manpage_intro']
|
||||
f.puts manual['body']
|
||||
manual['sections'].each do |section|
|
||||
|
||||
f.puts "## #{section['title'].upcase}\n"
|
||||
f.puts section['body']
|
||||
f.puts ""
|
||||
(section['entries'] || []).each do |entry|
|
||||
f.puts "### #{entry['title']}\n"
|
||||
f.puts entry['body']
|
||||
f.puts ""
|
||||
(entry['examples'] || []).each do |example|
|
||||
f.puts " jq '#{example['program']}'"
|
||||
f.puts " #{example['input']}"
|
||||
f.puts " => #{example['output'].join(", ")}"
|
||||
f.puts
|
||||
end
|
||||
end
|
||||
f.puts ""
|
||||
end
|
||||
f.puts manual['manpage_epilogue']
|
||||
f.close
|
||||
puts Ronn::Document.new(f.path).convert('roff').gsub(/<\/?code>/,"")
|
||||
end
|
||||
end
|
||||
|
||||
task :mantests do
|
||||
load_manual['sections'].each do |section|
|
||||
(section['entries'] || []).each do |entry|
|
||||
(entry['examples'] || []).each do |example|
|
||||
puts example['program'].gsub("\n", " ")
|
||||
puts example['input']
|
||||
example['output'].each do |s| puts s end
|
||||
puts
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1,76 +0,0 @@
|
||||
require 'bonsai'
|
||||
require 'json'
|
||||
require 'liquid'
|
||||
require 'maruku'
|
||||
|
||||
module ExtraFilters
|
||||
def markdownify(input)
|
||||
Maruku.new(input).to_html
|
||||
end
|
||||
def search_id(input)
|
||||
input.gsub(/`/, '')
|
||||
end
|
||||
def section_id(input)
|
||||
input.gsub(/[^a-zA-Z0-9_]/, '')
|
||||
end
|
||||
def entry_id(input)
|
||||
input.gsub(/[ `]/, '')
|
||||
end
|
||||
def no_paragraph(input)
|
||||
input.gsub('<p>', '').gsub('</p>', '')
|
||||
end
|
||||
def json(input)
|
||||
input.to_json
|
||||
end
|
||||
def unique(input)
|
||||
@n = (@n || 0) + 1
|
||||
input + @n.to_s
|
||||
end
|
||||
end
|
||||
|
||||
Liquid::Template.register_filter(ExtraFilters)
|
||||
|
||||
begin
|
||||
`java 2>&1`
|
||||
rescue
|
||||
class Bonsai::Exporter
|
||||
def self.compress_assets
|
||||
Bonsai.log "java not found! Not compressing javascript or stylesheets"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
task :build do
|
||||
Bonsai.root_dir = Dir.pwd
|
||||
Bonsai::Exporter.publish!
|
||||
end
|
||||
|
||||
task :serve do
|
||||
begin
|
||||
Bonsai.log "Press Control+C to quit"
|
||||
|
||||
require 'rack'
|
||||
require 'sinatra'
|
||||
require 'watch'
|
||||
require 'launchy'
|
||||
|
||||
Bonsai.root_dir = Dir.pwd
|
||||
|
||||
server = fork {
|
||||
app = Rack::Builder.app {
|
||||
map "/jq" do
|
||||
use Bonsai::StaticPassThrough, :root => Bonsai.root_dir + "/output", :urls => ["/"]
|
||||
end
|
||||
run Bonsai::DevelopmentServer
|
||||
}
|
||||
Rack::Handler.default.run(app, :Port => 5000) do
|
||||
Launchy.open("http://localhost:5000/jq/")
|
||||
end
|
||||
}
|
||||
Watch.new("{content,templates,public}/**/*") { Bonsai::Exporter.process! }
|
||||
rescue Interrupt
|
||||
Process.kill("QUIT", server)
|
||||
Process.wait(server)
|
||||
exit
|
||||
end
|
||||
end
|
||||
Executable
+235
@@ -0,0 +1,235 @@
|
||||
#!/usr/bin/env python3
|
||||
from datetime import date
|
||||
from io import StringIO
|
||||
from lxml import etree
|
||||
import markdown
|
||||
from markdown.extensions import Extension
|
||||
import re
|
||||
import sys
|
||||
import yaml
|
||||
|
||||
# Prevent our markdown parser from trying to help by interpreting things in angle brackets as HTML tags.
|
||||
class EscapeHtml(Extension):
|
||||
def extendMarkdown(self, md, md_globals):
|
||||
del md.preprocessors['html_block']
|
||||
del md.inlinePatterns['html']
|
||||
|
||||
class RoffWalker(object):
|
||||
def __init__(self, tree, output=sys.stdout):
|
||||
self.tree = tree
|
||||
self.target = output
|
||||
self.f = StringIO()
|
||||
|
||||
def walk(self):
|
||||
self._walk(self.tree, parent_tag=None)
|
||||
# We don't want to start lines with \. because that can confuse man
|
||||
# For lines that start with \., we need to prefix them with \& so it
|
||||
# knows not to treat that line as a directive
|
||||
data = re.sub(r'^\\\.', r'\&.', self.f.getvalue(), flags=re.MULTILINE)
|
||||
self.target.write(data)
|
||||
|
||||
def _ul_is_special(self, root):
|
||||
if len(root) != 1:
|
||||
return False
|
||||
child = root[0]
|
||||
if child.tag != 'li':
|
||||
return False
|
||||
msg = ''.join(child.itertext()).strip()
|
||||
return msg.endswith(':')
|
||||
|
||||
def _walk_child(self, root):
|
||||
if len(root) > 0:
|
||||
self._walk(root[0], parent_tag=root.tag)
|
||||
|
||||
def _write_element(self, root, ensure_newline=True):
|
||||
if root.text is not None:
|
||||
text = self._sanitize(root.text)
|
||||
self.__write_raw(text)
|
||||
self._walk_child(root)
|
||||
self._write_tail(root, ensure_newline=ensure_newline)
|
||||
|
||||
def _write_tail(self, root, ensure_newline=False, inline=False):
|
||||
if root.tail is not None:
|
||||
if inline or root.tail != '\n':
|
||||
text = self._sanitize(root.tail)
|
||||
if text.endswith('\n'):
|
||||
ensure_newline = False
|
||||
self.__write_raw(text)
|
||||
if ensure_newline:
|
||||
self.__write_raw('\n')
|
||||
|
||||
def _walk(self, root, parent_tag=None):
|
||||
last_tag = None
|
||||
while root is not None:
|
||||
if root.tag == 'h1':
|
||||
self.__write_cmd('.TH "JQ" "1" "{}" "" ""'.format(date.today().strftime('%B %Y')))
|
||||
self.__write_cmd('.SH "NAME"')
|
||||
# TODO: properly parse this
|
||||
self.__write_raw(r'\fBjq\fR \- Command\-line JSON processor' + "\n")
|
||||
|
||||
elif root.tag == 'h2':
|
||||
self.__write_cmd('.SH "{}"'.format(''.join(root.itertext()).strip()))
|
||||
|
||||
elif root.tag == 'h3':
|
||||
text = ''.join(root.itertext()).strip()
|
||||
self.__write_cmd('.SS "{}"'.format(self._h3_sanitize(text)))
|
||||
|
||||
elif root.tag == 'p':
|
||||
if last_tag not in ['h2', 'h3'] and parent_tag not in ['li']:
|
||||
self.__write_cmd('.P')
|
||||
self._write_element(root, ensure_newline=(parent_tag != 'li'))
|
||||
|
||||
elif root.tag == 'ul':
|
||||
if self._ul_is_special(root):
|
||||
li = root[0]
|
||||
self.__write_cmd('.TP')
|
||||
self._write_element(li)
|
||||
next = root.getnext()
|
||||
while next is not None and next.tag == 'p':
|
||||
if next.getnext() is not None and next.getnext().tag == 'pre':
|
||||
# we don't want to .IP these, because it'll look funny with the code indent
|
||||
break
|
||||
self.__write_cmd('.IP')
|
||||
self._write_element(next)
|
||||
root = next
|
||||
next = root.getnext()
|
||||
else:
|
||||
self._walk_child(root)
|
||||
self._write_tail(root)
|
||||
# A pre tag after the end of a list doesn't want two of the indentation commands
|
||||
if root.getnext() is None or root.getnext().tag != 'pre':
|
||||
self.__write_cmd('.IP "" 0')
|
||||
|
||||
elif root.tag == 'li':
|
||||
self.__write_cmd(r'.IP "\(bu" 4')
|
||||
if root.text is not None and root.text.strip() != '':
|
||||
text = self._sanitize(root.text)
|
||||
self.__write_raw(text)
|
||||
self._walk_child(root)
|
||||
self._write_tail(root, ensure_newline=True)
|
||||
|
||||
elif root.tag == 'strong':
|
||||
if root.text is not None:
|
||||
text = self._sanitize(root.text)
|
||||
self.__write_raw('\\fB{}\\fR'.format(text))
|
||||
|
||||
self._write_tail(root, inline=True)
|
||||
|
||||
elif root.tag == 'em':
|
||||
if root.text is not None:
|
||||
text = self._sanitize(root.text)
|
||||
self.__write_raw('\\fI{}\\fR'.format(text))
|
||||
self._write_tail(root, inline=True)
|
||||
|
||||
elif root.tag == 'code':
|
||||
if root.text is not None:
|
||||
text = self._code_sanitize(root.text)
|
||||
self.__write_raw('\\fB{}\\fR'.format(text))
|
||||
self._write_tail(root, inline=True)
|
||||
|
||||
elif root.tag == 'pre':
|
||||
self.__write_cmd('.IP "" 4')
|
||||
self.__write_cmd('.nf\n') # extra newline for spacing reasons
|
||||
next = root
|
||||
first = True
|
||||
while next is not None and next.tag == 'pre':
|
||||
if not first:
|
||||
self.__write_raw('\n')
|
||||
text = ''.join(next.itertext(with_tail=False))
|
||||
self.__write_raw(self._pre_sanitize(text))
|
||||
first = False
|
||||
root = next
|
||||
next = next.getnext()
|
||||
self.__write_cmd('.fi')
|
||||
self.__write_cmd('.IP "" 0')
|
||||
|
||||
else:
|
||||
self._walk_child(root)
|
||||
|
||||
last_tag = root.tag
|
||||
root = root.getnext()
|
||||
|
||||
def _base_sanitize(self, text):
|
||||
text = re.sub(r'\\', r'\\e', text)
|
||||
text = re.sub(r'\.', r'\\.', text)
|
||||
text = re.sub("'", r"\'", text)
|
||||
text = re.sub('-', r'\-', text)
|
||||
return text
|
||||
|
||||
def _pre_sanitize(self, text):
|
||||
return self._base_sanitize(text)
|
||||
|
||||
def _code_sanitize(self, text):
|
||||
text = self._base_sanitize(text)
|
||||
text = re.sub(r'\s', ' ', text)
|
||||
return text
|
||||
|
||||
def _h3_sanitize(self, text):
|
||||
text = self._base_sanitize(text)
|
||||
text = re.sub(' \n|\n ', ' ', text)
|
||||
text = re.sub('\n', ' ', text)
|
||||
return text
|
||||
|
||||
def _sanitize(self, text):
|
||||
text = self._base_sanitize(text)
|
||||
text = re.sub(r'<([^>]+)>', r'\\fI\1\\fR', text)
|
||||
text = re.sub(r' +', ' ', text)
|
||||
text = re.sub('\n', ' ', text)
|
||||
return text
|
||||
|
||||
def __write_cmd(self, dat):
|
||||
print('.', dat, sep='\n', file=self.f)
|
||||
pass
|
||||
|
||||
def __write_raw(self, dat):
|
||||
print(dat, sep='', end='', file=self.f)
|
||||
pass
|
||||
|
||||
def load_yml_file(fn):
|
||||
with open(fn) as f:
|
||||
return yaml.load(f)
|
||||
|
||||
def dedent_body(body):
|
||||
lines = [re.sub(r'^ (\S)', r'\1', l) for l in body.split('\n')]
|
||||
return '\n'.join(lines)
|
||||
|
||||
def convert_manual_to_markdown():
|
||||
f = StringIO()
|
||||
manual = load_yml_file("content/manual/manual.yml")
|
||||
f.write(manual.get('manpage_intro', '\n'))
|
||||
f.write(dedent_body(manual.get('body', '\n')))
|
||||
for section in manual.get('sections', []):
|
||||
f.write('## {}\n'.format(section.get('title', '').upper()))
|
||||
f.write(dedent_body(section.get('body', '\n')))
|
||||
f.write('\n')
|
||||
for entry in section.get('entries', []):
|
||||
f.write('### {}\n'.format(entry.get('title', '')))
|
||||
f.write(dedent_body(entry.get('body', '\n')))
|
||||
f.write('\n')
|
||||
if entry.get('examples') is not None:
|
||||
f.write("~~~~\n")
|
||||
first = True
|
||||
for example in entry.get('examples'):
|
||||
if not first:
|
||||
f.write('\n')
|
||||
f.write("jq '{}'\n".format(example.get('program', '')))
|
||||
f.write(" {}\n".format(example.get('input', '')))
|
||||
output = [str(x) for x in example.get('output', [])]
|
||||
f.write("=> {}\n".format(', '.join(output)))
|
||||
first = False
|
||||
f.write("~~~~\n")
|
||||
f.write('\n')
|
||||
f.write(manual.get('manpage_epilogue', ''))
|
||||
return f.getvalue()
|
||||
|
||||
# Convert manual.yml to our special markdown format
|
||||
markdown_data = convert_manual_to_markdown()
|
||||
|
||||
# Convert markdown to html
|
||||
html_data = markdown.markdown(markdown_data, extensions=[EscapeHtml(), 'fenced_code'])
|
||||
|
||||
# Parse the html into a tree so we can walk it
|
||||
tr = etree.HTML(html_data, etree.HTMLParser())
|
||||
|
||||
# Convert the markdown to ROFF
|
||||
RoffWalker(tr).walk()
|
||||
Executable
+13
@@ -0,0 +1,13 @@
|
||||
#!/usr/bin/env python3
|
||||
import yaml
|
||||
|
||||
with open("content/manual/manual.yml") as f:
|
||||
manual = yaml.load(f)
|
||||
for section in manual.get('sections', []):
|
||||
for entry in section.get('entries', []):
|
||||
for example in entry.get('examples', []):
|
||||
print(example.get('program', '').replace('\n', ' '))
|
||||
print(example.get('input', ''))
|
||||
for s in example.get('output', []):
|
||||
print(s)
|
||||
print('')
|
||||
Executable
+62
@@ -0,0 +1,62 @@
|
||||
#!/usr/bin/env python3
|
||||
import glob
|
||||
import itertools
|
||||
from jinja2 import Environment, FileSystemLoader, Markup, select_autoescape, contextfunction
|
||||
from markdown import markdown
|
||||
import os
|
||||
import os.path
|
||||
import re
|
||||
import shutil
|
||||
import yaml
|
||||
|
||||
env = Environment(
|
||||
loader=FileSystemLoader('templates'),
|
||||
autoescape=select_autoescape(['html.j2']),
|
||||
)
|
||||
|
||||
def load_yml_file(fn):
|
||||
with open(fn) as f:
|
||||
return yaml.load(f)
|
||||
|
||||
env.filters['search_id'] = lambda input: input.replace(r'`', '')
|
||||
env.filters['section_id'] = lambda input: re.sub(r"[^a-zA-Z0-9_]", '', input)
|
||||
env.filters['entry_id'] = lambda input: re.sub(r"[ `]", '', input)
|
||||
env.filters['markdownify'] = lambda input: Markup(markdown(input))
|
||||
env.filters['no_paragraph'] = lambda input: Markup(re.sub(r"</?p>", '', input))
|
||||
|
||||
env.globals['unique_id'] = contextfunction(lambda ctx: str(next(ctx['unique_ctr'])))
|
||||
|
||||
|
||||
env.globals.update(load_yml_file('site.yml'))
|
||||
|
||||
|
||||
env.globals['navigation'] = ['tutorial', 'download', 'manual']
|
||||
|
||||
def generate_file(env, fname='content/1.tutorial/default.yml'):
|
||||
path, base = os.path.split(fname)
|
||||
path = os.path.relpath(path, 'content')
|
||||
output_dir = os.path.join('output', path)
|
||||
output_path = os.path.join(output_dir, 'index.html')
|
||||
|
||||
template_name = re.sub(r".yml$", '.html.j2', base)
|
||||
|
||||
ctx = load_yml_file(fname)
|
||||
ctx.update(unique_ctr=itertools.count(1), permalink=path)
|
||||
os.makedirs(output_dir, exist_ok=True)
|
||||
env.get_template(template_name).stream(ctx).dump(output_path, encoding='utf-8')
|
||||
|
||||
|
||||
def copy_public_files(root=''):
|
||||
for f in os.scandir(os.path.join('public', root)):
|
||||
src = os.path.join(root, f.name)
|
||||
dst = os.path.join('output', src)
|
||||
if f.is_dir():
|
||||
os.makedirs(dst, exist_ok=True)
|
||||
copy_public_files(src)
|
||||
else:
|
||||
shutil.copyfile(f.path, dst)
|
||||
|
||||
copy_public_files()
|
||||
|
||||
for fn in glob.glob('content/**/*.yml', recursive=True):
|
||||
generate_file(env, fn)
|
||||
@@ -13,6 +13,10 @@ body:
|
||||
jq is licensed under the MIT license. For all of the gory
|
||||
details, read the file `COPYING` in the source distribution.
|
||||
|
||||
jq uses a C library for decimal number support. This is an ICU 1.8.1
|
||||
licensed code obtained from the ICU downloads archive
|
||||
http://download.icu-project.org/files/decNumber/decNumber-icu-368.zip.
|
||||
|
||||
|
||||
### Linux
|
||||
|
||||
@@ -180,14 +184,13 @@ body:
|
||||
|
||||
#### Building the documentation
|
||||
|
||||
jq's documentation is compiled into static HTML using
|
||||
[Bonsai](http://www.tinytree.info). To view the documentation
|
||||
locally, run `rake serve` (or `bundle exec rake serve`) from the
|
||||
docs/ subdirectory. To build the docs just `rake build` from the
|
||||
docs subdirectory. You'll need a few Ruby dependencies, which can
|
||||
be installed by following the instructions in `docs/README.md`.
|
||||
jq's documentation is compiled into static HTML using Python.
|
||||
To build the docs, run `pipenv run python3 build_website.py` from
|
||||
the docs/ subdirectory. To serve them locally, you can run
|
||||
`python3 -m SimpleHTTPServer`. You'll need a few Python dependencies,
|
||||
which can be installed by following the instructions in `docs/README.md`.
|
||||
|
||||
The man page is built by `make jq.1`, or just `make`, also from
|
||||
the YAML docs, and you'll still need the Ruby dependencies to
|
||||
the YAML docs, and you'll still need the Python dependencies to
|
||||
build the manpage.
|
||||
|
||||
File renamed without changes.
@@ -164,6 +164,12 @@ sections:
|
||||
Colors can be configured with the `JQ_COLORS` environment
|
||||
variable (see below).
|
||||
|
||||
* `--binary` / `-b`:
|
||||
|
||||
Windows users using WSL, MSYS2, or Cygwin, should use this option
|
||||
when using a native jq.exe, otherwise jq will turn newlines (LFs)
|
||||
into carriage-return-then-newline (CRLF).
|
||||
|
||||
* `--ascii-output` / `-a`:
|
||||
|
||||
jq usually outputs non-ASCII Unicode codepoints as UTF-8, even
|
||||
@@ -172,7 +178,7 @@ sections:
|
||||
ASCII output with every non-ASCII character replaced with the
|
||||
equivalent escape sequence.
|
||||
|
||||
* `--unbuffered`
|
||||
* `--unbuffered`:
|
||||
|
||||
Flush the output after each JSON object is printed (useful if
|
||||
you're piping a slow data source into jq and piping jq's
|
||||
@@ -658,10 +664,10 @@ sections:
|
||||
- **Strings** are added by being joined into a larger string.
|
||||
|
||||
- **Objects** are added by merging, that is, inserting all
|
||||
the key-value pairs from both objects into a single
|
||||
combined object. If both objects contain a value for the
|
||||
same key, the object on the right of the `+` wins. (For
|
||||
recursive merge use the `*` operator.)
|
||||
the key-value pairs from both objects into a single
|
||||
combined object. If both objects contain a value for the
|
||||
same key, the object on the right of the `+` wins. (For
|
||||
recursive merge use the `*` operator.)
|
||||
|
||||
`null` can be added to any value, and returns the other
|
||||
value unchanged.
|
||||
@@ -1975,40 +1981,40 @@ sections:
|
||||
|
||||
jq provides a few SQL-style operators.
|
||||
|
||||
* INDEX(stream; index_expression):
|
||||
* INDEX(stream; index_expression):
|
||||
|
||||
This builtin produces an object whose keys are computed by
|
||||
the given index expression applied to each value from the
|
||||
given stream.
|
||||
This builtin produces an object whose keys are computed by
|
||||
the given index expression applied to each value from the
|
||||
given stream.
|
||||
|
||||
* JOIN($idx; stream; idx_expr; join_expr):
|
||||
* JOIN($idx; stream; idx_expr; join_expr):
|
||||
|
||||
This builtin joins the values from the given stream to the
|
||||
given index. The index's keys are computed by applying the
|
||||
given index expression to each value from the given stream.
|
||||
An array of the value in the stream and the corresponding
|
||||
value from the index is fed to the given join expression to
|
||||
produce each result.
|
||||
This builtin joins the values from the given stream to the
|
||||
given index. The index's keys are computed by applying the
|
||||
given index expression to each value from the given stream.
|
||||
An array of the value in the stream and the corresponding
|
||||
value from the index is fed to the given join expression to
|
||||
produce each result.
|
||||
|
||||
* JOIN($idx; stream; idx_expr):
|
||||
* JOIN($idx; stream; idx_expr):
|
||||
|
||||
Same as `JOIN($idx; stream; idx_expr; .)`.
|
||||
Same as `JOIN($idx; stream; idx_expr; .)`.
|
||||
|
||||
* JOIN($idx; idx_expr):
|
||||
* JOIN($idx; idx_expr):
|
||||
|
||||
This builtin joins the input `.` to the given index, applying
|
||||
the given index expression to `.` to compute the index key.
|
||||
The join operation is as described above.
|
||||
This builtin joins the input `.` to the given index, applying
|
||||
the given index expression to `.` to compute the index key.
|
||||
The join operation is as described above.
|
||||
|
||||
* IN(s):
|
||||
* IN(s):
|
||||
|
||||
This builtin outputs `true` if `.` appears in the given
|
||||
stream, otherwise it outputs `false`.
|
||||
This builtin outputs `true` if `.` appears in the given
|
||||
stream, otherwise it outputs `false`.
|
||||
|
||||
* IN(source; s):
|
||||
* IN(source; s):
|
||||
|
||||
This builtin outputs `true` if any value in the source stream
|
||||
appears in the second stream, otherwise it outputs `false`.
|
||||
This builtin outputs `true` if any value in the source stream
|
||||
appears in the second stream, otherwise it outputs `false`.
|
||||
|
||||
- title: "`builtins`"
|
||||
body: |
|
||||
@@ -2230,6 +2236,7 @@ sections:
|
||||
STRING | FILTER( [REGEX, FLAGS] )
|
||||
|
||||
where:
|
||||
|
||||
* STRING, REGEX and FLAGS are jq strings and subject to jq string interpolation;
|
||||
* REGEX, after string interpolation, should be a valid PCRE regex;
|
||||
* FILTER is one of `test`, `match`, or `capture`, as described below.
|
||||
@@ -2642,9 +2649,9 @@ sections:
|
||||
|
||||
For example, in the following expression there is a binding
|
||||
which is visible "to the right" of it, `... | .*3 as
|
||||
$times_three | [. + $times_three] | ...`, but not "to the
|
||||
$times_three | [. + $times_three] | ...`, but not "to the
|
||||
left". Consider this expression now, `... | (.*3 as
|
||||
$times_three | [.+ $times_three]) | ...`: here the binding
|
||||
$times_three | [. + $times_three]) | ...`: here the binding
|
||||
`$times_three` is _not_ visible past the closing parenthesis.
|
||||
|
||||
- title: Reduce
|
||||
@@ -2867,7 +2874,7 @@ sections:
|
||||
|
||||
Two builtins provide minimal output capabilities, `debug`, and
|
||||
`stderr`. (Recall that a jq program's output values are always
|
||||
output as JSON texts on `stdout`.) The `debug` builtin can have
|
||||
output as JSON texts on `stdout`.) The `debug` builtin can have
|
||||
application-specific behavior, such as for executables that use
|
||||
the libjq C API but aren't the jq executable itself. The `stderr`
|
||||
builtin outputs its input in raw mode to stder with no additional
|
||||
@@ -441,7 +441,7 @@ sections:
|
||||
input: 5
|
||||
output: [6]
|
||||
|
||||
- title: `length`
|
||||
- title: '`length`'
|
||||
body: |
|
||||
|
||||
The builtin function `length` gets the length of various
|
||||
@@ -462,7 +462,7 @@ sections:
|
||||
input: '[[1,2], "string", {"a":2}, null]'
|
||||
output: [2, 6, 1, 0]
|
||||
|
||||
- title: `keys`
|
||||
- title: '`keys`'
|
||||
body: |
|
||||
|
||||
The builtin function `keys`, when given an object, returns
|
||||
@@ -485,7 +485,7 @@ sections:
|
||||
input: '[42,3,35]'
|
||||
output: ['[0,1,2]']
|
||||
|
||||
- title: `has`
|
||||
- title: '`has`'
|
||||
body: |
|
||||
|
||||
The builtin function `has` returns whether the input object
|
||||
@@ -504,7 +504,7 @@ sections:
|
||||
input: '[[0,1], ["a","b","c"]]'
|
||||
output: ['[false, true]']
|
||||
|
||||
- title: `to_entries`, `from_entries`, `with_entries`
|
||||
- title: '`to_entries`, `from_entries`, `with_entries`'
|
||||
body: |
|
||||
|
||||
These functions convert between an object and an array of
|
||||
@@ -529,14 +529,14 @@ sections:
|
||||
output: ['{"KEY_a": 1, "KEY_b": 2}']
|
||||
|
||||
|
||||
- title: `select`
|
||||
- title: '`select`'
|
||||
body: |
|
||||
|
||||
The function `select(foo)` produces its input unchanged if
|
||||
`foo` returns true for that input, and produces no output
|
||||
otherwise.
|
||||
|
||||
It's useful for filtering lists: `[1,2,3] | map(select(. >= 2))`
|
||||
It's useful for filtering lists: '`[1,2,3] | map(select(. >= 2))`'
|
||||
will give you `[3]`.
|
||||
|
||||
examples:
|
||||
@@ -544,7 +544,7 @@ sections:
|
||||
input: '[1,5,3,0,7]'
|
||||
output: ['[5,3,7]']
|
||||
|
||||
- title: `empty`
|
||||
- title: '`empty`'
|
||||
body: |
|
||||
|
||||
`empty` returns no results. None at all. Not even `null`.
|
||||
@@ -559,7 +559,7 @@ sections:
|
||||
input: 'null'
|
||||
output: ['[1,2,3]']
|
||||
|
||||
- title: `map(x)`
|
||||
- title: '`map(x)`'
|
||||
body: |
|
||||
|
||||
For any filter `x`, `map(x)` will run that filter for each
|
||||
@@ -574,7 +574,7 @@ sections:
|
||||
input: '[1,2,3]'
|
||||
output: ['[2,3,4]']
|
||||
|
||||
- title: `add`
|
||||
- title: '`add`'
|
||||
body: |
|
||||
|
||||
The filter `add` takes as input an array, and produces as
|
||||
@@ -596,7 +596,7 @@ sections:
|
||||
input: '[]'
|
||||
output: ["null"]
|
||||
|
||||
- title: `range`
|
||||
- title: '`range`'
|
||||
body: |
|
||||
|
||||
The `range` function produces a range of numbers. `range(4;10)`
|
||||
@@ -612,7 +612,7 @@ sections:
|
||||
input: 'null'
|
||||
output: ['[2,3]']
|
||||
|
||||
- title: `tonumber`
|
||||
- title: '`tonumber`'
|
||||
body: |
|
||||
|
||||
The `tonumber` function parses its input as a number. It
|
||||
@@ -624,7 +624,7 @@ sections:
|
||||
input: '[1, "1"]'
|
||||
output: [1, 1]
|
||||
|
||||
- title: `tostring`
|
||||
- title: '`tostring`'
|
||||
body: |
|
||||
|
||||
The `tostring` function prints its input as a
|
||||
@@ -636,7 +636,7 @@ sections:
|
||||
input: '[1, "1", [1]]'
|
||||
output: ['"1"', '"1"', '"[1]"']
|
||||
|
||||
- title: `type`
|
||||
- title: '`type`'
|
||||
body: |
|
||||
|
||||
The `type` function returns the type of its argument as a
|
||||
@@ -648,7 +648,7 @@ sections:
|
||||
input: '[0, false, [], {}, null, "hello"]'
|
||||
output: ['["number", "boolean", "array", "object", "null", "string"]']
|
||||
|
||||
- title: `sort, sort_by`
|
||||
- title: '`sort, sort_by`'
|
||||
body: |
|
||||
|
||||
The `sort` functions sorts its input, which must be an
|
||||
@@ -680,7 +680,7 @@ sections:
|
||||
input: '[{"foo":4, "bar":10}, {"foo":3, "bar":100}, {"foo":2, "bar":1}]'
|
||||
output: ['[{"foo":2, "bar":1}, {"foo":3, "bar":100}, {"foo":4, "bar":10}]']
|
||||
|
||||
- title: `group_by`
|
||||
- title: '`group_by`'
|
||||
body: |
|
||||
|
||||
`group_by(.foo)` takes as input an array, groups the
|
||||
@@ -697,7 +697,7 @@ sections:
|
||||
input: '[{"foo":1, "bar":10}, {"foo":3, "bar":100}, {"foo":1, "bar":1}]'
|
||||
output: ['[[{"foo":1, "bar":10}, {"foo":1, "bar":1}], [{"foo":3, "bar":100}]]']
|
||||
|
||||
- title: `min`, `max`, `min_by`, `max_by`
|
||||
- title: '`min`, `max`, `min_by`, `max_by`'
|
||||
body: |
|
||||
|
||||
Find the minimum or maximum element of the input array. The
|
||||
@@ -713,7 +713,7 @@ sections:
|
||||
input: '[{"foo":1, "bar":14}, {"foo":2, "bar":3}]'
|
||||
output: ['{"foo":2, "bar":3}']
|
||||
|
||||
- title: `unique`
|
||||
- title: '`unique`'
|
||||
body: |
|
||||
|
||||
The `unique` function takes as input an array and produces
|
||||
@@ -725,7 +725,7 @@ sections:
|
||||
input: '[1,2,5,3,5,3,1,3]'
|
||||
output: ['[1,2,3,5]']
|
||||
|
||||
- title: `reverse`
|
||||
- title: '`reverse`'
|
||||
body: |
|
||||
|
||||
This function reverses an array.
|
||||
@@ -735,7 +735,7 @@ sections:
|
||||
input: '[1,2,3,4]'
|
||||
output: ['[4,3,2,1]']
|
||||
|
||||
- title: `contains`
|
||||
- title: '`contains`'
|
||||
body: |
|
||||
|
||||
The filter `contains(b)` will produce true if b is
|
||||
@@ -764,7 +764,7 @@ sections:
|
||||
input: '{"foo": 12, "bar":[1,2,{"barp":12, "blip":13}]}'
|
||||
output: ['false']
|
||||
|
||||
- title: `recurse`
|
||||
- title: '`recurse`'
|
||||
body: |
|
||||
|
||||
The `recurse` function allows you to search through a
|
||||
@@ -796,7 +796,7 @@ sections:
|
||||
- '{"foo":[]}'
|
||||
|
||||
|
||||
- title: "String interpolation - `\(foo)`"
|
||||
- title: String interpolation - `\(foo)`
|
||||
body: |
|
||||
|
||||
Inside a string, you can put an expression inside parens
|
||||
@@ -882,7 +882,7 @@ sections:
|
||||
|
||||
- title: Conditionals and Comparisons
|
||||
entries:
|
||||
- title: `==`, `!=`
|
||||
- title: '`==`, `!=`'
|
||||
body: |
|
||||
|
||||
The expression 'a == b' will produce 'true' if the result of a and b
|
||||
@@ -931,7 +931,7 @@ sections:
|
||||
input: 2
|
||||
output: ['"many"']
|
||||
|
||||
- title: `>, >=, <=, <`
|
||||
- title: '`>, >=, <=, <`'
|
||||
body: |
|
||||
|
||||
The comparison operators `>`, `>=`, `<=`, `<` return whether
|
||||
File renamed without changes.
File renamed without changes.
@@ -292,11 +292,37 @@ sections:
|
||||
program can be a useful way of formatting JSON output from,
|
||||
say, `curl`.
|
||||
|
||||
An important point about the identity filter is that it
|
||||
guarantees to preserve the literal decimal representation
|
||||
of values. This is particularly important when dealing with numbers
|
||||
which can't be losslessly converted to an IEEE754 double precision
|
||||
representation.
|
||||
|
||||
jq doesn't truncate the literal numbers to double unless there
|
||||
is a need to make arithmetic operations with the number.
|
||||
Comparisions are carried out over the untruncated big decimal
|
||||
representation of the number.
|
||||
|
||||
jq will also try to maintain the original decimal precision of the provided
|
||||
number literal. See below for examples.
|
||||
|
||||
examples:
|
||||
- program: '.'
|
||||
input: '"Hello, world!"'
|
||||
output: ['"Hello, world!"']
|
||||
|
||||
- program: '. | tojson'
|
||||
input: '12345678909876543212345'
|
||||
output: ['"12345678909876543212345"']
|
||||
|
||||
- program: 'map([., . == 1]) | tojson'
|
||||
input: '[1, 1.000, 1.0, 100e-2]'
|
||||
output: ['"[[1,true],[1.000,true],[1.0,true],[1.00,true]]"']
|
||||
|
||||
- program: '. as $big | [$big, $big + 1] | map(. > 10000000000000000000000000000000)'
|
||||
input: '10000000000000000000000000000001'
|
||||
output: ['[true, false]']
|
||||
|
||||
- title: "Object Identifier-Index: `.foo`, `.foo.bar`"
|
||||
body: |
|
||||
|
||||
@@ -511,6 +537,16 @@ sections:
|
||||
expression that takes an input, ignores it, and returns 42
|
||||
instead.
|
||||
|
||||
Numbers in jq are internally represented by their IEEE754 double
|
||||
precision approximation. Any arithmetic operation with numbers,
|
||||
whether they are literals or results of previous filters, will
|
||||
produce a double precision floating point result.
|
||||
|
||||
However, when parsing a literal jq will store the original literal
|
||||
string. If no mutation is applied to this value then it will make
|
||||
to the output in its original form, even if conversion to double
|
||||
would result in a loss.
|
||||
|
||||
entries:
|
||||
- title: "Array construction: `[]`"
|
||||
body: |
|
||||
@@ -629,6 +665,18 @@ sections:
|
||||
try to add a string to an object you'll get an error message and
|
||||
no result.
|
||||
|
||||
Please note that all numbers are converted to IEEE754 double precision
|
||||
floating point representation. Arithmetic and logical operators are working
|
||||
with these converted doubles. Results of all such operations are also limited
|
||||
to the double precision.
|
||||
|
||||
The only exception to this behaviour of number is a snapshot of original number
|
||||
literal. When a number which originally was provided as a literal is never
|
||||
mutated until the end of the program then it is printed to the output in its
|
||||
original literal form. This also includes cases when the original literal
|
||||
would be truncated when converted to the IEEE754 double precision floating point
|
||||
number.
|
||||
|
||||
entries:
|
||||
- title: "Addition: `+`"
|
||||
body: |
|
||||
File renamed without changes.
@@ -0,0 +1,173 @@
|
||||
body {
|
||||
padding-top: 80px;
|
||||
}
|
||||
|
||||
.container {
|
||||
max-width: 970px;
|
||||
}
|
||||
|
||||
/* index.liquid *******************************************/
|
||||
#blurb {
|
||||
padding-top: 40px;
|
||||
}
|
||||
#blurb p {
|
||||
font-size: 1.9em;
|
||||
}
|
||||
#blurb .btn-group {
|
||||
margin: 4px;
|
||||
}
|
||||
|
||||
#multiblurb {
|
||||
line-height: 1.7;
|
||||
text-align: center;
|
||||
font-size: 12pt;
|
||||
}
|
||||
#multiblurb code {
|
||||
border: 0;
|
||||
font-size: 12pt;
|
||||
}
|
||||
|
||||
#news {
|
||||
font-size: 12pt;
|
||||
}
|
||||
#news .date {
|
||||
font-style: italic;
|
||||
}
|
||||
|
||||
/* default.liquid *****************************************/
|
||||
.tutorial-example {
|
||||
position: relative;
|
||||
margin-bottom: 10px;
|
||||
}
|
||||
.tutorial-example pre {
|
||||
margin-bottom: 0px;
|
||||
}
|
||||
.tutorial-example a {
|
||||
position: absolute;
|
||||
top: 0px;
|
||||
right: 0px;
|
||||
padding: 15px 8px;
|
||||
color: #777777;
|
||||
font-weight: bold;
|
||||
line-height: 10px;
|
||||
font-size: 12px;
|
||||
border-left: 1px solid #DDDDDD;
|
||||
display: block;
|
||||
}
|
||||
.tutorial-example .accordion-body pre {
|
||||
margin: 0 4px;
|
||||
border-top: 0;
|
||||
border-top-left-radius: 0;
|
||||
border-top-right-radius: 0;
|
||||
}
|
||||
|
||||
@media print {
|
||||
.tutorial-example a {
|
||||
display: none;
|
||||
}
|
||||
}
|
||||
/* manual.liquid ******************************************/
|
||||
section {
|
||||
padding-top: 24px;
|
||||
}
|
||||
|
||||
h3 code {
|
||||
border: 0;
|
||||
font-size: 20px;
|
||||
}
|
||||
|
||||
@media (max-width: 991px) {
|
||||
#navcolumn {
|
||||
/* Put nav column above manual content */
|
||||
position: relative !important;
|
||||
margin-bottom: 60px;
|
||||
}
|
||||
}
|
||||
@media (min-width: 992px) {
|
||||
#manualcontent {
|
||||
/* Put nav column left of manual content */
|
||||
padding-left: 280px;
|
||||
}
|
||||
}
|
||||
.nav-pills {
|
||||
margin-bottom: 20px;
|
||||
}
|
||||
.nav-pills li a {
|
||||
padding: 8px 12px;
|
||||
}
|
||||
|
||||
.manual-example table {
|
||||
border-top: 1px solid #E5E5E5;
|
||||
}
|
||||
.manual-example table td {
|
||||
white-space: pre-wrap;
|
||||
font-family: Monaco, Menlo, Consolas, "Courier New", monospace;
|
||||
}
|
||||
.manual-example table td.jqprogram {
|
||||
font-weight: bold;
|
||||
}
|
||||
.manual-example table th {
|
||||
text-align: right;
|
||||
padding-right: 10px;
|
||||
}
|
||||
|
||||
@media print {
|
||||
#navcolumn {
|
||||
display: none !important;
|
||||
}
|
||||
|
||||
.manual-example {
|
||||
display: block !important;
|
||||
height: auto !important;
|
||||
}
|
||||
|
||||
.jqplay-btn {
|
||||
display: none !important;
|
||||
}
|
||||
}
|
||||
/* shared/_footer.liquid **********************************/
|
||||
footer {
|
||||
background-color: #F5F5F5;
|
||||
padding: 20px 0;
|
||||
margin-top: 40px;
|
||||
color: #999999;
|
||||
text-align: center;
|
||||
}
|
||||
footer p {
|
||||
margin: 8px 0;
|
||||
}
|
||||
|
||||
/* typeahead **********************************************/
|
||||
.twitter-typeahead {
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.tt-menu {
|
||||
width: 100%;
|
||||
background-color: #fff;
|
||||
padding: 8px 0;
|
||||
border: 1px solid #ccc;
|
||||
border: 1px solid rgba(0, 0, 0, 0.2);
|
||||
-webkit-border-radius: 8px;
|
||||
-moz-border-radius: 8px;
|
||||
border-radius: 8px;
|
||||
-webkit-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
|
||||
-moz-box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
|
||||
box-shadow: 0 5px 10px rgba(0, 0, 0, 0.2);
|
||||
}
|
||||
|
||||
.tt-suggestion {
|
||||
padding: 3px 20px;
|
||||
}
|
||||
.tt-suggestion:hover {
|
||||
cursor: pointer;
|
||||
color: #fff;
|
||||
background-color: #446e9b;
|
||||
}
|
||||
.tt-suggestion.tt-cursor {
|
||||
color: #fff;
|
||||
background-color: #446e9b;
|
||||
}
|
||||
.tt-suggestion p {
|
||||
margin: 0;
|
||||
}
|
||||
@@ -1,26 +1,26 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
{% include "shared/head" %}
|
||||
{% include "shared/_head.html.j2" %}
|
||||
|
||||
<body id="{{slug}}">
|
||||
{% include "shared/navbar" %}
|
||||
{% include "shared/_navbar.html.j2" %}
|
||||
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
<h1>{{headline}}</h1>
|
||||
{% for item in body %}
|
||||
{% if item.text %}
|
||||
{{ item.text | replace: '$JQ_VERSION', jq_version | markdownify }}
|
||||
{{ item.text | replace('$JQ_VERSION', jq_version) | markdownify }}
|
||||
{% endif %}
|
||||
|
||||
{% if item.command %}
|
||||
{% capture resultID %}{{ "result" | unique}}{% endcapture %}
|
||||
{% set resultID = unique_id() %}
|
||||
<div class="tutorial-example">
|
||||
<div class="accordion-heading">
|
||||
<pre>{{item.command}}</pre>
|
||||
<a data-toggle="collapse" href="#{{resultID}}">Show result</a>
|
||||
<a data-toggle="collapse" href="#result{{resultID}}">Show result</a>
|
||||
</div>
|
||||
<div id="{{resultID}}" class="accordion-body collapse">
|
||||
<div id="result{{resultID}}" class="accordion-body collapse">
|
||||
<pre>{{item.result}}</pre>
|
||||
</div>
|
||||
</div>
|
||||
@@ -29,6 +29,6 @@
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{% include "shared/footer" %}
|
||||
{% include "shared/_footer.html.j2" %}
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,9 +1,9 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
{% include "shared/head" %}
|
||||
{% include "shared/_head.html.j2" %}
|
||||
|
||||
<body id="{{slug}}">
|
||||
{% include "shared/navbar" %}
|
||||
<body id="{{ slug }}">
|
||||
{% include "shared/_navbar.html.j2" %}
|
||||
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
@@ -27,7 +27,7 @@
|
||||
<li><a href="https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64">Linux (64-bit)</a></li>
|
||||
<li><a href="https://github.com/stedolan/jq/releases/download/jq-1.6/jq-osx-amd64">OS X (64-bit)</a></li>
|
||||
<li><a href="https://github.com/stedolan/jq/releases/download/jq-1.6/jq-win64.exe">Windows (64-bit)</a></li>
|
||||
<li><a href="/jq/download/">Other platforms, older versions, and source</a></li>
|
||||
<li><a href="{{root}}/download/">Other platforms, older versions, and source</a></li>
|
||||
</ul>
|
||||
</div>
|
||||
|
||||
@@ -68,6 +68,6 @@
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{% include "shared/footer" %}
|
||||
{% include "shared/_footer.html.j2" %}
|
||||
</body>
|
||||
</html>
|
||||
+16
-16
@@ -1,9 +1,9 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
{% include "shared/head" %}
|
||||
{% include "shared/_head.html.j2" %}
|
||||
|
||||
<body id="{{slug}}" data-spy="scroll" data-target="#navcolumn" data-offset="100">
|
||||
{% include "shared/navbar" %}
|
||||
{% include "shared/_navbar.html.j2" %}
|
||||
|
||||
<div class="container">
|
||||
<div class="row">
|
||||
@@ -32,41 +32,41 @@
|
||||
{% for section in sections %}
|
||||
<section id="{{section.title | section_id}}">
|
||||
<h2>{{section.title}}</h2>
|
||||
{{section.body | markdownify}}
|
||||
{{ (section.body | markdownify) if section.body }}
|
||||
{% for entry in section.entries %}
|
||||
<section id="{{entry.title | entry_id}}">
|
||||
<h3>
|
||||
{{entry.title | markdownify | no_paragraph}}
|
||||
{{entry.title | markdownify | no_paragraph }}
|
||||
{% if entry.subtitle %}<small>{{entry.subtitle}}</small>{% endif %}
|
||||
</h3>
|
||||
{{entry.body | markdownify}}
|
||||
|
||||
{% if entry.examples %}
|
||||
<div>
|
||||
{% capture exampleID %}{{ "" | unique }}{% endcapture %}
|
||||
{% set exampleID = unique_id() %}
|
||||
<a data-toggle="collapse" href="#example{{exampleID}}">
|
||||
<i class="glyphicon glyphicon-chevron-right"></i>
|
||||
{% if entry.examples[1] %}Examples{%else%}Example{%endif%}
|
||||
{% if entry.examples | length > 1 %}Examples{%else%}Example{%endif%}
|
||||
</a>
|
||||
<div id="example{{exampleID}}" class="manual-example collapse">
|
||||
{% for example in entry.examples %}
|
||||
<table>
|
||||
<tr><th></th><td class="jqprogram">jq '{{example.program | escape}}'</td></tr>
|
||||
<tr><th>Input</th><td>{{example.input | escape}}</td></tr>
|
||||
{% unless example.output[0] %}
|
||||
<tr><th></th><td class="jqprogram">jq '{{ example.program }}'</td></tr>
|
||||
<tr><th>Input</th><td>{{ example.input }}</td></tr>
|
||||
{% if not example.output[0] %}
|
||||
<tr>
|
||||
<th>Output</th>
|
||||
<td><i>none</i></td>
|
||||
</tr>
|
||||
{% endunless %}
|
||||
{% endif %}
|
||||
{% for output in example.output %}
|
||||
<tr>
|
||||
{% if forloop.index == 1 %}
|
||||
{% if loop.first %}
|
||||
<th>Output</th>
|
||||
{% else %}
|
||||
<th></th>
|
||||
{% endif %}
|
||||
<td>{{output | escape}}</td>
|
||||
<td>{{ output }}</td>
|
||||
</tr>
|
||||
{% endfor %}
|
||||
</table>
|
||||
@@ -82,15 +82,15 @@
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{% include "shared/footer" %}
|
||||
{% include "shared/_footer.html.j2" %}
|
||||
<script>
|
||||
var section_map = {
|
||||
{% for section in sections %}
|
||||
{% for entry in section.entries %}
|
||||
{{entry.title | search_id | json}} : {{entry.title | entry_id | json}},
|
||||
{{entry.title | search_id | tojson }} : {{entry.title | entry_id | tojson }},
|
||||
{% endfor %}
|
||||
{{section.title | search_id | json}} : {{section.title | section_id | json}}
|
||||
{% unless forloop.last %},{% endunless %}
|
||||
{{section.title | search_id | tojson }} : {{section.title | section_id | tojson }}
|
||||
{% if not loop.last %},{% endif %}
|
||||
{% endfor %}
|
||||
};
|
||||
</script>
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
<footer>
|
||||
<div class="container">
|
||||
<p>This website is made with <a href="http://www.tinytree.info">Bonsai</a> and <a href="http://getbootstrap.com">Bootstrap</a>, themed with <a href="https://bootswatch.com">Bootswatch</a>.</p>
|
||||
<p>This website is made with <a href="http://getbootstrap.com">Bootstrap</a>, themed with <a href="https://bootswatch.com">Bootswatch</a>.</p>
|
||||
<p>jq is licensed under the MIT license (code) and the <a href="https://creativecommons.org/licenses/by/3.0/">CC-BY-3.0</a> license (docs).</p>
|
||||
</div>
|
||||
</footer>
|
||||
@@ -7,9 +7,9 @@
|
||||
<title>{{headline}}</title>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
|
||||
<link rel="canonical" href="{{url}}{{permalink | remove:'/index'}}" />
|
||||
<link rel="canonical" href="{{ url }}{{ permalink | replace('/index','') }}" />
|
||||
<link href="https://maxcdn.bootstrapcdn.com/bootswatch/3.3.5/spacelab/bootstrap.min.css" rel="stylesheet" integrity="sha256-j7Dtnd7ZjexEiPNbscbopFn9+Cs0b3TLipKsWAPHZIM= sha512-RFhfi6P8zWMAJrEGU+CPjuxPh3r/UUBGqQ+/o6WKPIVZmQqeOipGotH2ihRULuQ8wsMBoK15TSZqc/7VYWyuIw==" crossorigin="anonymous">
|
||||
<link rel="stylesheet" href="{{root}}/css/base.css" type="text/css">
|
||||
<link rel="stylesheet" href="{{ root }}/css/base.css" type="text/css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
|
||||
<script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
|
||||
+2
-2
@@ -13,8 +13,8 @@
|
||||
<div class="navbar-collapse collapse" id="nav-collapse">
|
||||
<ul class="nav navbar-nav">
|
||||
{% for item in navigation %}
|
||||
<li {% if item.permalink == permalink %} class="active" {% endif %}>
|
||||
<a href="{{root}}{{item.permalink}}">{{item.name}}</a>
|
||||
<li {% if item == permalink %} class="active" {% endif %}>
|
||||
<a href="{{root}}/{{item}}">{{item | capitalize}}</a>
|
||||
</li>
|
||||
{% endfor %}
|
||||
<li><a href="https://github.com/stedolan/jq/issues">Issues</a></li>
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
prefix=@prefix@
|
||||
exec_prefix=@exec_prefix@
|
||||
libdir=@libdir@
|
||||
includedir=@includedir@
|
||||
|
||||
Name: libjq
|
||||
URL: https://stedolan.github.io/jq/
|
||||
Description: Library to process JSON using a query language
|
||||
Version: @VERSION@
|
||||
Libs: -L${libdir} -ljq
|
||||
Cflags: -I${includedir}
|
||||
@@ -11,7 +11,7 @@ set -o xtrace
|
||||
scriptdir=`dirname "$0"`
|
||||
cd "$scriptdir"/../docs
|
||||
rm -rf output
|
||||
rake build
|
||||
pipenv run python3 build_website.py
|
||||
cd ..
|
||||
|
||||
# copy to /tmp
|
||||
|
||||
+24
-8
@@ -90,8 +90,11 @@ static jv f_plus(jq_state *jq, jv input, jv a, jv b) {
|
||||
jv_free(b);
|
||||
return a;
|
||||
} else if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
||||
return jv_number(jv_number_value(a) +
|
||||
jv r = jv_number(jv_number_value(a) +
|
||||
jv_number_value(b));
|
||||
jv_free(a);
|
||||
jv_free(b);
|
||||
return r;
|
||||
} else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
|
||||
return jv_string_concat(a, b);
|
||||
} else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
|
||||
@@ -274,7 +277,10 @@ static jv f_rtrimstr(jq_state *jq, jv input, jv right) {
|
||||
static jv f_minus(jq_state *jq, jv input, jv a, jv b) {
|
||||
jv_free(input);
|
||||
if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
||||
return jv_number(jv_number_value(a) - jv_number_value(b));
|
||||
jv r = jv_number(jv_number_value(a) - jv_number_value(b));
|
||||
jv_free(a);
|
||||
jv_free(b);
|
||||
return r;
|
||||
} else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
|
||||
jv out = jv_array();
|
||||
jv_array_foreach(a, i, x) {
|
||||
@@ -302,7 +308,10 @@ static jv f_multiply(jq_state *jq, jv input, jv a, jv b) {
|
||||
jv_kind bk = jv_get_kind(b);
|
||||
jv_free(input);
|
||||
if (ak == JV_KIND_NUMBER && bk == JV_KIND_NUMBER) {
|
||||
return jv_number(jv_number_value(a) * jv_number_value(b));
|
||||
jv r = jv_number(jv_number_value(a) * jv_number_value(b));
|
||||
jv_free(a);
|
||||
jv_free(b);
|
||||
return r;
|
||||
} else if ((ak == JV_KIND_STRING && bk == JV_KIND_NUMBER) ||
|
||||
(ak == JV_KIND_NUMBER && bk == JV_KIND_STRING)) {
|
||||
jv str = a;
|
||||
@@ -336,7 +345,10 @@ static jv f_divide(jq_state *jq, jv input, jv a, jv b) {
|
||||
if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
||||
if (jv_number_value(b) == 0.0)
|
||||
return type_error2(a, b, "cannot be divided because the divisor is zero");
|
||||
return jv_number(jv_number_value(a) / jv_number_value(b));
|
||||
jv r = jv_number(jv_number_value(a) / jv_number_value(b));
|
||||
jv_free(a);
|
||||
jv_free(b);
|
||||
return r;
|
||||
} else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
|
||||
return jv_string_split(a, b);
|
||||
} else {
|
||||
@@ -349,7 +361,10 @@ static jv f_mod(jq_state *jq, jv input, jv a, jv b) {
|
||||
if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
||||
if ((intmax_t)jv_number_value(b) == 0)
|
||||
return type_error2(a, b, "cannot be divided (remainder) because the divisor is zero");
|
||||
return jv_number((intmax_t)jv_number_value(a) % (intmax_t)jv_number_value(b));
|
||||
jv r = jv_number((intmax_t)jv_number_value(a) % (intmax_t)jv_number_value(b));
|
||||
jv_free(a);
|
||||
jv_free(b);
|
||||
return r;
|
||||
} else {
|
||||
return type_error2(a, b, "cannot be divided (remainder)");
|
||||
}
|
||||
@@ -440,7 +455,9 @@ static jv f_length(jq_state *jq, jv input) {
|
||||
} else if (jv_get_kind(input) == JV_KIND_STRING) {
|
||||
return jv_number(jv_string_length_codepoints(input));
|
||||
} else if (jv_get_kind(input) == JV_KIND_NUMBER) {
|
||||
return jv_number(fabs(jv_number_value(input)));
|
||||
jv r = jv_number(fabs(jv_number_value(input)));
|
||||
jv_free(input);
|
||||
return r;
|
||||
} else if (jv_get_kind(input) == JV_KIND_NULL) {
|
||||
jv_free(input);
|
||||
return jv_number(0);
|
||||
@@ -1793,7 +1810,6 @@ int builtins_bind(jq_state *jq, block* bb) {
|
||||
builtins = gen_cbinding(function_list, sizeof(function_list)/sizeof(function_list[0]), builtins);
|
||||
builtins = gen_builtin_list(builtins);
|
||||
|
||||
*bb = block_bind_incremental(builtins, *bb, OP_IS_CALL_PSEUDO);
|
||||
*bb = block_drop_unreferenced(*bb);
|
||||
*bb = block_bind_referenced(builtins, *bb, OP_IS_CALL_PSEUDO);
|
||||
return nerrors;
|
||||
}
|
||||
+35
-73
@@ -32,33 +32,18 @@ def index($i): indices($i) | .[0]; # TODO: optimize
|
||||
def rindex($i): indices($i) | .[-1:][0]; # TODO: optimize
|
||||
def paths: path(recurse(if (type|. == "array" or . == "object") then .[] else empty end))|select(length > 0);
|
||||
def paths(node_filter): . as $dot|paths|select(. as $p|$dot|getpath($p)|node_filter);
|
||||
def any(generator; condition):
|
||||
[label $out | foreach generator as $i
|
||||
(false;
|
||||
if . then break $out elif $i | condition then true else . end;
|
||||
if . then . else empty end)] | length == 1;
|
||||
def any(condition): any(.[]; condition);
|
||||
def any: any(.);
|
||||
def all(generator; condition):
|
||||
[label $out | foreach generator as $i
|
||||
(true;
|
||||
if .|not then break $out elif $i | condition then . else false end;
|
||||
if .|not then . else empty end)] | length == 0;
|
||||
def all(condition): all(.[]; condition);
|
||||
def all: all(.);
|
||||
def isfinite: type == "number" and (isinfinite | not);
|
||||
def arrays: select(type == "array");
|
||||
def objects: select(type == "object");
|
||||
def iterables: arrays, objects;
|
||||
def iterables: select(type|. == "array" or . == "object");
|
||||
def booleans: select(type == "boolean");
|
||||
def numbers: select(type == "number");
|
||||
def normals: select(isnormal);
|
||||
def finites: select(isfinite);
|
||||
def strings: select(type == "string");
|
||||
def nulls: select(type == "null");
|
||||
def nulls: select(. == null);
|
||||
def values: select(. != null);
|
||||
def scalars: select(. == null or . == true or . == false or type == "number" or type == "string");
|
||||
def scalars_or_empty: select(. == null or . == true or . == false or type == "number" or type == "string" or ((type=="array" or type=="object") and length==0));
|
||||
def scalars: select(type|. != "array" and . != "object");
|
||||
def leaf_paths: paths(scalars);
|
||||
def join($x): reduce .[] as $i (null;
|
||||
(if .==null then "" else .+$x end) +
|
||||
@@ -153,11 +138,6 @@ def gsub($re; s; flags): sub($re; s; flags + "g");
|
||||
def gsub($re; s): sub($re; s; "g");
|
||||
|
||||
########################################################################
|
||||
# range/3, with a `by` expression argument
|
||||
def range($init; $upto; $by):
|
||||
def _range:
|
||||
if ($by > 0 and . < $upto) or ($by < 0 and . > $upto) then ., ((.+$by)|_range) else . end;
|
||||
if $by == 0 then $init else $init|_range end | select(($by > 0 and . < $upto) or ($by < 0 and . > $upto));
|
||||
# generic iterator/generator
|
||||
def while(cond; update):
|
||||
def _while:
|
||||
@@ -171,8 +151,19 @@ def limit($n; exp):
|
||||
if $n > 0 then label $out | foreach exp as $item ($n; .-1; $item, if . <= 0 then break $out else empty end)
|
||||
elif $n == 0 then empty
|
||||
else exp end;
|
||||
def isempty(g): 0 == ((label $go | g | (1, break $go)) // 0);
|
||||
# range/3, with a `by` expression argument
|
||||
def range($init; $upto; $by):
|
||||
if $by > 0 then $init|while(. < $upto; . + $by)
|
||||
elif $by < 0 then $init|while(. > $upto; . + $by)
|
||||
else empty end;
|
||||
def first(g): label $out | g | ., break $out;
|
||||
def isempty(g): first((g|false), true);
|
||||
def all(generator; condition): isempty(generator|condition and empty);
|
||||
def any(generator; condition): isempty(generator|condition or empty)|not;
|
||||
def all(condition): all(.[]; condition);
|
||||
def any(condition): any(.[]; condition);
|
||||
def all: all(.[]; .);
|
||||
def any: any(.[]; .);
|
||||
def last(g): reduce g as $item (null; $item);
|
||||
def nth($n; g): if $n < 0 then error("nth doesn't support negative indices") else last(limit($n + 1; g)) end;
|
||||
def first: .[0];
|
||||
@@ -204,7 +195,7 @@ def repeat(exp):
|
||||
def _repeat:
|
||||
exp, _repeat;
|
||||
_repeat;
|
||||
def inputs: try repeat(input) catch if .=="break" then empty else .|error end;
|
||||
def inputs: try repeat(input) catch if .=="break" then empty else error end;
|
||||
# like ruby's downcase - only characters A to Z are affected
|
||||
def ascii_downcase:
|
||||
explode | map( if 65 <= . and . <= 90 then . + 32 else . end) | implode;
|
||||
@@ -215,53 +206,28 @@ def ascii_upcase:
|
||||
# Streaming utilities
|
||||
def truncate_stream(stream):
|
||||
. as $n | null | stream | . as $input | if (.[0]|length) > $n then setpath([0];$input[0][$n:]) else empty end;
|
||||
def fromstream(i):
|
||||
foreach i as $i (
|
||||
[null, null];
|
||||
|
||||
if ($i | length) == 2 then
|
||||
if ($i[0] | length) == 0 then .
|
||||
else [ ( .[0] | setpath($i[0]; $i[1]) ), .[1] ]
|
||||
end
|
||||
elif ($i[0] | length) == 1 then [ null, .[0] ]
|
||||
else .
|
||||
end;
|
||||
|
||||
if ($i | length) == 1 then
|
||||
if ($i[0] | length) == 1 then .[1]
|
||||
else empty
|
||||
end
|
||||
elif ($i[0] | length) == 0 then $i[1]
|
||||
else empty
|
||||
end
|
||||
);
|
||||
def fromstream(i): {x: null, e: false} as $init |
|
||||
# .x = object being built; .e = emit and reset state
|
||||
foreach i as $i ($init
|
||||
; if .e then $init else . end
|
||||
| if $i|length == 2
|
||||
then setpath(["e"]; $i[0]|length==0) | setpath(["x"]+$i[0]; $i[1])
|
||||
else setpath(["e"]; $i[0]|length==1) end
|
||||
; if .e then .x else empty end);
|
||||
def tostream:
|
||||
{string:true,number:true,boolean:true,null:true} as $leaf_types |
|
||||
. as $dot |
|
||||
if $leaf_types[$dot|type] or length==0 then [[],$dot]
|
||||
else
|
||||
# We really need a _streaming_ form of `keys`.
|
||||
# We can use `range` for arrays, but not for objects.
|
||||
keys_unsorted as $keys |
|
||||
$keys[-1] as $last|
|
||||
((# for each key
|
||||
$keys[] | . as $key |
|
||||
$dot[$key] | . as $dot |
|
||||
# recurse on each key/value
|
||||
tostream|.[0]|=[$key]+.),
|
||||
# then add the closing marker
|
||||
[[$last]])
|
||||
end;
|
||||
path(def r: (.[]?|r), .; r) as $p |
|
||||
getpath($p) |
|
||||
reduce path(.[]?) as $q ([$p, .]; [$p+$q]);
|
||||
|
||||
|
||||
# Assuming the input array is sorted, bsearch/1 returns
|
||||
# the index of the target if the target is in the input array; and otherwise
|
||||
# (-1 - ix), where ix is the insertion point that would leave the array sorted.
|
||||
# If the input is not sorted, bsearch will terminate but with irrelevant results.
|
||||
def bsearch(target):
|
||||
def bsearch($target):
|
||||
if length == 0 then -1
|
||||
elif length == 1 then
|
||||
if target == .[0] then 0 elif target < .[0] then -1 else -2 end
|
||||
if $target == .[0] then 0 elif $target < .[0] then -1 else -2 end
|
||||
else . as $in
|
||||
# state variable: [start, end, answer]
|
||||
# where start and end are the upper and lower offsets to use.
|
||||
@@ -271,14 +237,14 @@ def bsearch(target):
|
||||
else
|
||||
( ( (.[1] + .[0]) / 2 ) | floor ) as $mid
|
||||
| $in[$mid] as $monkey
|
||||
| if $monkey == target then (.[2] = $mid) # success
|
||||
| if $monkey == $target then (.[2] = $mid) # success
|
||||
elif .[0] == .[1] then (.[1] = -1) # failure
|
||||
elif $monkey < target then (.[0] = ($mid + 1))
|
||||
elif $monkey < $target then (.[0] = ($mid + 1))
|
||||
else (.[1] = ($mid - 1))
|
||||
end
|
||||
end )
|
||||
| if .[2] == null then # compute the insertion point
|
||||
if $in[ .[0] ] < target then (-2 -.[0])
|
||||
if $in[ .[0] ] < $target then (-2 -.[0])
|
||||
else (-1 -.[0])
|
||||
end
|
||||
else .[2]
|
||||
@@ -297,11 +263,7 @@ def walk(f):
|
||||
|
||||
# SQL-ish operators here:
|
||||
def INDEX(stream; idx_expr):
|
||||
reduce stream as $row ({};
|
||||
.[$row|idx_expr|
|
||||
if type != "string" then tojson
|
||||
else .
|
||||
end] |= $row);
|
||||
reduce stream as $row ({}; .[$row|idx_expr|tostring] = $row);
|
||||
def INDEX(idx_expr): INDEX(.[]; idx_expr);
|
||||
def JOIN($idx; idx_expr):
|
||||
[.[] | [., $idx[idx_expr]]];
|
||||
@@ -309,5 +271,5 @@ def JOIN($idx; stream; idx_expr):
|
||||
stream | [., $idx[idx_expr]];
|
||||
def JOIN($idx; stream; idx_expr; join_expr):
|
||||
stream | [., $idx[idx_expr]] | join_expr;
|
||||
def IN(s): reduce (first(select(. == s)) | true) as $v (false; if . or $v then true else false end);
|
||||
def IN(src; s): reduce (src|IN(s)) as $v (false; if . or $v then true else false end);
|
||||
def IN(s): any(s == .; .);
|
||||
def IN(src; s): any(src == s; .);
|
||||
+17
-36
@@ -290,18 +290,6 @@ int block_has_only_binders(block binders, int bindflags) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Count a binder's (function) formal params
|
||||
static int block_count_formals(block b) {
|
||||
int args = 0;
|
||||
if (b.first->op == CLOSURE_CREATE_C)
|
||||
return b.first->imm.cfunc->nargs - 1;
|
||||
for (inst* i = b.first->arglist.first; i; i = i->next) {
|
||||
assert(i->op == CLOSURE_PARAM);
|
||||
args++;
|
||||
}
|
||||
return args;
|
||||
}
|
||||
|
||||
// Count a call site's actual params
|
||||
static int block_count_actuals(block b) {
|
||||
int args = 0;
|
||||
@@ -326,8 +314,6 @@ static int block_bind_subblock_inner(int* any_unbound, block binder, block body,
|
||||
assert(break_distance >= 0);
|
||||
|
||||
binder.first->bound_by = binder.first;
|
||||
if (binder.first->nformals == -1)
|
||||
binder.first->nformals = block_count_formals(binder);
|
||||
int nrefs = 0;
|
||||
for (inst* i = body.first; i; i = i->next) {
|
||||
if (i->any_unbound == 0)
|
||||
@@ -341,8 +327,6 @@ static int block_bind_subblock_inner(int* any_unbound, block binder, block body,
|
||||
break_distance <= 3 && (i->symbol[1] == '1' + break_distance) &&
|
||||
i->symbol[2] == '\0'))) {
|
||||
// bind this instruction
|
||||
if (i->op == CALL_JQ && i->nactuals == -1)
|
||||
i->nactuals = block_count_actuals(i->arglist);
|
||||
if (i->nactuals == -1 || i->nactuals == binder.first->nformals) {
|
||||
i->bound_by = binder.first;
|
||||
nrefs++;
|
||||
@@ -400,7 +384,7 @@ block block_bind_library(block binder, block body, int bindflags, const char *li
|
||||
matchlen += 2;
|
||||
}
|
||||
assert(block_has_only_binders(binder, bindflags));
|
||||
for (inst *curr = binder.first; curr; curr = curr->next) {
|
||||
for (inst *curr = binder.last; curr; curr = curr->prev) {
|
||||
int bindflags2 = bindflags;
|
||||
char* cname = curr->symbol;
|
||||
char* tname = jv_mem_alloc(strlen(curr->symbol)+matchlen+1);
|
||||
@@ -421,20 +405,6 @@ block block_bind_library(block binder, block body, int bindflags, const char *li
|
||||
return body; // We don't return a join because we don't want those sticking around...
|
||||
}
|
||||
|
||||
// Bind binder to body, then throw it away if not referenced.
|
||||
block block_bind_referenced(block binder, block body, int bindflags) {
|
||||
assert(block_is_single(binder));
|
||||
assert(block_has_only_binders(binder, bindflags));
|
||||
bindflags |= OP_HAS_BINDING;
|
||||
|
||||
if (block_bind_subblock(binder, body, bindflags, 0) == 0) {
|
||||
block_free(binder);
|
||||
} else {
|
||||
body = BLOCK(binder, body);
|
||||
}
|
||||
return body;
|
||||
}
|
||||
|
||||
static inst* block_take_last(block* b) {
|
||||
inst* i = b->last;
|
||||
if (i == 0)
|
||||
@@ -452,13 +422,18 @@ static inst* block_take_last(block* b) {
|
||||
|
||||
// Binds a sequence of binders, which *must not* alrady be bound to each other,
|
||||
// to body, throwing away unreferenced defs
|
||||
block block_bind_incremental(block binder, block body, int bindflags) {
|
||||
block block_bind_referenced(block binder, block body, int bindflags) {
|
||||
assert(block_has_only_binders(binder, bindflags));
|
||||
bindflags |= OP_HAS_BINDING;
|
||||
|
||||
inst* curr;
|
||||
while ((curr = block_take_last(&binder))) {
|
||||
body = block_bind_referenced(inst_block(curr), body, bindflags);
|
||||
block b = inst_block(curr);
|
||||
if (block_bind_subblock(b, body, bindflags, 0) == 0) {
|
||||
block_free(b);
|
||||
} else {
|
||||
body = BLOCK(b, body);
|
||||
}
|
||||
}
|
||||
return body;
|
||||
}
|
||||
@@ -503,7 +478,7 @@ block block_drop_unreferenced(block body) {
|
||||
if (curr->bound_by == curr && !curr->referenced) {
|
||||
inst_free(curr);
|
||||
} else {
|
||||
refd = BLOCK(inst_block(curr), refd);
|
||||
refd = BLOCK(refd, inst_block(curr));
|
||||
}
|
||||
}
|
||||
return refd;
|
||||
@@ -575,7 +550,10 @@ block gen_import_meta(block import, block metadata) {
|
||||
|
||||
block gen_function(const char* name, block formals, block body) {
|
||||
inst* i = inst_new(CLOSURE_CREATE);
|
||||
int nformals = 0;
|
||||
for (inst* i = formals.last; i; i = i->prev) {
|
||||
nformals++;
|
||||
i->nformals = 0;
|
||||
if (i->op == CLOSURE_PARAM_REGULAR) {
|
||||
i->op = CLOSURE_PARAM;
|
||||
body = gen_var_binding(gen_call(i->symbol, gen_noop()), i->symbol, body);
|
||||
@@ -585,6 +563,7 @@ block gen_function(const char* name, block formals, block body) {
|
||||
i->subfn = body;
|
||||
i->symbol = strdup(name);
|
||||
i->any_unbound = -1;
|
||||
i->nformals = nformals;
|
||||
i->arglist = formals;
|
||||
block b = inst_block(i);
|
||||
block_bind_subblock(b, b, OP_IS_CALL_PSEUDO | OP_HAS_BINDING, 0);
|
||||
@@ -606,6 +585,7 @@ block gen_lambda(block body) {
|
||||
block gen_call(const char* name, block args) {
|
||||
block b = gen_op_unbound(CALL_JQ, name);
|
||||
b.first->arglist = args;
|
||||
b.first->nactuals = block_count_actuals(b.first->arglist);
|
||||
return b;
|
||||
}
|
||||
|
||||
@@ -1115,7 +1095,8 @@ block gen_cbinding(const struct cfunction* cfunctions, int ncfunctions, block co
|
||||
for (int cfunc=0; cfunc<ncfunctions; cfunc++) {
|
||||
inst* i = inst_new(CLOSURE_CREATE_C);
|
||||
i->imm.cfunc = &cfunctions[cfunc];
|
||||
i->symbol = strdup(i->imm.cfunc->name);
|
||||
i->symbol = strdup(cfunctions[cfunc].name);
|
||||
i->nformals = cfunctions[cfunc].nargs - 1;
|
||||
i->any_unbound = 0;
|
||||
code = BLOCK(inst_block(i), code);
|
||||
}
|
||||
@@ -1183,7 +1164,7 @@ static int expand_call_arglist(block* b, jv args, jv *env) {
|
||||
else if (curr->op == LOADV)
|
||||
locfile_locate(curr->locfile, curr->source, "jq: error: $%s is not defined", curr->symbol);
|
||||
else
|
||||
locfile_locate(curr->locfile, curr->source, "jq: error: %s/%d is not defined", curr->symbol, block_count_actuals(curr->arglist));
|
||||
locfile_locate(curr->locfile, curr->source, "jq: error: %s/%d is not defined", curr->symbol, curr->nactuals);
|
||||
errors++;
|
||||
// don't process this instruction if it's not well-defined
|
||||
ret = BLOCK(ret, inst_block(curr));
|
||||
|
||||
@@ -74,7 +74,6 @@ int block_is_funcdef(block b);
|
||||
int block_is_single(block b);
|
||||
block block_bind_library(block binder, block body, int bindflags, const char* libname);
|
||||
block block_bind_referenced(block binder, block body, int bindflags);
|
||||
block block_bind_incremental(block binder, block body, int bindflags);
|
||||
block block_bind_self(block binder, int bindflags);
|
||||
block block_drop_unreferenced(block body);
|
||||
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii"></meta>
|
||||
<title>ICU License - ICU 1.8.1 and later</title>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<h1>ICU License - ICU 1.8.1 and later</h1>
|
||||
<pre>
|
||||
COPYRIGHT AND PERMISSION NOTICE
|
||||
|
||||
Copyright (c) 1995-2005 International Business Machines Corporation and others
|
||||
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, and/or sell copies of the Software, and to permit persons
|
||||
to whom the Software is furnished to do so, provided that the above
|
||||
copyright notice(s) and this permission notice appear in all copies of
|
||||
the Software and that both the above copyright notice(s) and this
|
||||
permission notice appear in supporting documentation.
|
||||
|
||||
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
|
||||
OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
||||
INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
||||
FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
||||
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
||||
WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of a copyright holder
|
||||
shall not be used in advertising or otherwise to promote the sale, use
|
||||
or other dealings in this Software without prior written authorization
|
||||
of the copyright holder.
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
All trademarks and registered trademarks mentioned herein are the property of their respective owners.
|
||||
</pre>
|
||||
</body>
|
||||
</html>
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,437 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Context module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2009. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises the routines for handling arithmetic */
|
||||
/* context structures. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#include <string.h> // for strcmp
|
||||
#include <stdio.h> // for printf if DECCHECK
|
||||
#include "decContext.h" // context and base types
|
||||
#include "decNumberLocal.h" // decNumber local types, etc.
|
||||
|
||||
/* compile-time endian tester [assumes sizeof(Int)>1] */
|
||||
static const Int mfcone=1; // constant 1
|
||||
static const Flag *mfctop=(const Flag *)&mfcone; // -> top byte
|
||||
#define LITEND *mfctop // named flag; 1=little-endian
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* round-for-reround digits */
|
||||
/* ------------------------------------------------------------------ */
|
||||
const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Powers of ten (powers[n]==10**n, 0<=n<=9) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
const uInt DECPOWERS[10]={1, 10, 100, 1000, 10000, 100000, 1000000,
|
||||
10000000, 100000000, 1000000000};
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextClearStatus -- clear bits in current status */
|
||||
/* */
|
||||
/* context is the context structure to be queried */
|
||||
/* mask indicates the bits to be cleared (the status bit that */
|
||||
/* corresponds to each 1 bit in the mask is cleared) */
|
||||
/* returns context */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext *decContextClearStatus(decContext *context, uInt mask) {
|
||||
context->status&=~mask;
|
||||
return context;
|
||||
} // decContextClearStatus
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextDefault -- initialize a context structure */
|
||||
/* */
|
||||
/* context is the structure to be initialized */
|
||||
/* kind selects the required set of default values, one of: */
|
||||
/* DEC_INIT_BASE -- select ANSI X3-274 defaults */
|
||||
/* DEC_INIT_DECIMAL32 -- select IEEE 754 defaults, 32-bit */
|
||||
/* DEC_INIT_DECIMAL64 -- select IEEE 754 defaults, 64-bit */
|
||||
/* DEC_INIT_DECIMAL128 -- select IEEE 754 defaults, 128-bit */
|
||||
/* For any other value a valid context is returned, but with */
|
||||
/* Invalid_operation set in the status field. */
|
||||
/* returns a context structure with the appropriate initial values. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext * decContextDefault(decContext *context, Int kind) {
|
||||
// set defaults...
|
||||
context->digits=9; // 9 digits
|
||||
context->emax=DEC_MAX_EMAX; // 9-digit exponents
|
||||
context->emin=DEC_MIN_EMIN; // .. balanced
|
||||
context->round=DEC_ROUND_HALF_UP; // 0.5 rises
|
||||
context->traps=DEC_Errors; // all but informational
|
||||
context->status=0; // cleared
|
||||
context->clamp=0; // no clamping
|
||||
#if DECSUBSET
|
||||
context->extended=0; // cleared
|
||||
#endif
|
||||
switch (kind) {
|
||||
case DEC_INIT_BASE:
|
||||
// [use defaults]
|
||||
break;
|
||||
case DEC_INIT_DECIMAL32:
|
||||
context->digits=7; // digits
|
||||
context->emax=96; // Emax
|
||||
context->emin=-95; // Emin
|
||||
context->round=DEC_ROUND_HALF_EVEN; // 0.5 to nearest even
|
||||
context->traps=0; // no traps set
|
||||
context->clamp=1; // clamp exponents
|
||||
#if DECSUBSET
|
||||
context->extended=1; // set
|
||||
#endif
|
||||
break;
|
||||
case DEC_INIT_DECIMAL64:
|
||||
context->digits=16; // digits
|
||||
context->emax=384; // Emax
|
||||
context->emin=-383; // Emin
|
||||
context->round=DEC_ROUND_HALF_EVEN; // 0.5 to nearest even
|
||||
context->traps=0; // no traps set
|
||||
context->clamp=1; // clamp exponents
|
||||
#if DECSUBSET
|
||||
context->extended=1; // set
|
||||
#endif
|
||||
break;
|
||||
case DEC_INIT_DECIMAL128:
|
||||
context->digits=34; // digits
|
||||
context->emax=6144; // Emax
|
||||
context->emin=-6143; // Emin
|
||||
context->round=DEC_ROUND_HALF_EVEN; // 0.5 to nearest even
|
||||
context->traps=0; // no traps set
|
||||
context->clamp=1; // clamp exponents
|
||||
#if DECSUBSET
|
||||
context->extended=1; // set
|
||||
#endif
|
||||
break;
|
||||
|
||||
default: // invalid Kind
|
||||
// use defaults, and ..
|
||||
decContextSetStatus(context, DEC_Invalid_operation); // trap
|
||||
}
|
||||
|
||||
return context;} // decContextDefault
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextGetRounding -- return current rounding mode */
|
||||
/* */
|
||||
/* context is the context structure to be queried */
|
||||
/* returns the rounding mode */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
enum rounding decContextGetRounding(decContext *context) {
|
||||
return context->round;
|
||||
} // decContextGetRounding
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextGetStatus -- return current status */
|
||||
/* */
|
||||
/* context is the context structure to be queried */
|
||||
/* returns status */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uInt decContextGetStatus(decContext *context) {
|
||||
return context->status;
|
||||
} // decContextGetStatus
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextRestoreStatus -- restore bits in current status */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* newstatus is the source for the bits to be restored */
|
||||
/* mask indicates the bits to be restored (the status bit that */
|
||||
/* corresponds to each 1 bit in the mask is set to the value of */
|
||||
/* the correspnding bit in newstatus) */
|
||||
/* returns context */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext *decContextRestoreStatus(decContext *context,
|
||||
uInt newstatus, uInt mask) {
|
||||
context->status&=~mask; // clear the selected bits
|
||||
context->status|=(mask&newstatus); // or in the new bits
|
||||
return context;
|
||||
} // decContextRestoreStatus
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextSaveStatus -- save bits in current status */
|
||||
/* */
|
||||
/* context is the context structure to be queried */
|
||||
/* mask indicates the bits to be saved (the status bits that */
|
||||
/* correspond to each 1 bit in the mask are saved) */
|
||||
/* returns the AND of the mask and the current status */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uInt decContextSaveStatus(decContext *context, uInt mask) {
|
||||
return context->status&mask;
|
||||
} // decContextSaveStatus
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextSetRounding -- set current rounding mode */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* newround is the value which will replace the current mode */
|
||||
/* returns context */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext *decContextSetRounding(decContext *context,
|
||||
enum rounding newround) {
|
||||
context->round=newround;
|
||||
return context;
|
||||
} // decContextSetRounding
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextSetStatus -- set status and raise trap if appropriate */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* status is the DEC_ exception code */
|
||||
/* returns the context structure */
|
||||
/* */
|
||||
/* Control may never return from this routine, if there is a signal */
|
||||
/* handler and it takes a long jump. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext * decContextSetStatus(decContext *context, uInt status) {
|
||||
context->status|=status;
|
||||
if (status & context->traps) raise(SIGFPE);
|
||||
return context;} // decContextSetStatus
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextSetStatusFromString -- set status from a string + trap */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* string is a string exactly equal to one that might be returned */
|
||||
/* by decContextStatusToString */
|
||||
/* */
|
||||
/* The status bit corresponding to the string is set, and a trap */
|
||||
/* is raised if appropriate. */
|
||||
/* */
|
||||
/* returns the context structure, unless the string is equal to */
|
||||
/* DEC_Condition_MU or is not recognized. In these cases NULL is */
|
||||
/* returned. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext * decContextSetStatusFromString(decContext *context,
|
||||
const char *string) {
|
||||
if (strcmp(string, DEC_Condition_CS)==0)
|
||||
return decContextSetStatus(context, DEC_Conversion_syntax);
|
||||
if (strcmp(string, DEC_Condition_DZ)==0)
|
||||
return decContextSetStatus(context, DEC_Division_by_zero);
|
||||
if (strcmp(string, DEC_Condition_DI)==0)
|
||||
return decContextSetStatus(context, DEC_Division_impossible);
|
||||
if (strcmp(string, DEC_Condition_DU)==0)
|
||||
return decContextSetStatus(context, DEC_Division_undefined);
|
||||
if (strcmp(string, DEC_Condition_IE)==0)
|
||||
return decContextSetStatus(context, DEC_Inexact);
|
||||
if (strcmp(string, DEC_Condition_IS)==0)
|
||||
return decContextSetStatus(context, DEC_Insufficient_storage);
|
||||
if (strcmp(string, DEC_Condition_IC)==0)
|
||||
return decContextSetStatus(context, DEC_Invalid_context);
|
||||
if (strcmp(string, DEC_Condition_IO)==0)
|
||||
return decContextSetStatus(context, DEC_Invalid_operation);
|
||||
#if DECSUBSET
|
||||
if (strcmp(string, DEC_Condition_LD)==0)
|
||||
return decContextSetStatus(context, DEC_Lost_digits);
|
||||
#endif
|
||||
if (strcmp(string, DEC_Condition_OV)==0)
|
||||
return decContextSetStatus(context, DEC_Overflow);
|
||||
if (strcmp(string, DEC_Condition_PA)==0)
|
||||
return decContextSetStatus(context, DEC_Clamped);
|
||||
if (strcmp(string, DEC_Condition_RO)==0)
|
||||
return decContextSetStatus(context, DEC_Rounded);
|
||||
if (strcmp(string, DEC_Condition_SU)==0)
|
||||
return decContextSetStatus(context, DEC_Subnormal);
|
||||
if (strcmp(string, DEC_Condition_UN)==0)
|
||||
return decContextSetStatus(context, DEC_Underflow);
|
||||
if (strcmp(string, DEC_Condition_ZE)==0)
|
||||
return context;
|
||||
return NULL; // Multiple status, or unknown
|
||||
} // decContextSetStatusFromString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextSetStatusFromStringQuiet -- set status from a string */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* string is a string exactly equal to one that might be returned */
|
||||
/* by decContextStatusToString */
|
||||
/* */
|
||||
/* The status bit corresponding to the string is set; no trap is */
|
||||
/* raised. */
|
||||
/* */
|
||||
/* returns the context structure, unless the string is equal to */
|
||||
/* DEC_Condition_MU or is not recognized. In these cases NULL is */
|
||||
/* returned. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext * decContextSetStatusFromStringQuiet(decContext *context,
|
||||
const char *string) {
|
||||
if (strcmp(string, DEC_Condition_CS)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
|
||||
if (strcmp(string, DEC_Condition_DZ)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Division_by_zero);
|
||||
if (strcmp(string, DEC_Condition_DI)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Division_impossible);
|
||||
if (strcmp(string, DEC_Condition_DU)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Division_undefined);
|
||||
if (strcmp(string, DEC_Condition_IE)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Inexact);
|
||||
if (strcmp(string, DEC_Condition_IS)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
|
||||
if (strcmp(string, DEC_Condition_IC)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Invalid_context);
|
||||
if (strcmp(string, DEC_Condition_IO)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Invalid_operation);
|
||||
#if DECSUBSET
|
||||
if (strcmp(string, DEC_Condition_LD)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Lost_digits);
|
||||
#endif
|
||||
if (strcmp(string, DEC_Condition_OV)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Overflow);
|
||||
if (strcmp(string, DEC_Condition_PA)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Clamped);
|
||||
if (strcmp(string, DEC_Condition_RO)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Rounded);
|
||||
if (strcmp(string, DEC_Condition_SU)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Subnormal);
|
||||
if (strcmp(string, DEC_Condition_UN)==0)
|
||||
return decContextSetStatusQuiet(context, DEC_Underflow);
|
||||
if (strcmp(string, DEC_Condition_ZE)==0)
|
||||
return context;
|
||||
return NULL; // Multiple status, or unknown
|
||||
} // decContextSetStatusFromStringQuiet
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextSetStatusQuiet -- set status without trap */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* status is the DEC_ exception code */
|
||||
/* returns the context structure */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
|
||||
context->status|=status;
|
||||
return context;} // decContextSetStatusQuiet
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextStatusToString -- convert status flags to a string */
|
||||
/* */
|
||||
/* context is a context with valid status field */
|
||||
/* */
|
||||
/* returns a constant string describing the condition. If multiple */
|
||||
/* (or no) flags are set, a generic constant message is returned. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
const char *decContextStatusToString(const decContext *context) {
|
||||
Int status=context->status;
|
||||
|
||||
// test the five IEEE first, as some of the others are ambiguous when
|
||||
// DECEXTFLAG=0
|
||||
if (status==DEC_Invalid_operation ) return DEC_Condition_IO;
|
||||
if (status==DEC_Division_by_zero ) return DEC_Condition_DZ;
|
||||
if (status==DEC_Overflow ) return DEC_Condition_OV;
|
||||
if (status==DEC_Underflow ) return DEC_Condition_UN;
|
||||
if (status==DEC_Inexact ) return DEC_Condition_IE;
|
||||
|
||||
if (status==DEC_Division_impossible ) return DEC_Condition_DI;
|
||||
if (status==DEC_Division_undefined ) return DEC_Condition_DU;
|
||||
if (status==DEC_Rounded ) return DEC_Condition_RO;
|
||||
if (status==DEC_Clamped ) return DEC_Condition_PA;
|
||||
if (status==DEC_Subnormal ) return DEC_Condition_SU;
|
||||
if (status==DEC_Conversion_syntax ) return DEC_Condition_CS;
|
||||
if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
|
||||
if (status==DEC_Invalid_context ) return DEC_Condition_IC;
|
||||
#if DECSUBSET
|
||||
if (status==DEC_Lost_digits ) return DEC_Condition_LD;
|
||||
#endif
|
||||
if (status==0 ) return DEC_Condition_ZE;
|
||||
return DEC_Condition_MU; // Multiple errors
|
||||
} // decContextStatusToString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextTestEndian -- test whether DECLITEND is set correctly */
|
||||
/* */
|
||||
/* quiet is 1 to suppress message; 0 otherwise */
|
||||
/* returns 0 if DECLITEND is correct */
|
||||
/* 1 if DECLITEND is incorrect and should be 1 */
|
||||
/* -1 if DECLITEND is incorrect and should be 0 */
|
||||
/* */
|
||||
/* A message is displayed if the return value is not 0 and quiet==0. */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
Int decContextTestEndian(Flag quiet) {
|
||||
Int res=0; // optimist
|
||||
uInt dle=(uInt)DECLITEND; // unsign
|
||||
if (dle>1) dle=1; // ensure 0 or 1
|
||||
|
||||
if (LITEND!=DECLITEND) {
|
||||
if (!quiet) { // always refer to this
|
||||
#if DECPRINT
|
||||
const char *adj;
|
||||
if (LITEND) adj="little";
|
||||
else adj="big";
|
||||
printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
|
||||
DECLITEND, adj);
|
||||
#endif
|
||||
}
|
||||
res=(Int)LITEND-dle;
|
||||
}
|
||||
return res;
|
||||
} // decContextTestEndian
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextTestSavedStatus -- test bits in saved status */
|
||||
/* */
|
||||
/* oldstatus is the status word to be tested */
|
||||
/* mask indicates the bits to be tested (the oldstatus bits that */
|
||||
/* correspond to each 1 bit in the mask are tested) */
|
||||
/* returns 1 if any of the tested bits are 1, or 0 otherwise */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
|
||||
return (oldstatus&mask)!=0;
|
||||
} // decContextTestSavedStatus
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextTestStatus -- test bits in current status */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* mask indicates the bits to be tested (the status bits that */
|
||||
/* correspond to each 1 bit in the mask are tested) */
|
||||
/* returns 1 if any of the tested bits are 1, or 0 otherwise */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uInt decContextTestStatus(decContext *context, uInt mask) {
|
||||
return (context->status&mask)!=0;
|
||||
} // decContextTestStatus
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decContextZeroStatus -- clear all status bits */
|
||||
/* */
|
||||
/* context is the context structure to be updated */
|
||||
/* returns context */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decContext *decContextZeroStatus(decContext *context) {
|
||||
context->status=0;
|
||||
return context;
|
||||
} // decContextZeroStatus
|
||||
|
||||
@@ -0,0 +1,254 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Context module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2010. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* */
|
||||
/* Context variables must always have valid values: */
|
||||
/* */
|
||||
/* status -- [any bits may be cleared, but not set, by user] */
|
||||
/* round -- must be one of the enumerated rounding modes */
|
||||
/* */
|
||||
/* The following variables are implied for fixed size formats (i.e., */
|
||||
/* they are ignored) but should still be set correctly in case used */
|
||||
/* with decNumber functions: */
|
||||
/* */
|
||||
/* clamp -- must be either 0 or 1 */
|
||||
/* digits -- must be in the range 1 through 999999999 */
|
||||
/* emax -- must be in the range 0 through 999999999 */
|
||||
/* emin -- must be in the range 0 through -999999999 */
|
||||
/* extended -- must be either 0 or 1 [present only if DECSUBSET] */
|
||||
/* traps -- only defined bits may be set */
|
||||
/* */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECCONTEXT)
|
||||
#define DECCONTEXT
|
||||
#define DECCNAME "decContext" /* Short name */
|
||||
#define DECCFULLNAME "Decimal Context Descriptor" /* Verbose name */
|
||||
#define DECCAUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
#if !defined(int32_t)
|
||||
#include <stdint.h> /* C99 standard integers */
|
||||
#endif
|
||||
#include <stdio.h> /* for printf, etc. */
|
||||
#include <signal.h> /* for traps */
|
||||
|
||||
/* Extended flags setting -- set this to 0 to use only IEEE flags */
|
||||
#if !defined(DECEXTFLAG)
|
||||
#define DECEXTFLAG 1 /* 1=enable extended flags */
|
||||
#endif
|
||||
|
||||
/* Conditional code flag -- set this to 0 for best performance */
|
||||
#if !defined(DECSUBSET)
|
||||
#define DECSUBSET 0 /* 1=enable subset arithmetic */
|
||||
#endif
|
||||
|
||||
/* Context for operations, with associated constants */
|
||||
enum rounding {
|
||||
DEC_ROUND_CEILING, /* round towards +infinity */
|
||||
DEC_ROUND_UP, /* round away from 0 */
|
||||
DEC_ROUND_HALF_UP, /* 0.5 rounds up */
|
||||
DEC_ROUND_HALF_EVEN, /* 0.5 rounds to nearest even */
|
||||
DEC_ROUND_HALF_DOWN, /* 0.5 rounds down */
|
||||
DEC_ROUND_DOWN, /* round towards 0 (truncate) */
|
||||
DEC_ROUND_FLOOR, /* round towards -infinity */
|
||||
DEC_ROUND_05UP, /* round for reround */
|
||||
DEC_ROUND_MAX /* enum must be less than this */
|
||||
};
|
||||
#define DEC_ROUND_DEFAULT DEC_ROUND_HALF_EVEN;
|
||||
|
||||
typedef struct {
|
||||
int32_t digits; /* working precision */
|
||||
int32_t emax; /* maximum positive exponent */
|
||||
int32_t emin; /* minimum negative exponent */
|
||||
enum rounding round; /* rounding mode */
|
||||
uint32_t traps; /* trap-enabler flags */
|
||||
uint32_t status; /* status flags */
|
||||
uint8_t clamp; /* flag: apply IEEE exponent clamp */
|
||||
#if DECSUBSET
|
||||
uint8_t extended; /* flag: special-values allowed */
|
||||
#endif
|
||||
} decContext;
|
||||
|
||||
/* Maxima and Minima for context settings */
|
||||
#define DEC_MAX_DIGITS 999999999
|
||||
#define DEC_MIN_DIGITS 1
|
||||
#define DEC_MAX_EMAX 999999999
|
||||
#define DEC_MIN_EMAX 0
|
||||
#define DEC_MAX_EMIN 0
|
||||
#define DEC_MIN_EMIN -999999999
|
||||
#define DEC_MAX_MATH 999999 /* max emax, etc., for math funcs. */
|
||||
|
||||
/* Classifications for decimal numbers, aligned with 754 (note that */
|
||||
/* 'normal' and 'subnormal' are meaningful only with a decContext */
|
||||
/* or a fixed size format). */
|
||||
enum decClass {
|
||||
DEC_CLASS_SNAN,
|
||||
DEC_CLASS_QNAN,
|
||||
DEC_CLASS_NEG_INF,
|
||||
DEC_CLASS_NEG_NORMAL,
|
||||
DEC_CLASS_NEG_SUBNORMAL,
|
||||
DEC_CLASS_NEG_ZERO,
|
||||
DEC_CLASS_POS_ZERO,
|
||||
DEC_CLASS_POS_SUBNORMAL,
|
||||
DEC_CLASS_POS_NORMAL,
|
||||
DEC_CLASS_POS_INF
|
||||
};
|
||||
/* Strings for the decClasses */
|
||||
#define DEC_ClassString_SN "sNaN"
|
||||
#define DEC_ClassString_QN "NaN"
|
||||
#define DEC_ClassString_NI "-Infinity"
|
||||
#define DEC_ClassString_NN "-Normal"
|
||||
#define DEC_ClassString_NS "-Subnormal"
|
||||
#define DEC_ClassString_NZ "-Zero"
|
||||
#define DEC_ClassString_PZ "+Zero"
|
||||
#define DEC_ClassString_PS "+Subnormal"
|
||||
#define DEC_ClassString_PN "+Normal"
|
||||
#define DEC_ClassString_PI "+Infinity"
|
||||
#define DEC_ClassString_UN "Invalid"
|
||||
|
||||
/* Trap-enabler and Status flags (exceptional conditions), and */
|
||||
/* their names. The top byte is reserved for internal use */
|
||||
#if DECEXTFLAG
|
||||
/* Extended flags */
|
||||
#define DEC_Conversion_syntax 0x00000001
|
||||
#define DEC_Division_by_zero 0x00000002
|
||||
#define DEC_Division_impossible 0x00000004
|
||||
#define DEC_Division_undefined 0x00000008
|
||||
#define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */
|
||||
#define DEC_Inexact 0x00000020
|
||||
#define DEC_Invalid_context 0x00000040
|
||||
#define DEC_Invalid_operation 0x00000080
|
||||
#if DECSUBSET
|
||||
#define DEC_Lost_digits 0x00000100
|
||||
#endif
|
||||
#define DEC_Overflow 0x00000200
|
||||
#define DEC_Clamped 0x00000400
|
||||
#define DEC_Rounded 0x00000800
|
||||
#define DEC_Subnormal 0x00001000
|
||||
#define DEC_Underflow 0x00002000
|
||||
#else
|
||||
/* IEEE flags only */
|
||||
#define DEC_Conversion_syntax 0x00000010
|
||||
#define DEC_Division_by_zero 0x00000002
|
||||
#define DEC_Division_impossible 0x00000010
|
||||
#define DEC_Division_undefined 0x00000010
|
||||
#define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */
|
||||
#define DEC_Inexact 0x00000001
|
||||
#define DEC_Invalid_context 0x00000010
|
||||
#define DEC_Invalid_operation 0x00000010
|
||||
#if DECSUBSET
|
||||
#define DEC_Lost_digits 0x00000000
|
||||
#endif
|
||||
#define DEC_Overflow 0x00000008
|
||||
#define DEC_Clamped 0x00000000
|
||||
#define DEC_Rounded 0x00000000
|
||||
#define DEC_Subnormal 0x00000000
|
||||
#define DEC_Underflow 0x00000004
|
||||
#endif
|
||||
|
||||
/* IEEE 754 groupings for the flags */
|
||||
/* [DEC_Clamped, DEC_Lost_digits, DEC_Rounded, and DEC_Subnormal */
|
||||
/* are not in IEEE 754] */
|
||||
#define DEC_IEEE_754_Division_by_zero (DEC_Division_by_zero)
|
||||
#if DECSUBSET
|
||||
#define DEC_IEEE_754_Inexact (DEC_Inexact | DEC_Lost_digits)
|
||||
#else
|
||||
#define DEC_IEEE_754_Inexact (DEC_Inexact)
|
||||
#endif
|
||||
#define DEC_IEEE_754_Invalid_operation (DEC_Conversion_syntax | \
|
||||
DEC_Division_impossible | \
|
||||
DEC_Division_undefined | \
|
||||
DEC_Insufficient_storage | \
|
||||
DEC_Invalid_context | \
|
||||
DEC_Invalid_operation)
|
||||
#define DEC_IEEE_754_Overflow (DEC_Overflow)
|
||||
#define DEC_IEEE_754_Underflow (DEC_Underflow)
|
||||
|
||||
/* flags which are normally errors (result is qNaN, infinite, or 0) */
|
||||
#define DEC_Errors (DEC_IEEE_754_Division_by_zero | \
|
||||
DEC_IEEE_754_Invalid_operation | \
|
||||
DEC_IEEE_754_Overflow | DEC_IEEE_754_Underflow)
|
||||
/* flags which cause a result to become qNaN */
|
||||
#define DEC_NaNs DEC_IEEE_754_Invalid_operation
|
||||
|
||||
/* flags which are normally for information only (finite results) */
|
||||
#if DECSUBSET
|
||||
#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact \
|
||||
| DEC_Lost_digits)
|
||||
#else
|
||||
#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact)
|
||||
#endif
|
||||
|
||||
/* IEEE 854 names (for compatibility with older decNumber versions) */
|
||||
#define DEC_IEEE_854_Division_by_zero DEC_IEEE_754_Division_by_zero
|
||||
#define DEC_IEEE_854_Inexact DEC_IEEE_754_Inexact
|
||||
#define DEC_IEEE_854_Invalid_operation DEC_IEEE_754_Invalid_operation
|
||||
#define DEC_IEEE_854_Overflow DEC_IEEE_754_Overflow
|
||||
#define DEC_IEEE_854_Underflow DEC_IEEE_754_Underflow
|
||||
|
||||
/* Name strings for the exceptional conditions */
|
||||
#define DEC_Condition_CS "Conversion syntax"
|
||||
#define DEC_Condition_DZ "Division by zero"
|
||||
#define DEC_Condition_DI "Division impossible"
|
||||
#define DEC_Condition_DU "Division undefined"
|
||||
#define DEC_Condition_IE "Inexact"
|
||||
#define DEC_Condition_IS "Insufficient storage"
|
||||
#define DEC_Condition_IC "Invalid context"
|
||||
#define DEC_Condition_IO "Invalid operation"
|
||||
#if DECSUBSET
|
||||
#define DEC_Condition_LD "Lost digits"
|
||||
#endif
|
||||
#define DEC_Condition_OV "Overflow"
|
||||
#define DEC_Condition_PA "Clamped"
|
||||
#define DEC_Condition_RO "Rounded"
|
||||
#define DEC_Condition_SU "Subnormal"
|
||||
#define DEC_Condition_UN "Underflow"
|
||||
#define DEC_Condition_ZE "No status"
|
||||
#define DEC_Condition_MU "Multiple status"
|
||||
#define DEC_Condition_Length 21 /* length of the longest string, */
|
||||
/* including terminator */
|
||||
|
||||
/* Initialization descriptors, used by decContextDefault */
|
||||
#define DEC_INIT_BASE 0
|
||||
#define DEC_INIT_DECIMAL32 32
|
||||
#define DEC_INIT_DECIMAL64 64
|
||||
#define DEC_INIT_DECIMAL128 128
|
||||
/* Synonyms */
|
||||
#define DEC_INIT_DECSINGLE DEC_INIT_DECIMAL32
|
||||
#define DEC_INIT_DECDOUBLE DEC_INIT_DECIMAL64
|
||||
#define DEC_INIT_DECQUAD DEC_INIT_DECIMAL128
|
||||
|
||||
/* decContext routines */
|
||||
extern decContext * decContextClearStatus(decContext *, uint32_t);
|
||||
extern decContext * decContextDefault(decContext *, int32_t);
|
||||
extern enum rounding decContextGetRounding(decContext *);
|
||||
extern uint32_t decContextGetStatus(decContext *);
|
||||
extern decContext * decContextRestoreStatus(decContext *, uint32_t, uint32_t);
|
||||
extern uint32_t decContextSaveStatus(decContext *, uint32_t);
|
||||
extern decContext * decContextSetRounding(decContext *, enum rounding);
|
||||
extern decContext * decContextSetStatus(decContext *, uint32_t);
|
||||
extern decContext * decContextSetStatusFromString(decContext *, const char *);
|
||||
extern decContext * decContextSetStatusFromStringQuiet(decContext *, const char *);
|
||||
extern decContext * decContextSetStatusQuiet(decContext *, uint32_t);
|
||||
extern const char * decContextStatusToString(const decContext *);
|
||||
extern int32_t decContextTestEndian(uint8_t);
|
||||
extern uint32_t decContextTestSavedStatus(uint32_t, uint32_t);
|
||||
extern uint32_t decContextTestStatus(decContext *, uint32_t);
|
||||
extern decContext * decContextZeroStatus(decContext *);
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,140 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decDouble.c -- decDouble operations module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2010. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is included in the package as decNumber.pdf. This */
|
||||
/* document is also available in HTML, together with specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises decDouble operations (including conversions) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#include "decContext.h" // public includes
|
||||
#include "decDouble.h" // ..
|
||||
|
||||
/* Constant mappings for shared code */
|
||||
#define DECPMAX DECDOUBLE_Pmax
|
||||
#define DECEMIN DECDOUBLE_Emin
|
||||
#define DECEMAX DECDOUBLE_Emax
|
||||
#define DECEMAXD DECDOUBLE_EmaxD
|
||||
#define DECBYTES DECDOUBLE_Bytes
|
||||
#define DECSTRING DECDOUBLE_String
|
||||
#define DECECONL DECDOUBLE_EconL
|
||||
#define DECBIAS DECDOUBLE_Bias
|
||||
#define DECLETS DECDOUBLE_Declets
|
||||
#define DECQTINY (-DECDOUBLE_Bias)
|
||||
// parameters of next-wider format
|
||||
#define DECWBYTES DECQUAD_Bytes
|
||||
#define DECWPMAX DECQUAD_Pmax
|
||||
#define DECWECONL DECQUAD_EconL
|
||||
#define DECWBIAS DECQUAD_Bias
|
||||
|
||||
/* Type and function mappings for shared code */
|
||||
#define decFloat decDouble // Type name
|
||||
#define decFloatWider decQuad // Type name
|
||||
|
||||
// Utilities and conversions (binary results, extractors, etc.)
|
||||
#define decFloatFromBCD decDoubleFromBCD
|
||||
#define decFloatFromInt32 decDoubleFromInt32
|
||||
#define decFloatFromPacked decDoubleFromPacked
|
||||
#define decFloatFromPackedChecked decDoubleFromPackedChecked
|
||||
#define decFloatFromString decDoubleFromString
|
||||
#define decFloatFromUInt32 decDoubleFromUInt32
|
||||
#define decFloatFromWider decDoubleFromWider
|
||||
#define decFloatGetCoefficient decDoubleGetCoefficient
|
||||
#define decFloatGetExponent decDoubleGetExponent
|
||||
#define decFloatSetCoefficient decDoubleSetCoefficient
|
||||
#define decFloatSetExponent decDoubleSetExponent
|
||||
#define decFloatShow decDoubleShow
|
||||
#define decFloatToBCD decDoubleToBCD
|
||||
#define decFloatToEngString decDoubleToEngString
|
||||
#define decFloatToInt32 decDoubleToInt32
|
||||
#define decFloatToInt32Exact decDoubleToInt32Exact
|
||||
#define decFloatToPacked decDoubleToPacked
|
||||
#define decFloatToString decDoubleToString
|
||||
#define decFloatToUInt32 decDoubleToUInt32
|
||||
#define decFloatToUInt32Exact decDoubleToUInt32Exact
|
||||
#define decFloatToWider decDoubleToWider
|
||||
#define decFloatZero decDoubleZero
|
||||
|
||||
// Computational (result is a decFloat)
|
||||
#define decFloatAbs decDoubleAbs
|
||||
#define decFloatAdd decDoubleAdd
|
||||
#define decFloatAnd decDoubleAnd
|
||||
#define decFloatDivide decDoubleDivide
|
||||
#define decFloatDivideInteger decDoubleDivideInteger
|
||||
#define decFloatFMA decDoubleFMA
|
||||
#define decFloatInvert decDoubleInvert
|
||||
#define decFloatLogB decDoubleLogB
|
||||
#define decFloatMax decDoubleMax
|
||||
#define decFloatMaxMag decDoubleMaxMag
|
||||
#define decFloatMin decDoubleMin
|
||||
#define decFloatMinMag decDoubleMinMag
|
||||
#define decFloatMinus decDoubleMinus
|
||||
#define decFloatMultiply decDoubleMultiply
|
||||
#define decFloatNextMinus decDoubleNextMinus
|
||||
#define decFloatNextPlus decDoubleNextPlus
|
||||
#define decFloatNextToward decDoubleNextToward
|
||||
#define decFloatOr decDoubleOr
|
||||
#define decFloatPlus decDoublePlus
|
||||
#define decFloatQuantize decDoubleQuantize
|
||||
#define decFloatReduce decDoubleReduce
|
||||
#define decFloatRemainder decDoubleRemainder
|
||||
#define decFloatRemainderNear decDoubleRemainderNear
|
||||
#define decFloatRotate decDoubleRotate
|
||||
#define decFloatScaleB decDoubleScaleB
|
||||
#define decFloatShift decDoubleShift
|
||||
#define decFloatSubtract decDoubleSubtract
|
||||
#define decFloatToIntegralValue decDoubleToIntegralValue
|
||||
#define decFloatToIntegralExact decDoubleToIntegralExact
|
||||
#define decFloatXor decDoubleXor
|
||||
|
||||
// Comparisons
|
||||
#define decFloatCompare decDoubleCompare
|
||||
#define decFloatCompareSignal decDoubleCompareSignal
|
||||
#define decFloatCompareTotal decDoubleCompareTotal
|
||||
#define decFloatCompareTotalMag decDoubleCompareTotalMag
|
||||
|
||||
// Copies
|
||||
#define decFloatCanonical decDoubleCanonical
|
||||
#define decFloatCopy decDoubleCopy
|
||||
#define decFloatCopyAbs decDoubleCopyAbs
|
||||
#define decFloatCopyNegate decDoubleCopyNegate
|
||||
#define decFloatCopySign decDoubleCopySign
|
||||
|
||||
// Non-computational
|
||||
#define decFloatClass decDoubleClass
|
||||
#define decFloatClassString decDoubleClassString
|
||||
#define decFloatDigits decDoubleDigits
|
||||
#define decFloatIsCanonical decDoubleIsCanonical
|
||||
#define decFloatIsFinite decDoubleIsFinite
|
||||
#define decFloatIsInfinite decDoubleIsInfinite
|
||||
#define decFloatIsInteger decDoubleIsInteger
|
||||
#define decFloatIsLogical decDoubleIsLogical
|
||||
#define decFloatIsNaN decDoubleIsNaN
|
||||
#define decFloatIsNegative decDoubleIsNegative
|
||||
#define decFloatIsNormal decDoubleIsNormal
|
||||
#define decFloatIsPositive decDoubleIsPositive
|
||||
#define decFloatIsSignaling decDoubleIsSignaling
|
||||
#define decFloatIsSignalling decDoubleIsSignalling
|
||||
#define decFloatIsSigned decDoubleIsSigned
|
||||
#define decFloatIsSubnormal decDoubleIsSubnormal
|
||||
#define decFloatIsZero decDoubleIsZero
|
||||
#define decFloatRadix decDoubleRadix
|
||||
#define decFloatSameQuantum decDoubleSameQuantum
|
||||
#define decFloatVersion decDoubleVersion
|
||||
|
||||
#include "decNumberLocal.h" // local includes (need DECPMAX)
|
||||
#include "decCommon.c" // non-arithmetic decFloat routines
|
||||
#include "decBasic.c" // basic formats routines
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decDouble.h -- Decimal 64-bit format module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2010. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is included in the package as decNumber.pdf. This */
|
||||
/* document is also available in HTML, together with specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECDOUBLE)
|
||||
#define DECDOUBLE
|
||||
|
||||
#define DECDOUBLENAME "decimalDouble" /* Short name */
|
||||
#define DECDOUBLETITLE "Decimal 64-bit datum" /* Verbose name */
|
||||
#define DECDOUBLEAUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
/* parameters for decDoubles */
|
||||
#define DECDOUBLE_Bytes 8 /* length */
|
||||
#define DECDOUBLE_Pmax 16 /* maximum precision (digits) */
|
||||
#define DECDOUBLE_Emin -383 /* minimum adjusted exponent */
|
||||
#define DECDOUBLE_Emax 384 /* maximum adjusted exponent */
|
||||
#define DECDOUBLE_EmaxD 3 /* maximum exponent digits */
|
||||
#define DECDOUBLE_Bias 398 /* bias for the exponent */
|
||||
#define DECDOUBLE_String 25 /* maximum string length, +1 */
|
||||
#define DECDOUBLE_EconL 8 /* exponent continuation length */
|
||||
#define DECDOUBLE_Declets 5 /* count of declets */
|
||||
/* highest biased exponent (Elimit-1) */
|
||||
#define DECDOUBLE_Ehigh (DECDOUBLE_Emax + DECDOUBLE_Bias - (DECDOUBLE_Pmax-1))
|
||||
|
||||
/* Required includes */
|
||||
#include "decContext.h"
|
||||
#include "decQuad.h"
|
||||
|
||||
/* The decDouble decimal 64-bit type, accessible by all sizes */
|
||||
typedef union {
|
||||
uint8_t bytes[DECDOUBLE_Bytes]; /* fields: 1, 5, 8, 50 bits */
|
||||
uint16_t shorts[DECDOUBLE_Bytes/2];
|
||||
uint32_t words[DECDOUBLE_Bytes/4];
|
||||
#if DECUSE64
|
||||
uint64_t longs[DECDOUBLE_Bytes/8];
|
||||
#endif
|
||||
} decDouble;
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Routines -- implemented as decFloat routines in common files */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
/* Utilities and conversions, extractors, etc.) */
|
||||
extern decDouble * decDoubleFromBCD(decDouble *, int32_t, const uint8_t *, int32_t);
|
||||
extern decDouble * decDoubleFromInt32(decDouble *, int32_t);
|
||||
extern decDouble * decDoubleFromPacked(decDouble *, int32_t, const uint8_t *);
|
||||
extern decDouble * decDoubleFromPackedChecked(decDouble *, int32_t, const uint8_t *);
|
||||
extern decDouble * decDoubleFromString(decDouble *, const char *, decContext *);
|
||||
extern decDouble * decDoubleFromUInt32(decDouble *, uint32_t);
|
||||
extern decDouble * decDoubleFromWider(decDouble *, const decQuad *, decContext *);
|
||||
extern int32_t decDoubleGetCoefficient(const decDouble *, uint8_t *);
|
||||
extern int32_t decDoubleGetExponent(const decDouble *);
|
||||
extern decDouble * decDoubleSetCoefficient(decDouble *, const uint8_t *, int32_t);
|
||||
extern decDouble * decDoubleSetExponent(decDouble *, decContext *, int32_t);
|
||||
extern void decDoubleShow(const decDouble *, const char *);
|
||||
extern int32_t decDoubleToBCD(const decDouble *, int32_t *, uint8_t *);
|
||||
extern char * decDoubleToEngString(const decDouble *, char *);
|
||||
extern int32_t decDoubleToInt32(const decDouble *, decContext *, enum rounding);
|
||||
extern int32_t decDoubleToInt32Exact(const decDouble *, decContext *, enum rounding);
|
||||
extern int32_t decDoubleToPacked(const decDouble *, int32_t *, uint8_t *);
|
||||
extern char * decDoubleToString(const decDouble *, char *);
|
||||
extern uint32_t decDoubleToUInt32(const decDouble *, decContext *, enum rounding);
|
||||
extern uint32_t decDoubleToUInt32Exact(const decDouble *, decContext *, enum rounding);
|
||||
extern decQuad * decDoubleToWider(const decDouble *, decQuad *);
|
||||
extern decDouble * decDoubleZero(decDouble *);
|
||||
|
||||
/* Computational (result is a decDouble) */
|
||||
extern decDouble * decDoubleAbs(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleAdd(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleAnd(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleDivide(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleDivideInteger(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleFMA(decDouble *, const decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleInvert(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleLogB(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleMax(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleMaxMag(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleMin(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleMinMag(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleMinus(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleMultiply(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleNextMinus(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleNextPlus(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleNextToward(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleOr(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoublePlus(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleQuantize(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleReduce(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleRemainder(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleRemainderNear(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleRotate(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleScaleB(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleShift(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleSubtract(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleToIntegralValue(decDouble *, const decDouble *, decContext *, enum rounding);
|
||||
extern decDouble * decDoubleToIntegralExact(decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleXor(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
|
||||
/* Comparisons */
|
||||
extern decDouble * decDoubleCompare(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleCompareSignal(decDouble *, const decDouble *, const decDouble *, decContext *);
|
||||
extern decDouble * decDoubleCompareTotal(decDouble *, const decDouble *, const decDouble *);
|
||||
extern decDouble * decDoubleCompareTotalMag(decDouble *, const decDouble *, const decDouble *);
|
||||
|
||||
/* Copies */
|
||||
extern decDouble * decDoubleCanonical(decDouble *, const decDouble *);
|
||||
extern decDouble * decDoubleCopy(decDouble *, const decDouble *);
|
||||
extern decDouble * decDoubleCopyAbs(decDouble *, const decDouble *);
|
||||
extern decDouble * decDoubleCopyNegate(decDouble *, const decDouble *);
|
||||
extern decDouble * decDoubleCopySign(decDouble *, const decDouble *, const decDouble *);
|
||||
|
||||
/* Non-computational */
|
||||
extern enum decClass decDoubleClass(const decDouble *);
|
||||
extern const char * decDoubleClassString(const decDouble *);
|
||||
extern uint32_t decDoubleDigits(const decDouble *);
|
||||
extern uint32_t decDoubleIsCanonical(const decDouble *);
|
||||
extern uint32_t decDoubleIsFinite(const decDouble *);
|
||||
extern uint32_t decDoubleIsInfinite(const decDouble *);
|
||||
extern uint32_t decDoubleIsInteger(const decDouble *);
|
||||
extern uint32_t decDoubleIsLogical(const decDouble *);
|
||||
extern uint32_t decDoubleIsNaN(const decDouble *);
|
||||
extern uint32_t decDoubleIsNegative(const decDouble *);
|
||||
extern uint32_t decDoubleIsNormal(const decDouble *);
|
||||
extern uint32_t decDoubleIsPositive(const decDouble *);
|
||||
extern uint32_t decDoubleIsSignaling(const decDouble *);
|
||||
extern uint32_t decDoubleIsSignalling(const decDouble *);
|
||||
extern uint32_t decDoubleIsSigned(const decDouble *);
|
||||
extern uint32_t decDoubleIsSubnormal(const decDouble *);
|
||||
extern uint32_t decDoubleIsZero(const decDouble *);
|
||||
extern uint32_t decDoubleRadix(const decDouble *);
|
||||
extern uint32_t decDoubleSameQuantum(const decDouble *, const decDouble *);
|
||||
extern const char * decDoubleVersion(void);
|
||||
|
||||
/* decNumber conversions; these are implemented as macros so as not */
|
||||
/* to force a dependency on decimal64 and decNumber in decDouble. */
|
||||
/* decDoubleFromNumber returns a decimal64 * to avoid warnings. */
|
||||
#define decDoubleToNumber(dq, dn) decimal64ToNumber((decimal64 *)(dq), dn)
|
||||
#define decDoubleFromNumber(dq, dn, set) decimal64FromNumber((decimal64 *)(dq), dn, set)
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,182 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number arithmetic module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2010. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECNUMBER)
|
||||
#define DECNUMBER
|
||||
#define DECNAME "decNumber" /* Short name */
|
||||
#define DECFULLNAME "Decimal Number Module" /* Verbose name */
|
||||
#define DECAUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
#if !defined(DECCONTEXT)
|
||||
#include "decContext.h"
|
||||
#endif
|
||||
|
||||
/* Bit settings for decNumber.bits */
|
||||
#define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */
|
||||
#define DECINF 0x40 /* 1=Infinity */
|
||||
#define DECNAN 0x20 /* 1=NaN */
|
||||
#define DECSNAN 0x10 /* 1=sNaN */
|
||||
/* The remaining bits are reserved; they must be 0 */
|
||||
#define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */
|
||||
|
||||
/* Define the decNumber data structure. The size and shape of the */
|
||||
/* units array in the structure is determined by the following */
|
||||
/* constant. This must not be changed without recompiling the */
|
||||
/* decNumber library modules. */
|
||||
|
||||
#define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */
|
||||
/* and <10; 3 or powers of 2 are best]. */
|
||||
|
||||
/* DECNUMDIGITS is the default number of digits that can be held in */
|
||||
/* the structure. If undefined, 1 is assumed and it is assumed */
|
||||
/* that the structure will be immediately followed by extra space, */
|
||||
/* as required. DECNUMDIGITS is always >0. */
|
||||
#if !defined(DECNUMDIGITS)
|
||||
#define DECNUMDIGITS 1
|
||||
#endif
|
||||
|
||||
/* The size (integer data type) of each unit is determined by the */
|
||||
/* number of digits it will hold. */
|
||||
#if DECDPUN<=2
|
||||
#define decNumberUnit uint8_t
|
||||
#elif DECDPUN<=4
|
||||
#define decNumberUnit uint16_t
|
||||
#else
|
||||
#define decNumberUnit uint32_t
|
||||
#endif
|
||||
/* The number of units needed is ceil(DECNUMDIGITS/DECDPUN) */
|
||||
#define DECNUMUNITS ((DECNUMDIGITS+DECDPUN-1)/DECDPUN)
|
||||
|
||||
/* The data structure... */
|
||||
typedef struct {
|
||||
int32_t digits; /* Count of digits in the coefficient; >0 */
|
||||
int32_t exponent; /* Unadjusted exponent, unbiased, in */
|
||||
/* range: -1999999997 through 999999999 */
|
||||
uint8_t bits; /* Indicator bits (see above) */
|
||||
/* Coefficient, from least significant unit */
|
||||
decNumberUnit lsu[DECNUMUNITS];
|
||||
} decNumber;
|
||||
|
||||
/* Notes: */
|
||||
/* 1. If digits is > DECDPUN then there will one or more */
|
||||
/* decNumberUnits immediately following the first element of lsu.*/
|
||||
/* These contain the remaining (more significant) digits of the */
|
||||
/* number, and may be in the lsu array, or may be guaranteed by */
|
||||
/* some other mechanism (such as being contained in another */
|
||||
/* structure, or being overlaid on dynamically allocated */
|
||||
/* storage). */
|
||||
/* */
|
||||
/* Each integer of the coefficient (except potentially the last) */
|
||||
/* contains DECDPUN digits (e.g., a value in the range 0 through */
|
||||
/* 99999999 if DECDPUN is 8, or 0 through 999 if DECDPUN is 3). */
|
||||
/* */
|
||||
/* 2. A decNumber converted to a string may need up to digits+14 */
|
||||
/* characters. The worst cases (non-exponential and exponential */
|
||||
/* formats) are -0.00000{9...}# and -9.{9...}E+999999999# */
|
||||
/* (where # is '\0') */
|
||||
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* decNumber public functions and macros */
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Conversions */
|
||||
decNumber * decNumberFromInt32(decNumber *, int32_t);
|
||||
decNumber * decNumberFromUInt32(decNumber *, uint32_t);
|
||||
decNumber * decNumberFromString(decNumber *, const char *, decContext *);
|
||||
char * decNumberToString(const decNumber *, char *);
|
||||
char * decNumberToEngString(const decNumber *, char *);
|
||||
uint32_t decNumberToUInt32(const decNumber *, decContext *);
|
||||
int32_t decNumberToInt32(const decNumber *, decContext *);
|
||||
uint8_t * decNumberGetBCD(const decNumber *, uint8_t *);
|
||||
decNumber * decNumberSetBCD(decNumber *, const uint8_t *, uint32_t);
|
||||
|
||||
/* Operators and elementary functions */
|
||||
decNumber * decNumberAbs(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberAdd(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberAnd(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberCompare(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberCompareSignal(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberCompareTotal(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberCompareTotalMag(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberDivide(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberDivideInteger(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberExp(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberFMA(decNumber *, const decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberInvert(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberLn(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberLogB(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberLog10(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberMax(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberMaxMag(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberMin(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberMinMag(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberMinus(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberMultiply(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberNormalize(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberOr(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberPlus(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberPower(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberQuantize(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberReduce(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberRemainder(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberRemainderNear(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberRescale(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberRotate(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberSameQuantum(decNumber *, const decNumber *, const decNumber *);
|
||||
decNumber * decNumberScaleB(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberShift(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberSquareRoot(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberSubtract(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberToIntegralExact(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberToIntegralValue(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberXor(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
|
||||
/* Utilities */
|
||||
enum decClass decNumberClass(const decNumber *, decContext *);
|
||||
const char * decNumberClassToString(enum decClass);
|
||||
decNumber * decNumberCopy(decNumber *, const decNumber *);
|
||||
decNumber * decNumberCopyAbs(decNumber *, const decNumber *);
|
||||
decNumber * decNumberCopyNegate(decNumber *, const decNumber *);
|
||||
decNumber * decNumberCopySign(decNumber *, const decNumber *, const decNumber *);
|
||||
decNumber * decNumberNextMinus(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberNextPlus(decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberNextToward(decNumber *, const decNumber *, const decNumber *, decContext *);
|
||||
decNumber * decNumberTrim(decNumber *);
|
||||
const char * decNumberVersion(void);
|
||||
decNumber * decNumberZero(decNumber *);
|
||||
|
||||
/* Functions for testing decNumbers (normality depends on context) */
|
||||
int32_t decNumberIsNormal(const decNumber *, decContext *);
|
||||
int32_t decNumberIsSubnormal(const decNumber *, decContext *);
|
||||
|
||||
/* Macros for testing decNumber *dn */
|
||||
#define decNumberIsCanonical(dn) (1) /* All decNumbers are saintly */
|
||||
#define decNumberIsFinite(dn) (((dn)->bits&DECSPECIAL)==0)
|
||||
#define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0)
|
||||
#define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0)
|
||||
#define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0)
|
||||
#define decNumberIsQNaN(dn) (((dn)->bits&(DECNAN))!=0)
|
||||
#define decNumberIsSNaN(dn) (((dn)->bits&(DECSNAN))!=0)
|
||||
#define decNumberIsSpecial(dn) (((dn)->bits&DECSPECIAL)!=0)
|
||||
#define decNumberIsZero(dn) (*(dn)->lsu==0 \
|
||||
&& (dn)->digits==1 \
|
||||
&& (((dn)->bits&DECSPECIAL)==0))
|
||||
#define decNumberRadix(dn) (10)
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,757 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decNumber package local type, tuning, and macro definitions */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2010. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This header file is included by all modules in the decNumber */
|
||||
/* library, and contains local type definitions, tuning parameters, */
|
||||
/* etc. It should not need to be used by application programs. */
|
||||
/* decNumber.h or one of decDouble (etc.) must be included first. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECNUMBERLOC)
|
||||
#define DECNUMBERLOC
|
||||
#define DECVERSION "decNumber 3.68" /* Package Version [16 max.] */
|
||||
#define DECNLAUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
#include <stdlib.h> /* for abs */
|
||||
#include <string.h> /* for memset, strcpy */
|
||||
|
||||
/* Conditional code flag -- set this to match hardware platform */
|
||||
#if !defined(DECLITEND)
|
||||
#define DECLITEND 1 /* 1=little-endian, 0=big-endian */
|
||||
#endif
|
||||
|
||||
/* Conditional code flag -- set this to 1 for best performance */
|
||||
#if !defined(DECUSE64)
|
||||
#define DECUSE64 1 /* 1=use int64s, 0=int32 & smaller only */
|
||||
#endif
|
||||
|
||||
/* Conditional code flag -- set this to 0 to exclude printf calls */
|
||||
#if !defined(DECPRINT)
|
||||
#define DECPRINT 1 /* 1=allow printf calls; 0=no printf */
|
||||
#endif
|
||||
|
||||
/* Conditional check flags -- set these to 0 for best performance */
|
||||
#if !defined(DECCHECK)
|
||||
#define DECCHECK 0 /* 1 to enable robust checking */
|
||||
#endif
|
||||
#if !defined(DECALLOC)
|
||||
#define DECALLOC 0 /* 1 to enable memory accounting */
|
||||
#endif
|
||||
#if !defined(DECTRACE)
|
||||
#define DECTRACE 0 /* 1 to trace certain internals, etc. */
|
||||
#endif
|
||||
|
||||
/* Tuning parameter for decNumber (arbitrary precision) module */
|
||||
#if !defined(DECBUFFER)
|
||||
#define DECBUFFER 36 /* Size basis for local buffers. This */
|
||||
/* should be a common maximum precision */
|
||||
/* rounded up to a multiple of 4; must */
|
||||
/* be zero or positive. */
|
||||
#endif
|
||||
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Check parameter dependencies */
|
||||
/* ---------------------------------------------------------------- */
|
||||
#if DECCHECK & !DECPRINT
|
||||
#error DECCHECK needs DECPRINT to be useful
|
||||
#endif
|
||||
#if DECALLOC & !DECPRINT
|
||||
#error DECALLOC needs DECPRINT to be useful
|
||||
#endif
|
||||
#if DECTRACE & !DECPRINT
|
||||
#error DECTRACE needs DECPRINT to be useful
|
||||
#endif
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Definitions for all modules (general-purpose) */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
/* Local names for common types -- for safety, decNumber modules do */
|
||||
/* not use int or long directly. */
|
||||
#define Flag uint8_t
|
||||
#define Byte int8_t
|
||||
#define uByte uint8_t
|
||||
#define Short int16_t
|
||||
#define uShort uint16_t
|
||||
#define Int int32_t
|
||||
#define uInt uint32_t
|
||||
#define Unit decNumberUnit
|
||||
#if DECUSE64
|
||||
#define Long int64_t
|
||||
#define uLong uint64_t
|
||||
#endif
|
||||
|
||||
/* Development-use definitions */
|
||||
typedef long int LI; /* for printf arguments only */
|
||||
#define DECNOINT 0 /* 1 to check no internal use of 'int' */
|
||||
/* or stdint types */
|
||||
#if DECNOINT
|
||||
/* if these interfere with your C includes, do not set DECNOINT */
|
||||
#define int ? /* enable to ensure that plain C 'int' */
|
||||
#define long ?? /* .. or 'long' types are not used */
|
||||
#endif
|
||||
|
||||
/* Shared lookup tables */
|
||||
extern const uByte DECSTICKYTAB[10]; /* re-round digits if sticky */
|
||||
extern const uInt DECPOWERS[10]; /* powers of ten table */
|
||||
/* The following are included from decDPD.h */
|
||||
extern const uShort DPD2BIN[1024]; /* DPD -> 0-999 */
|
||||
extern const uShort BIN2DPD[1000]; /* 0-999 -> DPD */
|
||||
extern const uInt DPD2BINK[1024]; /* DPD -> 0-999000 */
|
||||
extern const uInt DPD2BINM[1024]; /* DPD -> 0-999000000 */
|
||||
extern const uByte DPD2BCD8[4096]; /* DPD -> ddd + len */
|
||||
extern const uByte BIN2BCD8[4000]; /* 0-999 -> ddd + len */
|
||||
extern const uShort BCD2DPD[2458]; /* 0-0x999 -> DPD (0x999=2457)*/
|
||||
|
||||
/* LONGMUL32HI -- set w=(u*v)>>32, where w, u, and v are uInts */
|
||||
/* (that is, sets w to be the high-order word of the 64-bit result; */
|
||||
/* the low-order word is simply u*v.) */
|
||||
/* This version is derived from Knuth via Hacker's Delight; */
|
||||
/* it seems to optimize better than some others tried */
|
||||
#define LONGMUL32HI(w, u, v) { \
|
||||
uInt u0, u1, v0, v1, w0, w1, w2, t; \
|
||||
u0=u & 0xffff; u1=u>>16; \
|
||||
v0=v & 0xffff; v1=v>>16; \
|
||||
w0=u0*v0; \
|
||||
t=u1*v0 + (w0>>16); \
|
||||
w1=t & 0xffff; w2=t>>16; \
|
||||
w1=u0*v1 + w1; \
|
||||
(w)=u1*v1 + w2 + (w1>>16);}
|
||||
|
||||
/* ROUNDUP -- round an integer up to a multiple of n */
|
||||
#define ROUNDUP(i, n) ((((i)+(n)-1)/n)*n)
|
||||
#define ROUNDUP4(i) (((i)+3)&~3) /* special for n=4 */
|
||||
|
||||
/* ROUNDDOWN -- round an integer down to a multiple of n */
|
||||
#define ROUNDDOWN(i, n) (((i)/n)*n)
|
||||
#define ROUNDDOWN4(i) ((i)&~3) /* special for n=4 */
|
||||
|
||||
/* References to multi-byte sequences under different sizes; these */
|
||||
/* require locally declared variables, but do not violate strict */
|
||||
/* aliasing or alignment (as did the UINTAT simple cast to uInt). */
|
||||
/* Variables needed are uswork, uiwork, etc. [so do not use at same */
|
||||
/* level in an expression, e.g., UBTOUI(x)==UBTOUI(y) may fail]. */
|
||||
|
||||
/* Return a uInt, etc., from bytes starting at a char* or uByte* */
|
||||
#define UBTOUS(b) (memcpy((void *)&uswork, b, 2), uswork)
|
||||
#define UBTOUI(b) (memcpy((void *)&uiwork, b, 4), uiwork)
|
||||
|
||||
/* Store a uInt, etc., into bytes starting at a char* or uByte*. */
|
||||
/* Returns i, evaluated, for convenience; has to use uiwork because */
|
||||
/* i may be an expression. */
|
||||
#define UBFROMUS(b, i) (uswork=(i), memcpy(b, (void *)&uswork, 2), uswork)
|
||||
#define UBFROMUI(b, i) (uiwork=(i), memcpy(b, (void *)&uiwork, 4), uiwork)
|
||||
|
||||
/* X10 and X100 -- multiply integer i by 10 or 100 */
|
||||
/* [shifts are usually faster than multiply; could be conditional] */
|
||||
#define X10(i) (((i)<<1)+((i)<<3))
|
||||
#define X100(i) (((i)<<2)+((i)<<5)+((i)<<6))
|
||||
|
||||
/* MAXI and MINI -- general max & min (not in ANSI) for integers */
|
||||
#define MAXI(x,y) ((x)<(y)?(y):(x))
|
||||
#define MINI(x,y) ((x)>(y)?(y):(x))
|
||||
|
||||
/* Useful constants */
|
||||
#define BILLION 1000000000 /* 10**9 */
|
||||
/* CHARMASK: 0x30303030 for ASCII/UTF8; 0xF0F0F0F0 for EBCDIC */
|
||||
#define CHARMASK ((((((((uInt)'0')<<8)+'0')<<8)+'0')<<8)+'0')
|
||||
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Definitions for arbitary-precision modules (only valid after */
|
||||
/* decNumber.h has been included) */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
/* Limits and constants */
|
||||
#define DECNUMMAXP 999999999 /* maximum precision code can handle */
|
||||
#define DECNUMMAXE 999999999 /* maximum adjusted exponent ditto */
|
||||
#define DECNUMMINE -999999999 /* minimum adjusted exponent ditto */
|
||||
#if (DECNUMMAXP != DEC_MAX_DIGITS)
|
||||
#error Maximum digits mismatch
|
||||
#endif
|
||||
#if (DECNUMMAXE != DEC_MAX_EMAX)
|
||||
#error Maximum exponent mismatch
|
||||
#endif
|
||||
#if (DECNUMMINE != DEC_MIN_EMIN)
|
||||
#error Minimum exponent mismatch
|
||||
#endif
|
||||
|
||||
/* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN */
|
||||
/* digits, and D2UTABLE -- the initializer for the D2U table */
|
||||
#if DECDPUN==1
|
||||
#define DECDPUNMAX 9
|
||||
#define D2UTABLE {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17, \
|
||||
18,19,20,21,22,23,24,25,26,27,28,29,30,31,32, \
|
||||
33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, \
|
||||
48,49}
|
||||
#elif DECDPUN==2
|
||||
#define DECDPUNMAX 99
|
||||
#define D2UTABLE {0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10, \
|
||||
11,11,12,12,13,13,14,14,15,15,16,16,17,17,18, \
|
||||
18,19,19,20,20,21,21,22,22,23,23,24,24,25}
|
||||
#elif DECDPUN==3
|
||||
#define DECDPUNMAX 999
|
||||
#define D2UTABLE {0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7, \
|
||||
8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13,13, \
|
||||
13,14,14,14,15,15,15,16,16,16,17}
|
||||
#elif DECDPUN==4
|
||||
#define DECDPUNMAX 9999
|
||||
#define D2UTABLE {0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6, \
|
||||
6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11, \
|
||||
11,11,11,12,12,12,12,13}
|
||||
#elif DECDPUN==5
|
||||
#define DECDPUNMAX 99999
|
||||
#define D2UTABLE {0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,5, \
|
||||
5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9, \
|
||||
9,9,10,10,10,10}
|
||||
#elif DECDPUN==6
|
||||
#define DECDPUNMAX 999999
|
||||
#define D2UTABLE {0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4, \
|
||||
4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8, \
|
||||
8,8,8,8,8,9}
|
||||
#elif DECDPUN==7
|
||||
#define DECDPUNMAX 9999999
|
||||
#define D2UTABLE {0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3, \
|
||||
4,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,7, \
|
||||
7,7,7,7,7,7}
|
||||
#elif DECDPUN==8
|
||||
#define DECDPUNMAX 99999999
|
||||
#define D2UTABLE {0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3, \
|
||||
3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6, \
|
||||
6,6,6,6,6,7}
|
||||
#elif DECDPUN==9
|
||||
#define DECDPUNMAX 999999999
|
||||
#define D2UTABLE {0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3, \
|
||||
3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5, \
|
||||
5,5,6,6,6,6}
|
||||
#elif defined(DECDPUN)
|
||||
#error DECDPUN must be in the range 1-9
|
||||
#endif
|
||||
|
||||
/* ----- Shared data (in decNumber.c) ----- */
|
||||
/* Public lookup table used by the D2U macro (see below) */
|
||||
#define DECMAXD2U 49
|
||||
extern const uByte d2utable[DECMAXD2U+1];
|
||||
|
||||
/* ----- Macros ----- */
|
||||
/* ISZERO -- return true if decNumber dn is a zero */
|
||||
/* [performance-critical in some situations] */
|
||||
#define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */
|
||||
|
||||
/* D2U -- return the number of Units needed to hold d digits */
|
||||
/* (runtime version, with table lookaside for small d) */
|
||||
#if DECDPUN==8
|
||||
#define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+7)>>3))
|
||||
#elif DECDPUN==4
|
||||
#define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+3)>>2))
|
||||
#else
|
||||
#define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN)
|
||||
#endif
|
||||
/* SD2U -- static D2U macro (for compile-time calculation) */
|
||||
#define SD2U(d) (((d)+DECDPUN-1)/DECDPUN)
|
||||
|
||||
/* MSUDIGITS -- returns digits in msu, from digits, calculated */
|
||||
/* using D2U */
|
||||
#define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN)
|
||||
|
||||
/* D2N -- return the number of decNumber structs that would be */
|
||||
/* needed to contain that number of digits (and the initial */
|
||||
/* decNumber struct) safely. Note that one Unit is included in the */
|
||||
/* initial structure. Used for allocating space that is aligned on */
|
||||
/* a decNumber struct boundary. */
|
||||
#define D2N(d) \
|
||||
((((SD2U(d)-1)*sizeof(Unit))+sizeof(decNumber)*2-1)/sizeof(decNumber))
|
||||
|
||||
/* TODIGIT -- macro to remove the leading digit from the unsigned */
|
||||
/* integer u at column cut (counting from the right, LSD=0) and */
|
||||
/* place it as an ASCII character into the character pointed to by */
|
||||
/* c. Note that cut must be <= 9, and the maximum value for u is */
|
||||
/* 2,000,000,000 (as is needed for negative exponents of */
|
||||
/* subnormals). The unsigned integer pow is used as a temporary */
|
||||
/* variable. */
|
||||
#define TODIGIT(u, cut, c, pow) { \
|
||||
*(c)='0'; \
|
||||
pow=DECPOWERS[cut]*2; \
|
||||
if ((u)>pow) { \
|
||||
pow*=4; \
|
||||
if ((u)>=pow) {(u)-=pow; *(c)+=8;} \
|
||||
pow/=2; \
|
||||
if ((u)>=pow) {(u)-=pow; *(c)+=4;} \
|
||||
pow/=2; \
|
||||
} \
|
||||
if ((u)>=pow) {(u)-=pow; *(c)+=2;} \
|
||||
pow/=2; \
|
||||
if ((u)>=pow) {(u)-=pow; *(c)+=1;} \
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Definitions for fixed-precision modules (only valid after */
|
||||
/* decSingle.h, decDouble.h, or decQuad.h has been included) */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
/* bcdnum -- a structure describing a format-independent finite */
|
||||
/* number, whose coefficient is a string of bcd8 uBytes */
|
||||
typedef struct {
|
||||
uByte *msd; /* -> most significant digit */
|
||||
uByte *lsd; /* -> least ditto */
|
||||
uInt sign; /* 0=positive, DECFLOAT_Sign=negative */
|
||||
Int exponent; /* Unadjusted signed exponent (q), or */
|
||||
/* DECFLOAT_NaN etc. for a special */
|
||||
} bcdnum;
|
||||
|
||||
/* Test if exponent or bcdnum exponent must be a special, etc. */
|
||||
#define EXPISSPECIAL(exp) ((exp)>=DECFLOAT_MinSp)
|
||||
#define EXPISINF(exp) (exp==DECFLOAT_Inf)
|
||||
#define EXPISNAN(exp) (exp==DECFLOAT_qNaN || exp==DECFLOAT_sNaN)
|
||||
#define NUMISSPECIAL(num) (EXPISSPECIAL((num)->exponent))
|
||||
|
||||
/* Refer to a 32-bit word or byte in a decFloat (df) by big-endian */
|
||||
/* (array) notation (the 0 word or byte contains the sign bit), */
|
||||
/* automatically adjusting for endianness; similarly address a word */
|
||||
/* in the next-wider format (decFloatWider, or dfw) */
|
||||
#define DECWORDS (DECBYTES/4)
|
||||
#define DECWWORDS (DECWBYTES/4)
|
||||
#if DECLITEND
|
||||
#define DFBYTE(df, off) ((df)->bytes[DECBYTES-1-(off)])
|
||||
#define DFWORD(df, off) ((df)->words[DECWORDS-1-(off)])
|
||||
#define DFWWORD(dfw, off) ((dfw)->words[DECWWORDS-1-(off)])
|
||||
#else
|
||||
#define DFBYTE(df, off) ((df)->bytes[off])
|
||||
#define DFWORD(df, off) ((df)->words[off])
|
||||
#define DFWWORD(dfw, off) ((dfw)->words[off])
|
||||
#endif
|
||||
|
||||
/* Tests for sign or specials, directly on DECFLOATs */
|
||||
#define DFISSIGNED(df) ((DFWORD(df, 0)&0x80000000)!=0)
|
||||
#define DFISSPECIAL(df) ((DFWORD(df, 0)&0x78000000)==0x78000000)
|
||||
#define DFISINF(df) ((DFWORD(df, 0)&0x7c000000)==0x78000000)
|
||||
#define DFISNAN(df) ((DFWORD(df, 0)&0x7c000000)==0x7c000000)
|
||||
#define DFISQNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7c000000)
|
||||
#define DFISSNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7e000000)
|
||||
|
||||
/* Shared lookup tables */
|
||||
extern const uInt DECCOMBMSD[64]; /* Combination field -> MSD */
|
||||
extern const uInt DECCOMBFROM[48]; /* exp+msd -> Combination */
|
||||
|
||||
/* Private generic (utility) routine */
|
||||
#if DECCHECK || DECTRACE
|
||||
extern void decShowNum(const bcdnum *, const char *);
|
||||
#endif
|
||||
|
||||
/* Format-dependent macros and constants */
|
||||
#if defined(DECPMAX)
|
||||
|
||||
/* Useful constants */
|
||||
#define DECPMAX9 (ROUNDUP(DECPMAX, 9)/9) /* 'Pmax' in 10**9s */
|
||||
/* Top words for a zero */
|
||||
#define SINGLEZERO 0x22500000
|
||||
#define DOUBLEZERO 0x22380000
|
||||
#define QUADZERO 0x22080000
|
||||
/* [ZEROWORD is defined to be one of these in the DFISZERO macro] */
|
||||
|
||||
/* Format-dependent common tests: */
|
||||
/* DFISZERO -- test for (any) zero */
|
||||
/* DFISCCZERO -- test for coefficient continuation being zero */
|
||||
/* DFISCC01 -- test for coefficient contains only 0s and 1s */
|
||||
/* DFISINT -- test for finite and exponent q=0 */
|
||||
/* DFISUINT01 -- test for sign=0, finite, exponent q=0, and */
|
||||
/* MSD=0 or 1 */
|
||||
/* ZEROWORD is also defined here. */
|
||||
/* */
|
||||
/* In DFISZERO the first test checks the least-significant word */
|
||||
/* (most likely to be non-zero); the penultimate tests MSD and */
|
||||
/* DPDs in the signword, and the final test excludes specials and */
|
||||
/* MSD>7. DFISINT similarly has to allow for the two forms of */
|
||||
/* MSD codes. DFISUINT01 only has to allow for one form of MSD */
|
||||
/* code. */
|
||||
#if DECPMAX==7
|
||||
#define ZEROWORD SINGLEZERO
|
||||
/* [test macros not needed except for Zero] */
|
||||
#define DFISZERO(df) ((DFWORD(df, 0)&0x1c0fffff)==0 \
|
||||
&& (DFWORD(df, 0)&0x60000000)!=0x60000000)
|
||||
#elif DECPMAX==16
|
||||
#define ZEROWORD DOUBLEZERO
|
||||
#define DFISZERO(df) ((DFWORD(df, 1)==0 \
|
||||
&& (DFWORD(df, 0)&0x1c03ffff)==0 \
|
||||
&& (DFWORD(df, 0)&0x60000000)!=0x60000000))
|
||||
#define DFISINT(df) ((DFWORD(df, 0)&0x63fc0000)==0x22380000 \
|
||||
||(DFWORD(df, 0)&0x7bfc0000)==0x6a380000)
|
||||
#define DFISUINT01(df) ((DFWORD(df, 0)&0xfbfc0000)==0x22380000)
|
||||
#define DFISCCZERO(df) (DFWORD(df, 1)==0 \
|
||||
&& (DFWORD(df, 0)&0x0003ffff)==0)
|
||||
#define DFISCC01(df) ((DFWORD(df, 0)&~0xfffc9124)==0 \
|
||||
&& (DFWORD(df, 1)&~0x49124491)==0)
|
||||
#elif DECPMAX==34
|
||||
#define ZEROWORD QUADZERO
|
||||
#define DFISZERO(df) ((DFWORD(df, 3)==0 \
|
||||
&& DFWORD(df, 2)==0 \
|
||||
&& DFWORD(df, 1)==0 \
|
||||
&& (DFWORD(df, 0)&0x1c003fff)==0 \
|
||||
&& (DFWORD(df, 0)&0x60000000)!=0x60000000))
|
||||
#define DFISINT(df) ((DFWORD(df, 0)&0x63ffc000)==0x22080000 \
|
||||
||(DFWORD(df, 0)&0x7bffc000)==0x6a080000)
|
||||
#define DFISUINT01(df) ((DFWORD(df, 0)&0xfbffc000)==0x22080000)
|
||||
#define DFISCCZERO(df) (DFWORD(df, 3)==0 \
|
||||
&& DFWORD(df, 2)==0 \
|
||||
&& DFWORD(df, 1)==0 \
|
||||
&& (DFWORD(df, 0)&0x00003fff)==0)
|
||||
|
||||
#define DFISCC01(df) ((DFWORD(df, 0)&~0xffffc912)==0 \
|
||||
&& (DFWORD(df, 1)&~0x44912449)==0 \
|
||||
&& (DFWORD(df, 2)&~0x12449124)==0 \
|
||||
&& (DFWORD(df, 3)&~0x49124491)==0)
|
||||
#endif
|
||||
|
||||
/* Macros to test if a certain 10 bits of a uInt or pair of uInts */
|
||||
/* are a canonical declet [higher or lower bits are ignored]. */
|
||||
/* declet is at offset 0 (from the right) in a uInt: */
|
||||
#define CANONDPD(dpd) (((dpd)&0x300)==0 || ((dpd)&0x6e)!=0x6e)
|
||||
/* declet is at offset k (a multiple of 2) in a uInt: */
|
||||
#define CANONDPDOFF(dpd, k) (((dpd)&(0x300<<(k)))==0 \
|
||||
|| ((dpd)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
|
||||
/* declet is at offset k (a multiple of 2) in a pair of uInts: */
|
||||
/* [the top 2 bits will always be in the more-significant uInt] */
|
||||
#define CANONDPDTWO(hi, lo, k) (((hi)&(0x300>>(32-(k))))==0 \
|
||||
|| ((hi)&(0x6e>>(32-(k))))!=(0x6e>>(32-(k))) \
|
||||
|| ((lo)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
|
||||
|
||||
/* Macro to test whether a full-length (length DECPMAX) BCD8 */
|
||||
/* coefficient, starting at uByte u, is all zeros */
|
||||
/* Test just the LSWord first, then the remainder as a sequence */
|
||||
/* of tests in order to avoid same-level use of UBTOUI */
|
||||
#if DECPMAX==7
|
||||
#define ISCOEFFZERO(u) ( \
|
||||
UBTOUI((u)+DECPMAX-4)==0 \
|
||||
&& UBTOUS((u)+DECPMAX-6)==0 \
|
||||
&& *(u)==0)
|
||||
#elif DECPMAX==16
|
||||
#define ISCOEFFZERO(u) ( \
|
||||
UBTOUI((u)+DECPMAX-4)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-8)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-12)==0 \
|
||||
&& UBTOUI(u)==0)
|
||||
#elif DECPMAX==34
|
||||
#define ISCOEFFZERO(u) ( \
|
||||
UBTOUI((u)+DECPMAX-4)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-8)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-12)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-16)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-20)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-24)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-28)==0 \
|
||||
&& UBTOUI((u)+DECPMAX-32)==0 \
|
||||
&& UBTOUS(u)==0)
|
||||
#endif
|
||||
|
||||
/* Macros and masks for the sign, exponent continuation, and MSD */
|
||||
/* Get the sign as DECFLOAT_Sign or 0 */
|
||||
#define GETSIGN(df) (DFWORD(df, 0)&0x80000000)
|
||||
/* Get the exponent continuation from a decFloat *df as an Int */
|
||||
#define GETECON(df) ((Int)((DFWORD((df), 0)&0x03ffffff)>>(32-6-DECECONL)))
|
||||
/* Ditto, from the next-wider format */
|
||||
#define GETWECON(df) ((Int)((DFWWORD((df), 0)&0x03ffffff)>>(32-6-DECWECONL)))
|
||||
/* Get the biased exponent similarly */
|
||||
#define GETEXP(df) ((Int)(DECCOMBEXP[DFWORD((df), 0)>>26]+GETECON(df)))
|
||||
/* Get the unbiased exponent similarly */
|
||||
#define GETEXPUN(df) ((Int)GETEXP(df)-DECBIAS)
|
||||
/* Get the MSD similarly (as uInt) */
|
||||
#define GETMSD(df) (DECCOMBMSD[DFWORD((df), 0)>>26])
|
||||
|
||||
/* Compile-time computes of the exponent continuation field masks */
|
||||
/* full exponent continuation field: */
|
||||
#define ECONMASK ((0x03ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
|
||||
/* same, not including its first digit (the qNaN/sNaN selector): */
|
||||
#define ECONNANMASK ((0x01ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
|
||||
|
||||
/* Macros to decode the coefficient in a finite decFloat *df into */
|
||||
/* a BCD string (uByte *bcdin) of length DECPMAX uBytes. */
|
||||
|
||||
/* In-line sequence to convert least significant 10 bits of uInt */
|
||||
/* dpd to three BCD8 digits starting at uByte u. Note that an */
|
||||
/* extra byte is written to the right of the three digits because */
|
||||
/* four bytes are moved at a time for speed; the alternative */
|
||||
/* macro moves exactly three bytes (usually slower). */
|
||||
#define dpd2bcd8(u, dpd) memcpy(u, &DPD2BCD8[((dpd)&0x3ff)*4], 4)
|
||||
#define dpd2bcd83(u, dpd) memcpy(u, &DPD2BCD8[((dpd)&0x3ff)*4], 3)
|
||||
|
||||
/* Decode the declets. After extracting each one, it is decoded */
|
||||
/* to BCD8 using a table lookup (also used for variable-length */
|
||||
/* decode). Each DPD decode is 3 bytes BCD8 plus a one-byte */
|
||||
/* length which is not used, here). Fixed-length 4-byte moves */
|
||||
/* are fast, however, almost everywhere, and so are used except */
|
||||
/* for the final three bytes (to avoid overrun). The code below */
|
||||
/* is 36 instructions for Doubles and about 70 for Quads, even */
|
||||
/* on IA32. */
|
||||
|
||||
/* Two macros are defined for each format: */
|
||||
/* GETCOEFF extracts the coefficient of the current format */
|
||||
/* GETWCOEFF extracts the coefficient of the next-wider format. */
|
||||
/* The latter is a copy of the next-wider GETCOEFF using DFWWORD. */
|
||||
|
||||
#if DECPMAX==7
|
||||
#define GETCOEFF(df, bcd) { \
|
||||
uInt sourhi=DFWORD(df, 0); \
|
||||
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
|
||||
dpd2bcd8(bcd+1, sourhi>>10); \
|
||||
dpd2bcd83(bcd+4, sourhi);}
|
||||
#define GETWCOEFF(df, bcd) { \
|
||||
uInt sourhi=DFWWORD(df, 0); \
|
||||
uInt sourlo=DFWWORD(df, 1); \
|
||||
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
|
||||
dpd2bcd8(bcd+1, sourhi>>8); \
|
||||
dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30)); \
|
||||
dpd2bcd8(bcd+7, sourlo>>20); \
|
||||
dpd2bcd8(bcd+10, sourlo>>10); \
|
||||
dpd2bcd83(bcd+13, sourlo);}
|
||||
|
||||
#elif DECPMAX==16
|
||||
#define GETCOEFF(df, bcd) { \
|
||||
uInt sourhi=DFWORD(df, 0); \
|
||||
uInt sourlo=DFWORD(df, 1); \
|
||||
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
|
||||
dpd2bcd8(bcd+1, sourhi>>8); \
|
||||
dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30)); \
|
||||
dpd2bcd8(bcd+7, sourlo>>20); \
|
||||
dpd2bcd8(bcd+10, sourlo>>10); \
|
||||
dpd2bcd83(bcd+13, sourlo);}
|
||||
#define GETWCOEFF(df, bcd) { \
|
||||
uInt sourhi=DFWWORD(df, 0); \
|
||||
uInt sourmh=DFWWORD(df, 1); \
|
||||
uInt sourml=DFWWORD(df, 2); \
|
||||
uInt sourlo=DFWWORD(df, 3); \
|
||||
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
|
||||
dpd2bcd8(bcd+1, sourhi>>4); \
|
||||
dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26)); \
|
||||
dpd2bcd8(bcd+7, sourmh>>16); \
|
||||
dpd2bcd8(bcd+10, sourmh>>6); \
|
||||
dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28)); \
|
||||
dpd2bcd8(bcd+16, sourml>>18); \
|
||||
dpd2bcd8(bcd+19, sourml>>8); \
|
||||
dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30)); \
|
||||
dpd2bcd8(bcd+25, sourlo>>20); \
|
||||
dpd2bcd8(bcd+28, sourlo>>10); \
|
||||
dpd2bcd83(bcd+31, sourlo);}
|
||||
|
||||
#elif DECPMAX==34
|
||||
#define GETCOEFF(df, bcd) { \
|
||||
uInt sourhi=DFWORD(df, 0); \
|
||||
uInt sourmh=DFWORD(df, 1); \
|
||||
uInt sourml=DFWORD(df, 2); \
|
||||
uInt sourlo=DFWORD(df, 3); \
|
||||
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
|
||||
dpd2bcd8(bcd+1, sourhi>>4); \
|
||||
dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26)); \
|
||||
dpd2bcd8(bcd+7, sourmh>>16); \
|
||||
dpd2bcd8(bcd+10, sourmh>>6); \
|
||||
dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28)); \
|
||||
dpd2bcd8(bcd+16, sourml>>18); \
|
||||
dpd2bcd8(bcd+19, sourml>>8); \
|
||||
dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30)); \
|
||||
dpd2bcd8(bcd+25, sourlo>>20); \
|
||||
dpd2bcd8(bcd+28, sourlo>>10); \
|
||||
dpd2bcd83(bcd+31, sourlo);}
|
||||
|
||||
#define GETWCOEFF(df, bcd) {??} /* [should never be used] */
|
||||
#endif
|
||||
|
||||
/* Macros to decode the coefficient in a finite decFloat *df into */
|
||||
/* a base-billion uInt array, with the least-significant */
|
||||
/* 0-999999999 'digit' at offset 0. */
|
||||
|
||||
/* Decode the declets. After extracting each one, it is decoded */
|
||||
/* to binary using a table lookup. Three tables are used; one */
|
||||
/* the usual DPD to binary, the other two pre-multiplied by 1000 */
|
||||
/* and 1000000 to avoid multiplication during decode. These */
|
||||
/* tables can also be used for multiplying up the MSD as the DPD */
|
||||
/* code for 0 through 9 is the identity. */
|
||||
#define DPD2BIN0 DPD2BIN /* for prettier code */
|
||||
|
||||
#if DECPMAX==7
|
||||
#define GETCOEFFBILL(df, buf) { \
|
||||
uInt sourhi=DFWORD(df, 0); \
|
||||
(buf)[0]=DPD2BIN0[sourhi&0x3ff] \
|
||||
+DPD2BINK[(sourhi>>10)&0x3ff] \
|
||||
+DPD2BINM[DECCOMBMSD[sourhi>>26]];}
|
||||
|
||||
#elif DECPMAX==16
|
||||
#define GETCOEFFBILL(df, buf) { \
|
||||
uInt sourhi, sourlo; \
|
||||
sourlo=DFWORD(df, 1); \
|
||||
(buf)[0]=DPD2BIN0[sourlo&0x3ff] \
|
||||
+DPD2BINK[(sourlo>>10)&0x3ff] \
|
||||
+DPD2BINM[(sourlo>>20)&0x3ff]; \
|
||||
sourhi=DFWORD(df, 0); \
|
||||
(buf)[1]=DPD2BIN0[((sourhi<<2) | (sourlo>>30))&0x3ff] \
|
||||
+DPD2BINK[(sourhi>>8)&0x3ff] \
|
||||
+DPD2BINM[DECCOMBMSD[sourhi>>26]];}
|
||||
|
||||
#elif DECPMAX==34
|
||||
#define GETCOEFFBILL(df, buf) { \
|
||||
uInt sourhi, sourmh, sourml, sourlo; \
|
||||
sourlo=DFWORD(df, 3); \
|
||||
(buf)[0]=DPD2BIN0[sourlo&0x3ff] \
|
||||
+DPD2BINK[(sourlo>>10)&0x3ff] \
|
||||
+DPD2BINM[(sourlo>>20)&0x3ff]; \
|
||||
sourml=DFWORD(df, 2); \
|
||||
(buf)[1]=DPD2BIN0[((sourml<<2) | (sourlo>>30))&0x3ff] \
|
||||
+DPD2BINK[(sourml>>8)&0x3ff] \
|
||||
+DPD2BINM[(sourml>>18)&0x3ff]; \
|
||||
sourmh=DFWORD(df, 1); \
|
||||
(buf)[2]=DPD2BIN0[((sourmh<<4) | (sourml>>28))&0x3ff] \
|
||||
+DPD2BINK[(sourmh>>6)&0x3ff] \
|
||||
+DPD2BINM[(sourmh>>16)&0x3ff]; \
|
||||
sourhi=DFWORD(df, 0); \
|
||||
(buf)[3]=DPD2BIN0[((sourhi<<6) | (sourmh>>26))&0x3ff] \
|
||||
+DPD2BINK[(sourhi>>4)&0x3ff] \
|
||||
+DPD2BINM[DECCOMBMSD[sourhi>>26]];}
|
||||
|
||||
#endif
|
||||
|
||||
/* Macros to decode the coefficient in a finite decFloat *df into */
|
||||
/* a base-thousand uInt array (of size DECLETS+1, to allow for */
|
||||
/* the MSD), with the least-significant 0-999 'digit' at offset 0.*/
|
||||
|
||||
/* Decode the declets. After extracting each one, it is decoded */
|
||||
/* to binary using a table lookup. */
|
||||
#if DECPMAX==7
|
||||
#define GETCOEFFTHOU(df, buf) { \
|
||||
uInt sourhi=DFWORD(df, 0); \
|
||||
(buf)[0]=DPD2BIN[sourhi&0x3ff]; \
|
||||
(buf)[1]=DPD2BIN[(sourhi>>10)&0x3ff]; \
|
||||
(buf)[2]=DECCOMBMSD[sourhi>>26];}
|
||||
|
||||
#elif DECPMAX==16
|
||||
#define GETCOEFFTHOU(df, buf) { \
|
||||
uInt sourhi, sourlo; \
|
||||
sourlo=DFWORD(df, 1); \
|
||||
(buf)[0]=DPD2BIN[sourlo&0x3ff]; \
|
||||
(buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \
|
||||
(buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \
|
||||
sourhi=DFWORD(df, 0); \
|
||||
(buf)[3]=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff]; \
|
||||
(buf)[4]=DPD2BIN[(sourhi>>8)&0x3ff]; \
|
||||
(buf)[5]=DECCOMBMSD[sourhi>>26];}
|
||||
|
||||
#elif DECPMAX==34
|
||||
#define GETCOEFFTHOU(df, buf) { \
|
||||
uInt sourhi, sourmh, sourml, sourlo; \
|
||||
sourlo=DFWORD(df, 3); \
|
||||
(buf)[0]=DPD2BIN[sourlo&0x3ff]; \
|
||||
(buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \
|
||||
(buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \
|
||||
sourml=DFWORD(df, 2); \
|
||||
(buf)[3]=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff]; \
|
||||
(buf)[4]=DPD2BIN[(sourml>>8)&0x3ff]; \
|
||||
(buf)[5]=DPD2BIN[(sourml>>18)&0x3ff]; \
|
||||
sourmh=DFWORD(df, 1); \
|
||||
(buf)[6]=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff]; \
|
||||
(buf)[7]=DPD2BIN[(sourmh>>6)&0x3ff]; \
|
||||
(buf)[8]=DPD2BIN[(sourmh>>16)&0x3ff]; \
|
||||
sourhi=DFWORD(df, 0); \
|
||||
(buf)[9]=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff]; \
|
||||
(buf)[10]=DPD2BIN[(sourhi>>4)&0x3ff]; \
|
||||
(buf)[11]=DECCOMBMSD[sourhi>>26];}
|
||||
#endif
|
||||
|
||||
|
||||
/* Macros to decode the coefficient in a finite decFloat *df and */
|
||||
/* add to a base-thousand uInt array (as for GETCOEFFTHOU). */
|
||||
/* After the addition then most significant 'digit' in the array */
|
||||
/* might have a value larger then 10 (with a maximum of 19). */
|
||||
#if DECPMAX==7
|
||||
#define ADDCOEFFTHOU(df, buf) { \
|
||||
uInt sourhi=DFWORD(df, 0); \
|
||||
(buf)[0]+=DPD2BIN[sourhi&0x3ff]; \
|
||||
if (buf[0]>999) {buf[0]-=1000; buf[1]++;} \
|
||||
(buf)[1]+=DPD2BIN[(sourhi>>10)&0x3ff]; \
|
||||
if (buf[1]>999) {buf[1]-=1000; buf[2]++;} \
|
||||
(buf)[2]+=DECCOMBMSD[sourhi>>26];}
|
||||
|
||||
#elif DECPMAX==16
|
||||
#define ADDCOEFFTHOU(df, buf) { \
|
||||
uInt sourhi, sourlo; \
|
||||
sourlo=DFWORD(df, 1); \
|
||||
(buf)[0]+=DPD2BIN[sourlo&0x3ff]; \
|
||||
if (buf[0]>999) {buf[0]-=1000; buf[1]++;} \
|
||||
(buf)[1]+=DPD2BIN[(sourlo>>10)&0x3ff]; \
|
||||
if (buf[1]>999) {buf[1]-=1000; buf[2]++;} \
|
||||
(buf)[2]+=DPD2BIN[(sourlo>>20)&0x3ff]; \
|
||||
if (buf[2]>999) {buf[2]-=1000; buf[3]++;} \
|
||||
sourhi=DFWORD(df, 0); \
|
||||
(buf)[3]+=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff]; \
|
||||
if (buf[3]>999) {buf[3]-=1000; buf[4]++;} \
|
||||
(buf)[4]+=DPD2BIN[(sourhi>>8)&0x3ff]; \
|
||||
if (buf[4]>999) {buf[4]-=1000; buf[5]++;} \
|
||||
(buf)[5]+=DECCOMBMSD[sourhi>>26];}
|
||||
|
||||
#elif DECPMAX==34
|
||||
#define ADDCOEFFTHOU(df, buf) { \
|
||||
uInt sourhi, sourmh, sourml, sourlo; \
|
||||
sourlo=DFWORD(df, 3); \
|
||||
(buf)[0]+=DPD2BIN[sourlo&0x3ff]; \
|
||||
if (buf[0]>999) {buf[0]-=1000; buf[1]++;} \
|
||||
(buf)[1]+=DPD2BIN[(sourlo>>10)&0x3ff]; \
|
||||
if (buf[1]>999) {buf[1]-=1000; buf[2]++;} \
|
||||
(buf)[2]+=DPD2BIN[(sourlo>>20)&0x3ff]; \
|
||||
if (buf[2]>999) {buf[2]-=1000; buf[3]++;} \
|
||||
sourml=DFWORD(df, 2); \
|
||||
(buf)[3]+=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff]; \
|
||||
if (buf[3]>999) {buf[3]-=1000; buf[4]++;} \
|
||||
(buf)[4]+=DPD2BIN[(sourml>>8)&0x3ff]; \
|
||||
if (buf[4]>999) {buf[4]-=1000; buf[5]++;} \
|
||||
(buf)[5]+=DPD2BIN[(sourml>>18)&0x3ff]; \
|
||||
if (buf[5]>999) {buf[5]-=1000; buf[6]++;} \
|
||||
sourmh=DFWORD(df, 1); \
|
||||
(buf)[6]+=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff]; \
|
||||
if (buf[6]>999) {buf[6]-=1000; buf[7]++;} \
|
||||
(buf)[7]+=DPD2BIN[(sourmh>>6)&0x3ff]; \
|
||||
if (buf[7]>999) {buf[7]-=1000; buf[8]++;} \
|
||||
(buf)[8]+=DPD2BIN[(sourmh>>16)&0x3ff]; \
|
||||
if (buf[8]>999) {buf[8]-=1000; buf[9]++;} \
|
||||
sourhi=DFWORD(df, 0); \
|
||||
(buf)[9]+=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff]; \
|
||||
if (buf[9]>999) {buf[9]-=1000; buf[10]++;} \
|
||||
(buf)[10]+=DPD2BIN[(sourhi>>4)&0x3ff]; \
|
||||
if (buf[10]>999) {buf[10]-=1000; buf[11]++;} \
|
||||
(buf)[11]+=DECCOMBMSD[sourhi>>26];}
|
||||
#endif
|
||||
|
||||
|
||||
/* Set a decFloat to the maximum positive finite number (Nmax) */
|
||||
#if DECPMAX==7
|
||||
#define DFSETNMAX(df) \
|
||||
{DFWORD(df, 0)=0x77f3fcff;}
|
||||
#elif DECPMAX==16
|
||||
#define DFSETNMAX(df) \
|
||||
{DFWORD(df, 0)=0x77fcff3f; \
|
||||
DFWORD(df, 1)=0xcff3fcff;}
|
||||
#elif DECPMAX==34
|
||||
#define DFSETNMAX(df) \
|
||||
{DFWORD(df, 0)=0x77ffcff3; \
|
||||
DFWORD(df, 1)=0xfcff3fcf; \
|
||||
DFWORD(df, 2)=0xf3fcff3f; \
|
||||
DFWORD(df, 3)=0xcff3fcff;}
|
||||
#endif
|
||||
|
||||
/* [end of format-dependent macros and constants] */
|
||||
#endif
|
||||
|
||||
#else
|
||||
#error decNumberLocal included more than once
|
||||
#endif
|
||||
@@ -0,0 +1,220 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Packed Decimal conversion module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2002. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises the routines for Packed Decimal format */
|
||||
/* numbers. Conversions are supplied to and from decNumber, which in */
|
||||
/* turn supports: */
|
||||
/* conversions to and from string */
|
||||
/* arithmetic routines */
|
||||
/* utilities. */
|
||||
/* Conversions from decNumber to and from densely packed decimal */
|
||||
/* formats are provided by the decimal32 through decimal128 modules. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#include <string.h> // for NULL
|
||||
#include "decNumber.h" // base number library
|
||||
#include "decPacked.h" // packed decimal
|
||||
#include "decNumberLocal.h" // decNumber local types, etc.
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decPackedFromNumber -- convert decNumber to BCD Packed Decimal */
|
||||
/* */
|
||||
/* bcd is the BCD bytes */
|
||||
/* length is the length of the BCD array */
|
||||
/* scale is the scale result */
|
||||
/* dn is the decNumber */
|
||||
/* returns bcd, or NULL if error */
|
||||
/* */
|
||||
/* The number is converted to a BCD packed decimal byte array, */
|
||||
/* right aligned in the bcd array, whose length is indicated by the */
|
||||
/* second parameter. The final 4-bit nibble in the array will be a */
|
||||
/* sign nibble, C (1100) for + and D (1101) for -. Unused bytes and */
|
||||
/* nibbles to the left of the number are set to 0. */
|
||||
/* */
|
||||
/* scale is set to the scale of the number (this is the exponent, */
|
||||
/* negated). To force the number to a specified scale, first use the */
|
||||
/* decNumberRescale routine, which will round and change the exponent */
|
||||
/* as necessary. */
|
||||
/* */
|
||||
/* If there is an error (that is, the decNumber has too many digits */
|
||||
/* to fit in length bytes, or it is a NaN or Infinity), NULL is */
|
||||
/* returned and the bcd and scale results are unchanged. Otherwise */
|
||||
/* bcd is returned. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uByte * decPackedFromNumber(uByte *bcd, Int length, Int *scale,
|
||||
const decNumber *dn) {
|
||||
const Unit *up=dn->lsu; // Unit array pointer
|
||||
uByte obyte, *out; // current output byte, and where it goes
|
||||
Int indigs=dn->digits; // digits processed
|
||||
uInt cut=DECDPUN; // downcounter per Unit
|
||||
uInt u=*up; // work
|
||||
uInt nib; // ..
|
||||
#if DECDPUN<=4
|
||||
uInt temp; // ..
|
||||
#endif
|
||||
|
||||
if (dn->digits>length*2-1 // too long ..
|
||||
||(dn->bits & DECSPECIAL)) return NULL; // .. or special -- hopeless
|
||||
|
||||
if (dn->bits&DECNEG) obyte=DECPMINUS; // set the sign ..
|
||||
else obyte=DECPPLUS;
|
||||
*scale=-dn->exponent; // .. and scale
|
||||
|
||||
// loop from lowest (rightmost) byte
|
||||
out=bcd+length-1; // -> final byte
|
||||
for (; out>=bcd; out--) {
|
||||
if (indigs>0) {
|
||||
if (cut==0) {
|
||||
up++;
|
||||
u=*up;
|
||||
cut=DECDPUN;
|
||||
}
|
||||
#if DECDPUN<=4
|
||||
temp=(u*6554)>>16; // fast /10
|
||||
nib=u-X10(temp);
|
||||
u=temp;
|
||||
#else
|
||||
nib=u%10; // cannot use *6554 trick :-(
|
||||
u=u/10;
|
||||
#endif
|
||||
obyte|=(nib<<4);
|
||||
indigs--;
|
||||
cut--;
|
||||
}
|
||||
*out=obyte;
|
||||
obyte=0; // assume 0
|
||||
if (indigs>0) {
|
||||
if (cut==0) {
|
||||
up++;
|
||||
u=*up;
|
||||
cut=DECDPUN;
|
||||
}
|
||||
#if DECDPUN<=4
|
||||
temp=(u*6554)>>16; // as above
|
||||
obyte=(uByte)(u-X10(temp));
|
||||
u=temp;
|
||||
#else
|
||||
obyte=(uByte)(u%10);
|
||||
u=u/10;
|
||||
#endif
|
||||
indigs--;
|
||||
cut--;
|
||||
}
|
||||
} // loop
|
||||
|
||||
return bcd;
|
||||
} // decPackedFromNumber
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decPackedToNumber -- convert BCD Packed Decimal to a decNumber */
|
||||
/* */
|
||||
/* bcd is the BCD bytes */
|
||||
/* length is the length of the BCD array */
|
||||
/* scale is the scale associated with the BCD integer */
|
||||
/* dn is the decNumber [with space for length*2 digits] */
|
||||
/* returns dn, or NULL if error */
|
||||
/* */
|
||||
/* The BCD packed decimal byte array, together with an associated */
|
||||
/* scale, is converted to a decNumber. The BCD array is assumed full */
|
||||
/* of digits, and must be ended by a 4-bit sign nibble in the least */
|
||||
/* significant four bits of the final byte. */
|
||||
/* */
|
||||
/* The scale is used (negated) as the exponent of the decNumber. */
|
||||
/* Note that zeros may have a sign and/or a scale. */
|
||||
/* */
|
||||
/* The decNumber structure is assumed to have sufficient space to */
|
||||
/* hold the converted number (that is, up to length*2-1 digits), so */
|
||||
/* no error is possible unless the adjusted exponent is out of range, */
|
||||
/* no sign nibble was found, or a sign nibble was found before the */
|
||||
/* final nibble. In these error cases, NULL is returned and the */
|
||||
/* decNumber will be 0. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decNumber * decPackedToNumber(const uByte *bcd, Int length,
|
||||
const Int *scale, decNumber *dn) {
|
||||
const uByte *last=bcd+length-1; // -> last byte
|
||||
const uByte *first; // -> first non-zero byte
|
||||
uInt nib; // work nibble
|
||||
Unit *up=dn->lsu; // output pointer
|
||||
Int digits; // digits count
|
||||
Int cut=0; // phase of output
|
||||
|
||||
decNumberZero(dn); // default result
|
||||
last=&bcd[length-1];
|
||||
nib=*last & 0x0f; // get the sign
|
||||
if (nib==DECPMINUS || nib==DECPMINUSALT) dn->bits=DECNEG;
|
||||
else if (nib<=9) return NULL; // not a sign nibble
|
||||
|
||||
// skip leading zero bytes [final byte is always non-zero, due to sign]
|
||||
for (first=bcd; *first==0;) first++;
|
||||
digits=(last-first)*2+1; // calculate digits ..
|
||||
if ((*first & 0xf0)==0) digits--; // adjust for leading zero nibble
|
||||
if (digits!=0) dn->digits=digits; // count of actual digits [if 0,
|
||||
// leave as 1]
|
||||
|
||||
// check the adjusted exponent; note that scale could be unbounded
|
||||
dn->exponent=-*scale; // set the exponent
|
||||
if (*scale>=0) { // usual case
|
||||
if ((dn->digits-*scale-1)<-DECNUMMAXE) { // underflow
|
||||
decNumberZero(dn);
|
||||
return NULL;}
|
||||
}
|
||||
else { // -ve scale; +ve exponent
|
||||
// need to be careful to avoid wrap, here, also BADINT case
|
||||
if ((*scale<-DECNUMMAXE) // overflow even without digits
|
||||
|| ((dn->digits-*scale-1)>DECNUMMAXE)) { // overflow
|
||||
decNumberZero(dn);
|
||||
return NULL;}
|
||||
}
|
||||
if (digits==0) return dn; // result was zero
|
||||
|
||||
// copy the digits to the number's units, starting at the lsu
|
||||
// [unrolled]
|
||||
for (;;) { // forever
|
||||
// left nibble first
|
||||
nib=(unsigned)(*last & 0xf0)>>4;
|
||||
// got a digit, in nib
|
||||
if (nib>9) {decNumberZero(dn); return NULL;}
|
||||
|
||||
if (cut==0) *up=(Unit)nib;
|
||||
else *up=(Unit)(*up+nib*DECPOWERS[cut]);
|
||||
digits--;
|
||||
if (digits==0) break; // got them all
|
||||
cut++;
|
||||
if (cut==DECDPUN) {
|
||||
up++;
|
||||
cut=0;
|
||||
}
|
||||
last--; // ready for next
|
||||
nib=*last & 0x0f; // get right nibble
|
||||
if (nib>9) {decNumberZero(dn); return NULL;}
|
||||
|
||||
// got a digit, in nib
|
||||
if (cut==0) *up=(Unit)nib;
|
||||
else *up=(Unit)(*up+nib*DECPOWERS[cut]);
|
||||
digits--;
|
||||
if (digits==0) break; // got them all
|
||||
cut++;
|
||||
if (cut==DECDPUN) {
|
||||
up++;
|
||||
cut=0;
|
||||
}
|
||||
} // forever
|
||||
|
||||
return dn;
|
||||
} // decPackedToNumber
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Packed Decimal conversion module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2005. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECPACKED)
|
||||
#define DECPACKED
|
||||
#define DECPNAME "decPacked" /* Short name */
|
||||
#define DECPFULLNAME "Packed Decimal conversions" /* Verbose name */
|
||||
#define DECPAUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
#define DECPACKED_DefP 32 /* default precision */
|
||||
|
||||
#ifndef DECNUMDIGITS
|
||||
#define DECNUMDIGITS DECPACKED_DefP /* size if not already defined*/
|
||||
#endif
|
||||
#include "decNumber.h" /* context and number library */
|
||||
|
||||
/* Sign nibble constants */
|
||||
#if !defined(DECPPLUSALT)
|
||||
#define DECPPLUSALT 0x0A /* alternate plus nibble */
|
||||
#define DECPMINUSALT 0x0B /* alternate minus nibble */
|
||||
#define DECPPLUS 0x0C /* preferred plus nibble */
|
||||
#define DECPMINUS 0x0D /* preferred minus nibble */
|
||||
#define DECPPLUSALT2 0x0E /* alternate plus nibble */
|
||||
#define DECPUNSIGNED 0x0F /* alternate plus nibble (unsigned) */
|
||||
#endif
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* decPacked public routines */
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Conversions */
|
||||
uint8_t * decPackedFromNumber(uint8_t *, int32_t, int32_t *,
|
||||
const decNumber *);
|
||||
decNumber * decPackedToNumber(const uint8_t *, int32_t, const int32_t *,
|
||||
decNumber *);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,135 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decQuad.c -- decQuad operations module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2010. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is included in the package as decNumber.pdf. This */
|
||||
/* document is also available in HTML, together with specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises decQuad operations (including conversions) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
|
||||
/* Constant mappings for shared code */
|
||||
#define DECPMAX DECQUAD_Pmax
|
||||
#define DECEMIN DECQUAD_Emin
|
||||
#define DECEMAX DECQUAD_Emax
|
||||
#define DECEMAXD DECQUAD_EmaxD
|
||||
#define DECBYTES DECQUAD_Bytes
|
||||
#define DECSTRING DECQUAD_String
|
||||
#define DECECONL DECQUAD_EconL
|
||||
#define DECBIAS DECQUAD_Bias
|
||||
#define DECLETS DECQUAD_Declets
|
||||
#define DECQTINY (-DECQUAD_Bias)
|
||||
|
||||
/* Type and function mappings for shared code */
|
||||
#define decFloat decQuad // Type name
|
||||
|
||||
// Utilities and conversions (binary results, extractors, etc.)
|
||||
#define decFloatFromBCD decQuadFromBCD
|
||||
#define decFloatFromInt32 decQuadFromInt32
|
||||
#define decFloatFromPacked decQuadFromPacked
|
||||
#define decFloatFromPackedChecked decQuadFromPackedChecked
|
||||
#define decFloatFromString decQuadFromString
|
||||
#define decFloatFromUInt32 decQuadFromUInt32
|
||||
#define decFloatFromWider decQuadFromWider
|
||||
#define decFloatGetCoefficient decQuadGetCoefficient
|
||||
#define decFloatGetExponent decQuadGetExponent
|
||||
#define decFloatSetCoefficient decQuadSetCoefficient
|
||||
#define decFloatSetExponent decQuadSetExponent
|
||||
#define decFloatShow decQuadShow
|
||||
#define decFloatToBCD decQuadToBCD
|
||||
#define decFloatToEngString decQuadToEngString
|
||||
#define decFloatToInt32 decQuadToInt32
|
||||
#define decFloatToInt32Exact decQuadToInt32Exact
|
||||
#define decFloatToPacked decQuadToPacked
|
||||
#define decFloatToString decQuadToString
|
||||
#define decFloatToUInt32 decQuadToUInt32
|
||||
#define decFloatToUInt32Exact decQuadToUInt32Exact
|
||||
#define decFloatToWider decQuadToWider
|
||||
#define decFloatZero decQuadZero
|
||||
|
||||
// Computational (result is a decFloat)
|
||||
#define decFloatAbs decQuadAbs
|
||||
#define decFloatAdd decQuadAdd
|
||||
#define decFloatAnd decQuadAnd
|
||||
#define decFloatDivide decQuadDivide
|
||||
#define decFloatDivideInteger decQuadDivideInteger
|
||||
#define decFloatFMA decQuadFMA
|
||||
#define decFloatInvert decQuadInvert
|
||||
#define decFloatLogB decQuadLogB
|
||||
#define decFloatMax decQuadMax
|
||||
#define decFloatMaxMag decQuadMaxMag
|
||||
#define decFloatMin decQuadMin
|
||||
#define decFloatMinMag decQuadMinMag
|
||||
#define decFloatMinus decQuadMinus
|
||||
#define decFloatMultiply decQuadMultiply
|
||||
#define decFloatNextMinus decQuadNextMinus
|
||||
#define decFloatNextPlus decQuadNextPlus
|
||||
#define decFloatNextToward decQuadNextToward
|
||||
#define decFloatOr decQuadOr
|
||||
#define decFloatPlus decQuadPlus
|
||||
#define decFloatQuantize decQuadQuantize
|
||||
#define decFloatReduce decQuadReduce
|
||||
#define decFloatRemainder decQuadRemainder
|
||||
#define decFloatRemainderNear decQuadRemainderNear
|
||||
#define decFloatRotate decQuadRotate
|
||||
#define decFloatScaleB decQuadScaleB
|
||||
#define decFloatShift decQuadShift
|
||||
#define decFloatSubtract decQuadSubtract
|
||||
#define decFloatToIntegralValue decQuadToIntegralValue
|
||||
#define decFloatToIntegralExact decQuadToIntegralExact
|
||||
#define decFloatXor decQuadXor
|
||||
|
||||
// Comparisons
|
||||
#define decFloatCompare decQuadCompare
|
||||
#define decFloatCompareSignal decQuadCompareSignal
|
||||
#define decFloatCompareTotal decQuadCompareTotal
|
||||
#define decFloatCompareTotalMag decQuadCompareTotalMag
|
||||
|
||||
// Copies
|
||||
#define decFloatCanonical decQuadCanonical
|
||||
#define decFloatCopy decQuadCopy
|
||||
#define decFloatCopyAbs decQuadCopyAbs
|
||||
#define decFloatCopyNegate decQuadCopyNegate
|
||||
#define decFloatCopySign decQuadCopySign
|
||||
|
||||
// Non-computational
|
||||
#define decFloatClass decQuadClass
|
||||
#define decFloatClassString decQuadClassString
|
||||
#define decFloatDigits decQuadDigits
|
||||
#define decFloatIsCanonical decQuadIsCanonical
|
||||
#define decFloatIsFinite decQuadIsFinite
|
||||
#define decFloatIsInfinite decQuadIsInfinite
|
||||
#define decFloatIsInteger decQuadIsInteger
|
||||
#define decFloatIsLogical decQuadIsLogical
|
||||
#define decFloatIsNaN decQuadIsNaN
|
||||
#define decFloatIsNegative decQuadIsNegative
|
||||
#define decFloatIsNormal decQuadIsNormal
|
||||
#define decFloatIsPositive decQuadIsPositive
|
||||
#define decFloatIsSignaling decQuadIsSignaling
|
||||
#define decFloatIsSignalling decQuadIsSignalling
|
||||
#define decFloatIsSigned decQuadIsSigned
|
||||
#define decFloatIsSubnormal decQuadIsSubnormal
|
||||
#define decFloatIsZero decQuadIsZero
|
||||
#define decFloatRadix decQuadRadix
|
||||
#define decFloatSameQuantum decQuadSameQuantum
|
||||
#define decFloatVersion decQuadVersion
|
||||
|
||||
/* And now the code itself */
|
||||
#include "decContext.h" // public includes
|
||||
#include "decQuad.h" // ..
|
||||
#include "decNumberLocal.h" // local includes (need DECPMAX)
|
||||
#include "decCommon.c" // non-arithmetic decFloat routines
|
||||
#include "decBasic.c" // basic formats routines
|
||||
|
||||
@@ -0,0 +1,177 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decQuad.h -- Decimal 128-bit format module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2010. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is included in the package as decNumber.pdf. This */
|
||||
/* document is also available in HTML, together with specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This include file is always included by decSingle and decDouble, */
|
||||
/* and therefore also holds useful constants used by all three. */
|
||||
|
||||
#if !defined(DECQUAD)
|
||||
#define DECQUAD
|
||||
|
||||
#define DECQUADNAME "decimalQuad" /* Short name */
|
||||
#define DECQUADTITLE "Decimal 128-bit datum" /* Verbose name */
|
||||
#define DECQUADAUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
/* parameters for decQuads */
|
||||
#define DECQUAD_Bytes 16 /* length */
|
||||
#define DECQUAD_Pmax 34 /* maximum precision (digits) */
|
||||
#define DECQUAD_Emin -6143 /* minimum adjusted exponent */
|
||||
#define DECQUAD_Emax 6144 /* maximum adjusted exponent */
|
||||
#define DECQUAD_EmaxD 4 /* maximum exponent digits */
|
||||
#define DECQUAD_Bias 6176 /* bias for the exponent */
|
||||
#define DECQUAD_String 43 /* maximum string length, +1 */
|
||||
#define DECQUAD_EconL 12 /* exponent continuation length */
|
||||
#define DECQUAD_Declets 11 /* count of declets */
|
||||
/* highest biased exponent (Elimit-1) */
|
||||
#define DECQUAD_Ehigh (DECQUAD_Emax + DECQUAD_Bias - (DECQUAD_Pmax-1))
|
||||
|
||||
/* Required include */
|
||||
#include "decContext.h"
|
||||
|
||||
/* The decQuad decimal 128-bit type, accessible by all sizes */
|
||||
typedef union {
|
||||
uint8_t bytes[DECQUAD_Bytes]; /* fields: 1, 5, 12, 110 bits */
|
||||
uint16_t shorts[DECQUAD_Bytes/2];
|
||||
uint32_t words[DECQUAD_Bytes/4];
|
||||
#if DECUSE64
|
||||
uint64_t longs[DECQUAD_Bytes/8];
|
||||
#endif
|
||||
} decQuad;
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Shared constants */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
/* sign and special values [top 32-bits; last two bits are don't-care
|
||||
for Infinity on input, last bit don't-care for NaNs] */
|
||||
#define DECFLOAT_Sign 0x80000000 /* 1 00000 00 Sign */
|
||||
#define DECFLOAT_NaN 0x7c000000 /* 0 11111 00 NaN generic */
|
||||
#define DECFLOAT_qNaN 0x7c000000 /* 0 11111 00 qNaN */
|
||||
#define DECFLOAT_sNaN 0x7e000000 /* 0 11111 10 sNaN */
|
||||
#define DECFLOAT_Inf 0x78000000 /* 0 11110 00 Infinity */
|
||||
#define DECFLOAT_MinSp 0x78000000 /* minimum special value */
|
||||
/* [specials are all >=MinSp] */
|
||||
/* Sign nibble constants */
|
||||
#if !defined(DECPPLUSALT)
|
||||
#define DECPPLUSALT 0x0A /* alternate plus nibble */
|
||||
#define DECPMINUSALT 0x0B /* alternate minus nibble */
|
||||
#define DECPPLUS 0x0C /* preferred plus nibble */
|
||||
#define DECPMINUS 0x0D /* preferred minus nibble */
|
||||
#define DECPPLUSALT2 0x0E /* alternate plus nibble */
|
||||
#define DECPUNSIGNED 0x0F /* alternate plus nibble (unsigned) */
|
||||
#endif
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Routines -- implemented as decFloat routines in common files */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
/* Utilities and conversions, extractors, etc.) */
|
||||
extern decQuad * decQuadFromBCD(decQuad *, int32_t, const uint8_t *, int32_t);
|
||||
extern decQuad * decQuadFromInt32(decQuad *, int32_t);
|
||||
extern decQuad * decQuadFromPacked(decQuad *, int32_t, const uint8_t *);
|
||||
extern decQuad * decQuadFromPackedChecked(decQuad *, int32_t, const uint8_t *);
|
||||
extern decQuad * decQuadFromString(decQuad *, const char *, decContext *);
|
||||
extern decQuad * decQuadFromUInt32(decQuad *, uint32_t);
|
||||
extern int32_t decQuadGetCoefficient(const decQuad *, uint8_t *);
|
||||
extern int32_t decQuadGetExponent(const decQuad *);
|
||||
extern decQuad * decQuadSetCoefficient(decQuad *, const uint8_t *, int32_t);
|
||||
extern decQuad * decQuadSetExponent(decQuad *, decContext *, int32_t);
|
||||
extern void decQuadShow(const decQuad *, const char *);
|
||||
extern int32_t decQuadToBCD(const decQuad *, int32_t *, uint8_t *);
|
||||
extern char * decQuadToEngString(const decQuad *, char *);
|
||||
extern int32_t decQuadToInt32(const decQuad *, decContext *, enum rounding);
|
||||
extern int32_t decQuadToInt32Exact(const decQuad *, decContext *, enum rounding);
|
||||
extern int32_t decQuadToPacked(const decQuad *, int32_t *, uint8_t *);
|
||||
extern char * decQuadToString(const decQuad *, char *);
|
||||
extern uint32_t decQuadToUInt32(const decQuad *, decContext *, enum rounding);
|
||||
extern uint32_t decQuadToUInt32Exact(const decQuad *, decContext *, enum rounding);
|
||||
extern decQuad * decQuadZero(decQuad *);
|
||||
|
||||
/* Computational (result is a decQuad) */
|
||||
extern decQuad * decQuadAbs(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadAdd(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadAnd(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadDivide(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadDivideInteger(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadFMA(decQuad *, const decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadInvert(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadLogB(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadMax(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadMaxMag(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadMin(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadMinMag(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadMinus(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadMultiply(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadNextMinus(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadNextPlus(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadNextToward(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadOr(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadPlus(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadQuantize(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadReduce(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadRemainder(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadRemainderNear(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadRotate(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadScaleB(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadShift(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadSubtract(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadToIntegralValue(decQuad *, const decQuad *, decContext *, enum rounding);
|
||||
extern decQuad * decQuadToIntegralExact(decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadXor(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
|
||||
/* Comparisons */
|
||||
extern decQuad * decQuadCompare(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadCompareSignal(decQuad *, const decQuad *, const decQuad *, decContext *);
|
||||
extern decQuad * decQuadCompareTotal(decQuad *, const decQuad *, const decQuad *);
|
||||
extern decQuad * decQuadCompareTotalMag(decQuad *, const decQuad *, const decQuad *);
|
||||
|
||||
/* Copies */
|
||||
extern decQuad * decQuadCanonical(decQuad *, const decQuad *);
|
||||
extern decQuad * decQuadCopy(decQuad *, const decQuad *);
|
||||
extern decQuad * decQuadCopyAbs(decQuad *, const decQuad *);
|
||||
extern decQuad * decQuadCopyNegate(decQuad *, const decQuad *);
|
||||
extern decQuad * decQuadCopySign(decQuad *, const decQuad *, const decQuad *);
|
||||
|
||||
/* Non-computational */
|
||||
extern enum decClass decQuadClass(const decQuad *);
|
||||
extern const char * decQuadClassString(const decQuad *);
|
||||
extern uint32_t decQuadDigits(const decQuad *);
|
||||
extern uint32_t decQuadIsCanonical(const decQuad *);
|
||||
extern uint32_t decQuadIsFinite(const decQuad *);
|
||||
extern uint32_t decQuadIsInteger(const decQuad *);
|
||||
extern uint32_t decQuadIsLogical(const decQuad *);
|
||||
extern uint32_t decQuadIsInfinite(const decQuad *);
|
||||
extern uint32_t decQuadIsNaN(const decQuad *);
|
||||
extern uint32_t decQuadIsNegative(const decQuad *);
|
||||
extern uint32_t decQuadIsNormal(const decQuad *);
|
||||
extern uint32_t decQuadIsPositive(const decQuad *);
|
||||
extern uint32_t decQuadIsSignaling(const decQuad *);
|
||||
extern uint32_t decQuadIsSignalling(const decQuad *);
|
||||
extern uint32_t decQuadIsSigned(const decQuad *);
|
||||
extern uint32_t decQuadIsSubnormal(const decQuad *);
|
||||
extern uint32_t decQuadIsZero(const decQuad *);
|
||||
extern uint32_t decQuadRadix(const decQuad *);
|
||||
extern uint32_t decQuadSameQuantum(const decQuad *, const decQuad *);
|
||||
extern const char * decQuadVersion(void);
|
||||
|
||||
/* decNumber conversions; these are implemented as macros so as not */
|
||||
/* to force a dependency on decimal128 and decNumber in decQuad. */
|
||||
/* decQuadFromNumber returns a decimal128 * to avoid warnings. */
|
||||
#define decQuadToNumber(dq, dn) decimal128ToNumber((decimal128 *)(dq), dn)
|
||||
#define decQuadFromNumber(dq, dn, set) decimal128FromNumber((decimal128 *)(dq), dn, set)
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,71 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decSingle.c -- decSingle operations module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2008. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is included in the package as decNumber.pdf. This */
|
||||
/* document is also available in HTML, together with specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises decSingle operations (including conversions) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#include "decContext.h" // public includes
|
||||
#include "decSingle.h" // public includes
|
||||
|
||||
/* Constant mappings for shared code */
|
||||
#define DECPMAX DECSINGLE_Pmax
|
||||
#define DECEMIN DECSINGLE_Emin
|
||||
#define DECEMAX DECSINGLE_Emax
|
||||
#define DECEMAXD DECSINGLE_EmaxD
|
||||
#define DECBYTES DECSINGLE_Bytes
|
||||
#define DECSTRING DECSINGLE_String
|
||||
#define DECECONL DECSINGLE_EconL
|
||||
#define DECBIAS DECSINGLE_Bias
|
||||
#define DECLETS DECSINGLE_Declets
|
||||
#define DECQTINY (-DECSINGLE_Bias)
|
||||
// parameters of next-wider format
|
||||
#define DECWBYTES DECDOUBLE_Bytes
|
||||
#define DECWPMAX DECDOUBLE_Pmax
|
||||
#define DECWECONL DECDOUBLE_EconL
|
||||
#define DECWBIAS DECDOUBLE_Bias
|
||||
|
||||
/* Type and function mappings for shared code */
|
||||
#define decFloat decSingle // Type name
|
||||
#define decFloatWider decDouble // Type name
|
||||
|
||||
// Utility (binary results, extractors, etc.)
|
||||
#define decFloatFromBCD decSingleFromBCD
|
||||
#define decFloatFromPacked decSingleFromPacked
|
||||
#define decFloatFromPackedChecked decSingleFromPackedChecked
|
||||
#define decFloatFromString decSingleFromString
|
||||
#define decFloatFromWider decSingleFromWider
|
||||
#define decFloatGetCoefficient decSingleGetCoefficient
|
||||
#define decFloatGetExponent decSingleGetExponent
|
||||
#define decFloatSetCoefficient decSingleSetCoefficient
|
||||
#define decFloatSetExponent decSingleSetExponent
|
||||
#define decFloatShow decSingleShow
|
||||
#define decFloatToBCD decSingleToBCD
|
||||
#define decFloatToEngString decSingleToEngString
|
||||
#define decFloatToPacked decSingleToPacked
|
||||
#define decFloatToString decSingleToString
|
||||
#define decFloatToWider decSingleToWider
|
||||
#define decFloatZero decSingleZero
|
||||
|
||||
// Non-computational
|
||||
#define decFloatRadix decSingleRadix
|
||||
#define decFloatVersion decSingleVersion
|
||||
|
||||
#include "decNumberLocal.h" // local includes (need DECPMAX)
|
||||
#include "decCommon.c" // non-basic decFloat routines
|
||||
// [Do not include decBasic.c for decimal32]
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decSingle.h -- Decimal 32-bit format module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2008. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is included in the package as decNumber.pdf. This */
|
||||
/* document is also available in HTML, together with specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECSINGLE)
|
||||
#define DECSINGLE
|
||||
|
||||
#define DECSINGLENAME "decSingle" /* Short name */
|
||||
#define DECSINGLETITLE "Decimal 32-bit datum" /* Verbose name */
|
||||
#define DECSINGLEAUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
/* parameters for decSingles */
|
||||
#define DECSINGLE_Bytes 4 /* length */
|
||||
#define DECSINGLE_Pmax 7 /* maximum precision (digits) */
|
||||
#define DECSINGLE_Emin -95 /* minimum adjusted exponent */
|
||||
#define DECSINGLE_Emax 96 /* maximum adjusted exponent */
|
||||
#define DECSINGLE_EmaxD 3 /* maximum exponent digits */
|
||||
#define DECSINGLE_Bias 101 /* bias for the exponent */
|
||||
#define DECSINGLE_String 16 /* maximum string length, +1 */
|
||||
#define DECSINGLE_EconL 6 /* exponent continuation length */
|
||||
#define DECSINGLE_Declets 2 /* count of declets */
|
||||
/* highest biased exponent (Elimit-1) */
|
||||
#define DECSINGLE_Ehigh (DECSINGLE_Emax + DECSINGLE_Bias - (DECSINGLE_Pmax-1))
|
||||
|
||||
/* Required includes */
|
||||
#include "decContext.h"
|
||||
#include "decQuad.h"
|
||||
#include "decDouble.h"
|
||||
|
||||
/* The decSingle decimal 32-bit type, accessible by all sizes */
|
||||
typedef union {
|
||||
uint8_t bytes[DECSINGLE_Bytes]; /* fields: 1, 5, 6, 20 bits */
|
||||
uint16_t shorts[DECSINGLE_Bytes/2];
|
||||
uint32_t words[DECSINGLE_Bytes/4];
|
||||
} decSingle;
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Routines -- implemented as decFloat routines in common files */
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
/* Utilities (binary argument(s) or result, extractors, etc.) */
|
||||
extern decSingle * decSingleFromBCD(decSingle *, int32_t, const uint8_t *, int32_t);
|
||||
extern decSingle * decSingleFromPacked(decSingle *, int32_t, const uint8_t *);
|
||||
extern decSingle * decSingleFromPackedChecked(decSingle *, int32_t, const uint8_t *);
|
||||
extern decSingle * decSingleFromString(decSingle *, const char *, decContext *);
|
||||
extern decSingle * decSingleFromWider(decSingle *, const decDouble *, decContext *);
|
||||
extern int32_t decSingleGetCoefficient(const decSingle *, uint8_t *);
|
||||
extern int32_t decSingleGetExponent(const decSingle *);
|
||||
extern decSingle * decSingleSetCoefficient(decSingle *, const uint8_t *, int32_t);
|
||||
extern decSingle * decSingleSetExponent(decSingle *, decContext *, int32_t);
|
||||
extern void decSingleShow(const decSingle *, const char *);
|
||||
extern int32_t decSingleToBCD(const decSingle *, int32_t *, uint8_t *);
|
||||
extern char * decSingleToEngString(const decSingle *, char *);
|
||||
extern int32_t decSingleToPacked(const decSingle *, int32_t *, uint8_t *);
|
||||
extern char * decSingleToString(const decSingle *, char *);
|
||||
extern decDouble * decSingleToWider(const decSingle *, decDouble *);
|
||||
extern decSingle * decSingleZero(decSingle *);
|
||||
|
||||
/* (No Arithmetic routines for decSingle) */
|
||||
|
||||
/* Non-computational */
|
||||
extern uint32_t decSingleRadix(const decSingle *);
|
||||
extern const char * decSingleVersion(void);
|
||||
|
||||
/* decNumber conversions; these are implemented as macros so as not */
|
||||
/* to force a dependency on decimal32 and decNumber in decSingle. */
|
||||
/* decSingleFromNumber returns a decimal32 * to avoid warnings. */
|
||||
#define decSingleToNumber(dq, dn) decimal32ToNumber((decimal32 *)(dq), dn)
|
||||
#define decSingleFromNumber(dq, dn, set) decimal32FromNumber((decimal32 *)(dq), dn, set)
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,553 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal 128-bit format module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2008. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises the routines for decimal128 format numbers. */
|
||||
/* Conversions are supplied to and from decNumber and String. */
|
||||
/* */
|
||||
/* This is used when decNumber provides operations, either for all */
|
||||
/* operations or as a proxy between decNumber and decSingle. */
|
||||
/* */
|
||||
/* Error handling is the same as decNumber (qv.). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
#include <string.h> // [for memset/memcpy]
|
||||
#include <stdio.h> // [for printf]
|
||||
|
||||
#define DECNUMDIGITS 34 // make decNumbers with space for 34
|
||||
#include "decNumber.h" // base number library
|
||||
#include "decNumberLocal.h" // decNumber local types, etc.
|
||||
#include "decimal128.h" // our primary include
|
||||
|
||||
/* Utility routines and tables [in decimal64.c] */
|
||||
// DPD2BIN and the reverse are renamed to prevent link-time conflict
|
||||
// if decQuad is also built in the same executable
|
||||
#define DPD2BIN DPD2BINx
|
||||
#define BIN2DPD BIN2DPDx
|
||||
extern const uInt COMBEXP[32], COMBMSD[32];
|
||||
extern const uShort DPD2BIN[1024];
|
||||
extern const uShort BIN2DPD[1000]; // [not used]
|
||||
extern const uByte BIN2CHAR[4001];
|
||||
|
||||
extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
|
||||
extern void decDigitsToDPD(const decNumber *, uInt *, Int);
|
||||
|
||||
#if DECTRACE || DECCHECK
|
||||
void decimal128Show(const decimal128 *); // for debug
|
||||
extern void decNumberShow(const decNumber *); // ..
|
||||
#endif
|
||||
|
||||
/* Useful macro */
|
||||
// Clear a structure (e.g., a decNumber)
|
||||
#define DEC_clear(d) memset(d, 0, sizeof(*d))
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal128FromNumber -- convert decNumber to decimal128 */
|
||||
/* */
|
||||
/* ds is the target decimal128 */
|
||||
/* dn is the source number (assumed valid) */
|
||||
/* set is the context, used only for reporting errors */
|
||||
/* */
|
||||
/* The set argument is used only for status reporting and for the */
|
||||
/* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/
|
||||
/* digits or an overflow is detected). If the exponent is out of the */
|
||||
/* valid range then Overflow or Underflow will be raised. */
|
||||
/* After Underflow a subnormal result is possible. */
|
||||
/* */
|
||||
/* DEC_Clamped is set if the number has to be 'folded down' to fit, */
|
||||
/* by reducing its exponent and multiplying the coefficient by a */
|
||||
/* power of ten, or if the exponent on a zero had to be clamped. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal128 * decimal128FromNumber(decimal128 *d128, const decNumber *dn,
|
||||
decContext *set) {
|
||||
uInt status=0; // status accumulator
|
||||
Int ae; // adjusted exponent
|
||||
decNumber dw; // work
|
||||
decContext dc; // ..
|
||||
uInt comb, exp; // ..
|
||||
uInt uiwork; // for macros
|
||||
uInt targar[4]={0,0,0,0}; // target 128-bit
|
||||
#define targhi targar[3] // name the word with the sign
|
||||
#define targmh targar[2] // name the words
|
||||
#define targml targar[1] // ..
|
||||
#define targlo targar[0] // ..
|
||||
|
||||
// If the number has too many digits, or the exponent could be
|
||||
// out of range then reduce the number under the appropriate
|
||||
// constraints. This could push the number to Infinity or zero,
|
||||
// so this check and rounding must be done before generating the
|
||||
// decimal128]
|
||||
ae=dn->exponent+dn->digits-1; // [0 if special]
|
||||
if (dn->digits>DECIMAL128_Pmax // too many digits
|
||||
|| ae>DECIMAL128_Emax // likely overflow
|
||||
|| ae<DECIMAL128_Emin) { // likely underflow
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL128); // [no traps]
|
||||
dc.round=set->round; // use supplied rounding
|
||||
decNumberPlus(&dw, dn, &dc); // (round and check)
|
||||
// [this changes -0 to 0, so enforce the sign...]
|
||||
dw.bits|=dn->bits&DECNEG;
|
||||
status=dc.status; // save status
|
||||
dn=&dw; // use the work number
|
||||
} // maybe out of range
|
||||
|
||||
if (dn->bits&DECSPECIAL) { // a special value
|
||||
if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
|
||||
else { // sNaN or qNaN
|
||||
if ((*dn->lsu!=0 || dn->digits>1) // non-zero coefficient
|
||||
&& (dn->digits<DECIMAL128_Pmax)) { // coefficient fits
|
||||
decDigitsToDPD(dn, targar, 0);
|
||||
}
|
||||
if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
|
||||
else targhi|=DECIMAL_sNaN<<24;
|
||||
} // a NaN
|
||||
} // special
|
||||
|
||||
else { // is finite
|
||||
if (decNumberIsZero(dn)) { // is a zero
|
||||
// set and clamp exponent
|
||||
if (dn->exponent<-DECIMAL128_Bias) {
|
||||
exp=0; // low clamp
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
else {
|
||||
exp=dn->exponent+DECIMAL128_Bias; // bias exponent
|
||||
if (exp>DECIMAL128_Ehigh) { // top clamp
|
||||
exp=DECIMAL128_Ehigh;
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
}
|
||||
comb=(exp>>9) & 0x18; // msd=0, exp top 2 bits ..
|
||||
}
|
||||
else { // non-zero finite number
|
||||
uInt msd; // work
|
||||
Int pad=0; // coefficient pad digits
|
||||
|
||||
// the dn is known to fit, but it may need to be padded
|
||||
exp=(uInt)(dn->exponent+DECIMAL128_Bias); // bias exponent
|
||||
if (exp>DECIMAL128_Ehigh) { // fold-down case
|
||||
pad=exp-DECIMAL128_Ehigh;
|
||||
exp=DECIMAL128_Ehigh; // [to maximum]
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
|
||||
// [fastpath for common case is not a win, here]
|
||||
decDigitsToDPD(dn, targar, pad);
|
||||
// save and clear the top digit
|
||||
msd=targhi>>14;
|
||||
targhi&=0x00003fff;
|
||||
|
||||
// create the combination field
|
||||
if (msd>=8) comb=0x18 | ((exp>>11) & 0x06) | (msd & 0x01);
|
||||
else comb=((exp>>9) & 0x18) | msd;
|
||||
}
|
||||
targhi|=comb<<26; // add combination field ..
|
||||
targhi|=(exp&0xfff)<<14; // .. and exponent continuation
|
||||
} // finite
|
||||
|
||||
if (dn->bits&DECNEG) targhi|=0x80000000; // add sign bit
|
||||
|
||||
// now write to storage; this is endian
|
||||
if (DECLITEND) {
|
||||
// lo -> hi
|
||||
UBFROMUI(d128->bytes, targlo);
|
||||
UBFROMUI(d128->bytes+4, targml);
|
||||
UBFROMUI(d128->bytes+8, targmh);
|
||||
UBFROMUI(d128->bytes+12, targhi);
|
||||
}
|
||||
else {
|
||||
// hi -> lo
|
||||
UBFROMUI(d128->bytes, targhi);
|
||||
UBFROMUI(d128->bytes+4, targmh);
|
||||
UBFROMUI(d128->bytes+8, targml);
|
||||
UBFROMUI(d128->bytes+12, targlo);
|
||||
}
|
||||
|
||||
if (status!=0) decContextSetStatus(set, status); // pass on status
|
||||
// decimal128Show(d128);
|
||||
return d128;
|
||||
} // decimal128FromNumber
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal128ToNumber -- convert decimal128 to decNumber */
|
||||
/* d128 is the source decimal128 */
|
||||
/* dn is the target number, with appropriate space */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decNumber * decimal128ToNumber(const decimal128 *d128, decNumber *dn) {
|
||||
uInt msd; // coefficient MSD
|
||||
uInt exp; // exponent top two bits
|
||||
uInt comb; // combination field
|
||||
Int need; // work
|
||||
uInt uiwork; // for macros
|
||||
uInt sourar[4]; // source 128-bit
|
||||
#define sourhi sourar[3] // name the word with the sign
|
||||
#define sourmh sourar[2] // and the mid-high word
|
||||
#define sourml sourar[1] // and the mod-low word
|
||||
#define sourlo sourar[0] // and the lowest word
|
||||
|
||||
// load source from storage; this is endian
|
||||
if (DECLITEND) {
|
||||
sourlo=UBTOUI(d128->bytes ); // directly load the low int
|
||||
sourml=UBTOUI(d128->bytes+4 ); // then the mid-low
|
||||
sourmh=UBTOUI(d128->bytes+8 ); // then the mid-high
|
||||
sourhi=UBTOUI(d128->bytes+12); // then the high int
|
||||
}
|
||||
else {
|
||||
sourhi=UBTOUI(d128->bytes ); // directly load the high int
|
||||
sourmh=UBTOUI(d128->bytes+4 ); // then the mid-high
|
||||
sourml=UBTOUI(d128->bytes+8 ); // then the mid-low
|
||||
sourlo=UBTOUI(d128->bytes+12); // then the low int
|
||||
}
|
||||
|
||||
comb=(sourhi>>26)&0x1f; // combination field
|
||||
|
||||
decNumberZero(dn); // clean number
|
||||
if (sourhi&0x80000000) dn->bits=DECNEG; // set sign if negative
|
||||
|
||||
msd=COMBMSD[comb]; // decode the combination field
|
||||
exp=COMBEXP[comb]; // ..
|
||||
|
||||
if (exp==3) { // is a special
|
||||
if (msd==0) {
|
||||
dn->bits|=DECINF;
|
||||
return dn; // no coefficient needed
|
||||
}
|
||||
else if (sourhi&0x02000000) dn->bits|=DECSNAN;
|
||||
else dn->bits|=DECNAN;
|
||||
msd=0; // no top digit
|
||||
}
|
||||
else { // is a finite number
|
||||
dn->exponent=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; // unbiased
|
||||
}
|
||||
|
||||
// get the coefficient
|
||||
sourhi&=0x00003fff; // clean coefficient continuation
|
||||
if (msd) { // non-zero msd
|
||||
sourhi|=msd<<14; // prefix to coefficient
|
||||
need=12; // process 12 declets
|
||||
}
|
||||
else { // msd=0
|
||||
if (sourhi) need=11; // declets to process
|
||||
else if (sourmh) need=10;
|
||||
else if (sourml) need=7;
|
||||
else if (sourlo) need=4;
|
||||
else return dn; // easy: coefficient is 0
|
||||
} //msd=0
|
||||
|
||||
decDigitsFromDPD(dn, sourar, need); // process declets
|
||||
// decNumberShow(dn);
|
||||
return dn;
|
||||
} // decimal128ToNumber
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* to-scientific-string -- conversion to numeric string */
|
||||
/* to-engineering-string -- conversion to numeric string */
|
||||
/* */
|
||||
/* decimal128ToString(d128, string); */
|
||||
/* decimal128ToEngString(d128, string); */
|
||||
/* */
|
||||
/* d128 is the decimal128 format number to convert */
|
||||
/* string is the string where the result will be laid out */
|
||||
/* */
|
||||
/* string must be at least 24 characters */
|
||||
/* */
|
||||
/* No error is possible, and no status can be set. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
char * decimal128ToEngString(const decimal128 *d128, char *string){
|
||||
decNumber dn; // work
|
||||
decimal128ToNumber(d128, &dn);
|
||||
decNumberToEngString(&dn, string);
|
||||
return string;
|
||||
} // decimal128ToEngString
|
||||
|
||||
char * decimal128ToString(const decimal128 *d128, char *string){
|
||||
uInt msd; // coefficient MSD
|
||||
Int exp; // exponent top two bits or full
|
||||
uInt comb; // combination field
|
||||
char *cstart; // coefficient start
|
||||
char *c; // output pointer in string
|
||||
const uByte *u; // work
|
||||
char *s, *t; // .. (source, target)
|
||||
Int dpd; // ..
|
||||
Int pre, e; // ..
|
||||
uInt uiwork; // for macros
|
||||
|
||||
uInt sourar[4]; // source 128-bit
|
||||
#define sourhi sourar[3] // name the word with the sign
|
||||
#define sourmh sourar[2] // and the mid-high word
|
||||
#define sourml sourar[1] // and the mod-low word
|
||||
#define sourlo sourar[0] // and the lowest word
|
||||
|
||||
// load source from storage; this is endian
|
||||
if (DECLITEND) {
|
||||
sourlo=UBTOUI(d128->bytes ); // directly load the low int
|
||||
sourml=UBTOUI(d128->bytes+4 ); // then the mid-low
|
||||
sourmh=UBTOUI(d128->bytes+8 ); // then the mid-high
|
||||
sourhi=UBTOUI(d128->bytes+12); // then the high int
|
||||
}
|
||||
else {
|
||||
sourhi=UBTOUI(d128->bytes ); // directly load the high int
|
||||
sourmh=UBTOUI(d128->bytes+4 ); // then the mid-high
|
||||
sourml=UBTOUI(d128->bytes+8 ); // then the mid-low
|
||||
sourlo=UBTOUI(d128->bytes+12); // then the low int
|
||||
}
|
||||
|
||||
c=string; // where result will go
|
||||
if (((Int)sourhi)<0) *c++='-'; // handle sign
|
||||
|
||||
comb=(sourhi>>26)&0x1f; // combination field
|
||||
msd=COMBMSD[comb]; // decode the combination field
|
||||
exp=COMBEXP[comb]; // ..
|
||||
|
||||
if (exp==3) {
|
||||
if (msd==0) { // infinity
|
||||
strcpy(c, "Inf");
|
||||
strcpy(c+3, "inity");
|
||||
return string; // easy
|
||||
}
|
||||
if (sourhi&0x02000000) *c++='s'; // sNaN
|
||||
strcpy(c, "NaN"); // complete word
|
||||
c+=3; // step past
|
||||
if (sourlo==0 && sourml==0 && sourmh==0
|
||||
&& (sourhi&0x0003ffff)==0) return string; // zero payload
|
||||
// otherwise drop through to add integer; set correct exp
|
||||
exp=0; msd=0; // setup for following code
|
||||
}
|
||||
else exp=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; // unbiased
|
||||
|
||||
// convert 34 digits of significand to characters
|
||||
cstart=c; // save start of coefficient
|
||||
if (msd) *c++='0'+(char)msd; // non-zero most significant digit
|
||||
|
||||
// Now decode the declets. After extracting each one, it is
|
||||
// decoded to binary and then to a 4-char sequence by table lookup;
|
||||
// the 4-chars are a 1-char length (significant digits, except 000
|
||||
// has length 0). This allows us to left-align the first declet
|
||||
// with non-zero content, then remaining ones are full 3-char
|
||||
// length. We use fixed-length memcpys because variable-length
|
||||
// causes a subroutine call in GCC. (These are length 4 for speed
|
||||
// and are safe because the array has an extra terminator byte.)
|
||||
#define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; \
|
||||
if (c!=cstart) {memcpy(c, u+1, 4); c+=3;} \
|
||||
else if (*u) {memcpy(c, u+4-*u, 4); c+=*u;}
|
||||
dpd=(sourhi>>4)&0x3ff; // declet 1
|
||||
dpd2char;
|
||||
dpd=((sourhi&0xf)<<6) | (sourmh>>26); // declet 2
|
||||
dpd2char;
|
||||
dpd=(sourmh>>16)&0x3ff; // declet 3
|
||||
dpd2char;
|
||||
dpd=(sourmh>>6)&0x3ff; // declet 4
|
||||
dpd2char;
|
||||
dpd=((sourmh&0x3f)<<4) | (sourml>>28); // declet 5
|
||||
dpd2char;
|
||||
dpd=(sourml>>18)&0x3ff; // declet 6
|
||||
dpd2char;
|
||||
dpd=(sourml>>8)&0x3ff; // declet 7
|
||||
dpd2char;
|
||||
dpd=((sourml&0xff)<<2) | (sourlo>>30); // declet 8
|
||||
dpd2char;
|
||||
dpd=(sourlo>>20)&0x3ff; // declet 9
|
||||
dpd2char;
|
||||
dpd=(sourlo>>10)&0x3ff; // declet 10
|
||||
dpd2char;
|
||||
dpd=(sourlo)&0x3ff; // declet 11
|
||||
dpd2char;
|
||||
|
||||
if (c==cstart) *c++='0'; // all zeros -- make 0
|
||||
|
||||
if (exp==0) { // integer or NaN case -- easy
|
||||
*c='\0'; // terminate
|
||||
return string;
|
||||
}
|
||||
|
||||
/* non-0 exponent */
|
||||
e=0; // assume no E
|
||||
pre=c-cstart+exp;
|
||||
// [here, pre-exp is the digits count (==1 for zero)]
|
||||
if (exp>0 || pre<-5) { // need exponential form
|
||||
e=pre-1; // calculate E value
|
||||
pre=1; // assume one digit before '.'
|
||||
} // exponential form
|
||||
|
||||
/* modify the coefficient, adding 0s, '.', and E+nn as needed */
|
||||
s=c-1; // source (LSD)
|
||||
if (pre>0) { // ddd.ddd (plain), perhaps with E
|
||||
char *dotat=cstart+pre;
|
||||
if (dotat<c) { // if embedded dot needed...
|
||||
t=c; // target
|
||||
for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
|
||||
*t='.'; // insert the dot
|
||||
c++; // length increased by one
|
||||
}
|
||||
|
||||
// finally add the E-part, if needed; it will never be 0, and has
|
||||
// a maximum length of 4 digits
|
||||
if (e!=0) {
|
||||
*c++='E'; // starts with E
|
||||
*c++='+'; // assume positive
|
||||
if (e<0) {
|
||||
*(c-1)='-'; // oops, need '-'
|
||||
e=-e; // uInt, please
|
||||
}
|
||||
if (e<1000) { // 3 (or fewer) digits case
|
||||
u=&BIN2CHAR[e*4]; // -> length byte
|
||||
memcpy(c, u+4-*u, 4); // copy fixed 4 characters [is safe]
|
||||
c+=*u; // bump pointer appropriately
|
||||
}
|
||||
else { // 4-digits
|
||||
Int thou=((e>>3)*1049)>>17; // e/1000
|
||||
Int rem=e-(1000*thou); // e%1000
|
||||
*c++='0'+(char)thou;
|
||||
u=&BIN2CHAR[rem*4]; // -> length byte
|
||||
memcpy(c, u+1, 4); // copy fixed 3+1 characters [is safe]
|
||||
c+=3; // bump pointer, always 3 digits
|
||||
}
|
||||
}
|
||||
*c='\0'; // add terminator
|
||||
//printf("res %s\n", string);
|
||||
return string;
|
||||
} // pre>0
|
||||
|
||||
/* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
|
||||
t=c+1-pre;
|
||||
*(t+1)='\0'; // can add terminator now
|
||||
for (; s>=cstart; s--, t--) *t=*s; // shift whole coefficient right
|
||||
c=cstart;
|
||||
*c++='0'; // always starts with 0.
|
||||
*c++='.';
|
||||
for (; pre<0; pre++) *c++='0'; // add any 0's after '.'
|
||||
//printf("res %s\n", string);
|
||||
return string;
|
||||
} // decimal128ToString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* to-number -- conversion from numeric string */
|
||||
/* */
|
||||
/* decimal128FromString(result, string, set); */
|
||||
/* */
|
||||
/* result is the decimal128 format number which gets the result of */
|
||||
/* the conversion */
|
||||
/* *string is the character string which should contain a valid */
|
||||
/* number (which may be a special value) */
|
||||
/* set is the context */
|
||||
/* */
|
||||
/* The context is supplied to this routine is used for error handling */
|
||||
/* (setting of status and traps) and for the rounding mode, only. */
|
||||
/* If an error occurs, the result will be a valid decimal128 NaN. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal128 * decimal128FromString(decimal128 *result, const char *string,
|
||||
decContext *set) {
|
||||
decContext dc; // work
|
||||
decNumber dn; // ..
|
||||
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL128); // no traps, please
|
||||
dc.round=set->round; // use supplied rounding
|
||||
|
||||
decNumberFromString(&dn, string, &dc); // will round if needed
|
||||
decimal128FromNumber(result, &dn, &dc);
|
||||
if (dc.status!=0) { // something happened
|
||||
decContextSetStatus(set, dc.status); // .. pass it on
|
||||
}
|
||||
return result;
|
||||
} // decimal128FromString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal128IsCanonical -- test whether encoding is canonical */
|
||||
/* d128 is the source decimal128 */
|
||||
/* returns 1 if the encoding of d128 is canonical, 0 otherwise */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uInt decimal128IsCanonical(const decimal128 *d128) {
|
||||
decNumber dn; // work
|
||||
decimal128 canon; // ..
|
||||
decContext dc; // ..
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL128);
|
||||
decimal128ToNumber(d128, &dn);
|
||||
decimal128FromNumber(&canon, &dn, &dc);// canon will now be canonical
|
||||
return memcmp(d128, &canon, DECIMAL128_Bytes)==0;
|
||||
} // decimal128IsCanonical
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal128Canonical -- copy an encoding, ensuring it is canonical */
|
||||
/* d128 is the source decimal128 */
|
||||
/* result is the target (may be the same decimal128) */
|
||||
/* returns result */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal128 * decimal128Canonical(decimal128 *result, const decimal128 *d128) {
|
||||
decNumber dn; // work
|
||||
decContext dc; // ..
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL128);
|
||||
decimal128ToNumber(d128, &dn);
|
||||
decimal128FromNumber(result, &dn, &dc);// result will now be canonical
|
||||
return result;
|
||||
} // decimal128Canonical
|
||||
|
||||
#if DECTRACE || DECCHECK
|
||||
/* Macros for accessing decimal128 fields. These assume the argument
|
||||
is a reference (pointer) to the decimal128 structure, and the
|
||||
decimal128 is in network byte order (big-endian) */
|
||||
// Get sign
|
||||
#define decimal128Sign(d) ((unsigned)(d)->bytes[0]>>7)
|
||||
|
||||
// Get combination field
|
||||
#define decimal128Comb(d) (((d)->bytes[0] & 0x7c)>>2)
|
||||
|
||||
// Get exponent continuation [does not remove bias]
|
||||
#define decimal128ExpCon(d) ((((d)->bytes[0] & 0x03)<<10) \
|
||||
| ((unsigned)(d)->bytes[1]<<2) \
|
||||
| ((unsigned)(d)->bytes[2]>>6))
|
||||
|
||||
// Set sign [this assumes sign previously 0]
|
||||
#define decimal128SetSign(d, b) { \
|
||||
(d)->bytes[0]|=((unsigned)(b)<<7);}
|
||||
|
||||
// Set exponent continuation [does not apply bias]
|
||||
// This assumes range has been checked and exponent previously 0;
|
||||
// type of exponent must be unsigned
|
||||
#define decimal128SetExpCon(d, e) { \
|
||||
(d)->bytes[0]|=(uByte)((e)>>10); \
|
||||
(d)->bytes[1] =(uByte)(((e)&0x3fc)>>2); \
|
||||
(d)->bytes[2]|=(uByte)(((e)&0x03)<<6);}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal128Show -- display a decimal128 in hexadecimal [debug aid] */
|
||||
/* d128 -- the number to show */
|
||||
/* ------------------------------------------------------------------ */
|
||||
// Also shows sign/cob/expconfields extracted
|
||||
void decimal128Show(const decimal128 *d128) {
|
||||
char buf[DECIMAL128_Bytes*2+1];
|
||||
Int i, j=0;
|
||||
|
||||
if (DECLITEND) {
|
||||
for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
|
||||
sprintf(&buf[j], "%02x", d128->bytes[15-i]);
|
||||
}
|
||||
printf(" D128> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
|
||||
d128->bytes[15]>>7, (d128->bytes[15]>>2)&0x1f,
|
||||
((d128->bytes[15]&0x3)<<10)|(d128->bytes[14]<<2)|
|
||||
(d128->bytes[13]>>6));
|
||||
}
|
||||
else {
|
||||
for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
|
||||
sprintf(&buf[j], "%02x", d128->bytes[i]);
|
||||
}
|
||||
printf(" D128> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
|
||||
decimal128Sign(d128), decimal128Comb(d128),
|
||||
decimal128ExpCon(d128));
|
||||
}
|
||||
} // decimal128Show
|
||||
#endif
|
||||
@@ -0,0 +1,81 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal 128-bit format module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2005. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECIMAL128)
|
||||
#define DECIMAL128
|
||||
#define DEC128NAME "decimal128" /* Short name */
|
||||
#define DEC128FULLNAME "Decimal 128-bit Number" /* Verbose name */
|
||||
#define DEC128AUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
/* parameters for decimal128s */
|
||||
#define DECIMAL128_Bytes 16 /* length */
|
||||
#define DECIMAL128_Pmax 34 /* maximum precision (digits) */
|
||||
#define DECIMAL128_Emax 6144 /* maximum adjusted exponent */
|
||||
#define DECIMAL128_Emin -6143 /* minimum adjusted exponent */
|
||||
#define DECIMAL128_Bias 6176 /* bias for the exponent */
|
||||
#define DECIMAL128_String 43 /* maximum string length, +1 */
|
||||
#define DECIMAL128_EconL 12 /* exp. continuation length */
|
||||
/* highest biased exponent (Elimit-1) */
|
||||
#define DECIMAL128_Ehigh (DECIMAL128_Emax+DECIMAL128_Bias-DECIMAL128_Pmax+1)
|
||||
|
||||
/* check enough digits, if pre-defined */
|
||||
#if defined(DECNUMDIGITS)
|
||||
#if (DECNUMDIGITS<DECIMAL128_Pmax)
|
||||
#error decimal128.h needs pre-defined DECNUMDIGITS>=34 for safe use
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef DECNUMDIGITS
|
||||
#define DECNUMDIGITS DECIMAL128_Pmax /* size if not already defined*/
|
||||
#endif
|
||||
#ifndef DECNUMBER
|
||||
#include "decNumber.h" /* context and number library */
|
||||
#endif
|
||||
|
||||
/* Decimal 128-bit type, accessible by bytes */
|
||||
typedef struct {
|
||||
uint8_t bytes[DECIMAL128_Bytes]; /* decimal128: 1, 5, 12, 110 bits*/
|
||||
} decimal128;
|
||||
|
||||
/* special values [top byte excluding sign bit; last two bits are */
|
||||
/* don't-care for Infinity on input, last bit don't-care for NaN] */
|
||||
#if !defined(DECIMAL_NaN)
|
||||
#define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */
|
||||
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */
|
||||
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */
|
||||
#endif
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Routines */
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* String conversions */
|
||||
decimal128 * decimal128FromString(decimal128 *, const char *, decContext *);
|
||||
char * decimal128ToString(const decimal128 *, char *);
|
||||
char * decimal128ToEngString(const decimal128 *, char *);
|
||||
|
||||
/* decNumber conversions */
|
||||
decimal128 * decimal128FromNumber(decimal128 *, const decNumber *,
|
||||
decContext *);
|
||||
decNumber * decimal128ToNumber(const decimal128 *, decNumber *);
|
||||
|
||||
/* Format-dependent utilities */
|
||||
uint32_t decimal128IsCanonical(const decimal128 *);
|
||||
decimal128 * decimal128Canonical(decimal128 *, const decimal128 *);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,476 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal 32-bit format module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2008. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises the routines for decimal32 format numbers. */
|
||||
/* Conversions are supplied to and from decNumber and String. */
|
||||
/* */
|
||||
/* This is used when decNumber provides operations, either for all */
|
||||
/* operations or as a proxy between decNumber and decSingle. */
|
||||
/* */
|
||||
/* Error handling is the same as decNumber (qv.). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
#include <string.h> // [for memset/memcpy]
|
||||
#include <stdio.h> // [for printf]
|
||||
|
||||
#define DECNUMDIGITS 7 // make decNumbers with space for 7
|
||||
#include "decNumber.h" // base number library
|
||||
#include "decNumberLocal.h" // decNumber local types, etc.
|
||||
#include "decimal32.h" // our primary include
|
||||
|
||||
/* Utility tables and routines [in decimal64.c] */
|
||||
// DPD2BIN and the reverse are renamed to prevent link-time conflict
|
||||
// if decQuad is also built in the same executable
|
||||
#define DPD2BIN DPD2BINx
|
||||
#define BIN2DPD BIN2DPDx
|
||||
extern const uInt COMBEXP[32], COMBMSD[32];
|
||||
extern const uShort DPD2BIN[1024];
|
||||
extern const uShort BIN2DPD[1000];
|
||||
extern const uByte BIN2CHAR[4001];
|
||||
|
||||
extern void decDigitsToDPD(const decNumber *, uInt *, Int);
|
||||
extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
|
||||
|
||||
#if DECTRACE || DECCHECK
|
||||
void decimal32Show(const decimal32 *); // for debug
|
||||
extern void decNumberShow(const decNumber *); // ..
|
||||
#endif
|
||||
|
||||
/* Useful macro */
|
||||
// Clear a structure (e.g., a decNumber)
|
||||
#define DEC_clear(d) memset(d, 0, sizeof(*d))
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal32FromNumber -- convert decNumber to decimal32 */
|
||||
/* */
|
||||
/* ds is the target decimal32 */
|
||||
/* dn is the source number (assumed valid) */
|
||||
/* set is the context, used only for reporting errors */
|
||||
/* */
|
||||
/* The set argument is used only for status reporting and for the */
|
||||
/* rounding mode (used if the coefficient is more than DECIMAL32_Pmax */
|
||||
/* digits or an overflow is detected). If the exponent is out of the */
|
||||
/* valid range then Overflow or Underflow will be raised. */
|
||||
/* After Underflow a subnormal result is possible. */
|
||||
/* */
|
||||
/* DEC_Clamped is set if the number has to be 'folded down' to fit, */
|
||||
/* by reducing its exponent and multiplying the coefficient by a */
|
||||
/* power of ten, or if the exponent on a zero had to be clamped. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal32 * decimal32FromNumber(decimal32 *d32, const decNumber *dn,
|
||||
decContext *set) {
|
||||
uInt status=0; // status accumulator
|
||||
Int ae; // adjusted exponent
|
||||
decNumber dw; // work
|
||||
decContext dc; // ..
|
||||
uInt comb, exp; // ..
|
||||
uInt uiwork; // for macros
|
||||
uInt targ=0; // target 32-bit
|
||||
|
||||
// If the number has too many digits, or the exponent could be
|
||||
// out of range then reduce the number under the appropriate
|
||||
// constraints. This could push the number to Infinity or zero,
|
||||
// so this check and rounding must be done before generating the
|
||||
// decimal32]
|
||||
ae=dn->exponent+dn->digits-1; // [0 if special]
|
||||
if (dn->digits>DECIMAL32_Pmax // too many digits
|
||||
|| ae>DECIMAL32_Emax // likely overflow
|
||||
|| ae<DECIMAL32_Emin) { // likely underflow
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL32); // [no traps]
|
||||
dc.round=set->round; // use supplied rounding
|
||||
decNumberPlus(&dw, dn, &dc); // (round and check)
|
||||
// [this changes -0 to 0, so enforce the sign...]
|
||||
dw.bits|=dn->bits&DECNEG;
|
||||
status=dc.status; // save status
|
||||
dn=&dw; // use the work number
|
||||
} // maybe out of range
|
||||
|
||||
if (dn->bits&DECSPECIAL) { // a special value
|
||||
if (dn->bits&DECINF) targ=DECIMAL_Inf<<24;
|
||||
else { // sNaN or qNaN
|
||||
if ((*dn->lsu!=0 || dn->digits>1) // non-zero coefficient
|
||||
&& (dn->digits<DECIMAL32_Pmax)) { // coefficient fits
|
||||
decDigitsToDPD(dn, &targ, 0);
|
||||
}
|
||||
if (dn->bits&DECNAN) targ|=DECIMAL_NaN<<24;
|
||||
else targ|=DECIMAL_sNaN<<24;
|
||||
} // a NaN
|
||||
} // special
|
||||
|
||||
else { // is finite
|
||||
if (decNumberIsZero(dn)) { // is a zero
|
||||
// set and clamp exponent
|
||||
if (dn->exponent<-DECIMAL32_Bias) {
|
||||
exp=0; // low clamp
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
else {
|
||||
exp=dn->exponent+DECIMAL32_Bias; // bias exponent
|
||||
if (exp>DECIMAL32_Ehigh) { // top clamp
|
||||
exp=DECIMAL32_Ehigh;
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
}
|
||||
comb=(exp>>3) & 0x18; // msd=0, exp top 2 bits ..
|
||||
}
|
||||
else { // non-zero finite number
|
||||
uInt msd; // work
|
||||
Int pad=0; // coefficient pad digits
|
||||
|
||||
// the dn is known to fit, but it may need to be padded
|
||||
exp=(uInt)(dn->exponent+DECIMAL32_Bias); // bias exponent
|
||||
if (exp>DECIMAL32_Ehigh) { // fold-down case
|
||||
pad=exp-DECIMAL32_Ehigh;
|
||||
exp=DECIMAL32_Ehigh; // [to maximum]
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
|
||||
// fastpath common case
|
||||
if (DECDPUN==3 && pad==0) {
|
||||
targ=BIN2DPD[dn->lsu[0]];
|
||||
if (dn->digits>3) targ|=(uInt)(BIN2DPD[dn->lsu[1]])<<10;
|
||||
msd=(dn->digits==7 ? dn->lsu[2] : 0);
|
||||
}
|
||||
else { // general case
|
||||
decDigitsToDPD(dn, &targ, pad);
|
||||
// save and clear the top digit
|
||||
msd=targ>>20;
|
||||
targ&=0x000fffff;
|
||||
}
|
||||
|
||||
// create the combination field
|
||||
if (msd>=8) comb=0x18 | ((exp>>5) & 0x06) | (msd & 0x01);
|
||||
else comb=((exp>>3) & 0x18) | msd;
|
||||
}
|
||||
targ|=comb<<26; // add combination field ..
|
||||
targ|=(exp&0x3f)<<20; // .. and exponent continuation
|
||||
} // finite
|
||||
|
||||
if (dn->bits&DECNEG) targ|=0x80000000; // add sign bit
|
||||
|
||||
// now write to storage; this is endian
|
||||
UBFROMUI(d32->bytes, targ); // directly store the int
|
||||
|
||||
if (status!=0) decContextSetStatus(set, status); // pass on status
|
||||
// decimal32Show(d32);
|
||||
return d32;
|
||||
} // decimal32FromNumber
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal32ToNumber -- convert decimal32 to decNumber */
|
||||
/* d32 is the source decimal32 */
|
||||
/* dn is the target number, with appropriate space */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decNumber * decimal32ToNumber(const decimal32 *d32, decNumber *dn) {
|
||||
uInt msd; // coefficient MSD
|
||||
uInt exp; // exponent top two bits
|
||||
uInt comb; // combination field
|
||||
uInt sour; // source 32-bit
|
||||
uInt uiwork; // for macros
|
||||
|
||||
// load source from storage; this is endian
|
||||
sour=UBTOUI(d32->bytes); // directly load the int
|
||||
|
||||
comb=(sour>>26)&0x1f; // combination field
|
||||
|
||||
decNumberZero(dn); // clean number
|
||||
if (sour&0x80000000) dn->bits=DECNEG; // set sign if negative
|
||||
|
||||
msd=COMBMSD[comb]; // decode the combination field
|
||||
exp=COMBEXP[comb]; // ..
|
||||
|
||||
if (exp==3) { // is a special
|
||||
if (msd==0) {
|
||||
dn->bits|=DECINF;
|
||||
return dn; // no coefficient needed
|
||||
}
|
||||
else if (sour&0x02000000) dn->bits|=DECSNAN;
|
||||
else dn->bits|=DECNAN;
|
||||
msd=0; // no top digit
|
||||
}
|
||||
else { // is a finite number
|
||||
dn->exponent=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; // unbiased
|
||||
}
|
||||
|
||||
// get the coefficient
|
||||
sour&=0x000fffff; // clean coefficient continuation
|
||||
if (msd) { // non-zero msd
|
||||
sour|=msd<<20; // prefix to coefficient
|
||||
decDigitsFromDPD(dn, &sour, 3); // process 3 declets
|
||||
return dn;
|
||||
}
|
||||
// msd=0
|
||||
if (!sour) return dn; // easy: coefficient is 0
|
||||
if (sour&0x000ffc00) // need 2 declets?
|
||||
decDigitsFromDPD(dn, &sour, 2); // process 2 declets
|
||||
else
|
||||
decDigitsFromDPD(dn, &sour, 1); // process 1 declet
|
||||
return dn;
|
||||
} // decimal32ToNumber
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* to-scientific-string -- conversion to numeric string */
|
||||
/* to-engineering-string -- conversion to numeric string */
|
||||
/* */
|
||||
/* decimal32ToString(d32, string); */
|
||||
/* decimal32ToEngString(d32, string); */
|
||||
/* */
|
||||
/* d32 is the decimal32 format number to convert */
|
||||
/* string is the string where the result will be laid out */
|
||||
/* */
|
||||
/* string must be at least 24 characters */
|
||||
/* */
|
||||
/* No error is possible, and no status can be set. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
char * decimal32ToEngString(const decimal32 *d32, char *string){
|
||||
decNumber dn; // work
|
||||
decimal32ToNumber(d32, &dn);
|
||||
decNumberToEngString(&dn, string);
|
||||
return string;
|
||||
} // decimal32ToEngString
|
||||
|
||||
char * decimal32ToString(const decimal32 *d32, char *string){
|
||||
uInt msd; // coefficient MSD
|
||||
Int exp; // exponent top two bits or full
|
||||
uInt comb; // combination field
|
||||
char *cstart; // coefficient start
|
||||
char *c; // output pointer in string
|
||||
const uByte *u; // work
|
||||
char *s, *t; // .. (source, target)
|
||||
Int dpd; // ..
|
||||
Int pre, e; // ..
|
||||
uInt uiwork; // for macros
|
||||
uInt sour; // source 32-bit
|
||||
|
||||
// load source from storage; this is endian
|
||||
sour=UBTOUI(d32->bytes); // directly load the int
|
||||
|
||||
c=string; // where result will go
|
||||
if (((Int)sour)<0) *c++='-'; // handle sign
|
||||
|
||||
comb=(sour>>26)&0x1f; // combination field
|
||||
msd=COMBMSD[comb]; // decode the combination field
|
||||
exp=COMBEXP[comb]; // ..
|
||||
|
||||
if (exp==3) {
|
||||
if (msd==0) { // infinity
|
||||
strcpy(c, "Inf");
|
||||
strcpy(c+3, "inity");
|
||||
return string; // easy
|
||||
}
|
||||
if (sour&0x02000000) *c++='s'; // sNaN
|
||||
strcpy(c, "NaN"); // complete word
|
||||
c+=3; // step past
|
||||
if ((sour&0x000fffff)==0) return string; // zero payload
|
||||
// otherwise drop through to add integer; set correct exp
|
||||
exp=0; msd=0; // setup for following code
|
||||
}
|
||||
else exp=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; // unbiased
|
||||
|
||||
// convert 7 digits of significand to characters
|
||||
cstart=c; // save start of coefficient
|
||||
if (msd) *c++='0'+(char)msd; // non-zero most significant digit
|
||||
|
||||
// Now decode the declets. After extracting each one, it is
|
||||
// decoded to binary and then to a 4-char sequence by table lookup;
|
||||
// the 4-chars are a 1-char length (significant digits, except 000
|
||||
// has length 0). This allows us to left-align the first declet
|
||||
// with non-zero content, then remaining ones are full 3-char
|
||||
// length. We use fixed-length memcpys because variable-length
|
||||
// causes a subroutine call in GCC. (These are length 4 for speed
|
||||
// and are safe because the array has an extra terminator byte.)
|
||||
#define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; \
|
||||
if (c!=cstart) {memcpy(c, u+1, 4); c+=3;} \
|
||||
else if (*u) {memcpy(c, u+4-*u, 4); c+=*u;}
|
||||
|
||||
dpd=(sour>>10)&0x3ff; // declet 1
|
||||
dpd2char;
|
||||
dpd=(sour)&0x3ff; // declet 2
|
||||
dpd2char;
|
||||
|
||||
if (c==cstart) *c++='0'; // all zeros -- make 0
|
||||
|
||||
if (exp==0) { // integer or NaN case -- easy
|
||||
*c='\0'; // terminate
|
||||
return string;
|
||||
}
|
||||
|
||||
/* non-0 exponent */
|
||||
e=0; // assume no E
|
||||
pre=c-cstart+exp;
|
||||
// [here, pre-exp is the digits count (==1 for zero)]
|
||||
if (exp>0 || pre<-5) { // need exponential form
|
||||
e=pre-1; // calculate E value
|
||||
pre=1; // assume one digit before '.'
|
||||
} // exponential form
|
||||
|
||||
/* modify the coefficient, adding 0s, '.', and E+nn as needed */
|
||||
s=c-1; // source (LSD)
|
||||
if (pre>0) { // ddd.ddd (plain), perhaps with E
|
||||
char *dotat=cstart+pre;
|
||||
if (dotat<c) { // if embedded dot needed...
|
||||
t=c; // target
|
||||
for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
|
||||
*t='.'; // insert the dot
|
||||
c++; // length increased by one
|
||||
}
|
||||
|
||||
// finally add the E-part, if needed; it will never be 0, and has
|
||||
// a maximum length of 3 digits (E-101 case)
|
||||
if (e!=0) {
|
||||
*c++='E'; // starts with E
|
||||
*c++='+'; // assume positive
|
||||
if (e<0) {
|
||||
*(c-1)='-'; // oops, need '-'
|
||||
e=-e; // uInt, please
|
||||
}
|
||||
u=&BIN2CHAR[e*4]; // -> length byte
|
||||
memcpy(c, u+4-*u, 4); // copy fixed 4 characters [is safe]
|
||||
c+=*u; // bump pointer appropriately
|
||||
}
|
||||
*c='\0'; // add terminator
|
||||
//printf("res %s\n", string);
|
||||
return string;
|
||||
} // pre>0
|
||||
|
||||
/* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
|
||||
t=c+1-pre;
|
||||
*(t+1)='\0'; // can add terminator now
|
||||
for (; s>=cstart; s--, t--) *t=*s; // shift whole coefficient right
|
||||
c=cstart;
|
||||
*c++='0'; // always starts with 0.
|
||||
*c++='.';
|
||||
for (; pre<0; pre++) *c++='0'; // add any 0's after '.'
|
||||
//printf("res %s\n", string);
|
||||
return string;
|
||||
} // decimal32ToString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* to-number -- conversion from numeric string */
|
||||
/* */
|
||||
/* decimal32FromString(result, string, set); */
|
||||
/* */
|
||||
/* result is the decimal32 format number which gets the result of */
|
||||
/* the conversion */
|
||||
/* *string is the character string which should contain a valid */
|
||||
/* number (which may be a special value) */
|
||||
/* set is the context */
|
||||
/* */
|
||||
/* The context is supplied to this routine is used for error handling */
|
||||
/* (setting of status and traps) and for the rounding mode, only. */
|
||||
/* If an error occurs, the result will be a valid decimal32 NaN. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal32 * decimal32FromString(decimal32 *result, const char *string,
|
||||
decContext *set) {
|
||||
decContext dc; // work
|
||||
decNumber dn; // ..
|
||||
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL32); // no traps, please
|
||||
dc.round=set->round; // use supplied rounding
|
||||
|
||||
decNumberFromString(&dn, string, &dc); // will round if needed
|
||||
decimal32FromNumber(result, &dn, &dc);
|
||||
if (dc.status!=0) { // something happened
|
||||
decContextSetStatus(set, dc.status); // .. pass it on
|
||||
}
|
||||
return result;
|
||||
} // decimal32FromString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal32IsCanonical -- test whether encoding is canonical */
|
||||
/* d32 is the source decimal32 */
|
||||
/* returns 1 if the encoding of d32 is canonical, 0 otherwise */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uInt decimal32IsCanonical(const decimal32 *d32) {
|
||||
decNumber dn; // work
|
||||
decimal32 canon; // ..
|
||||
decContext dc; // ..
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL32);
|
||||
decimal32ToNumber(d32, &dn);
|
||||
decimal32FromNumber(&canon, &dn, &dc);// canon will now be canonical
|
||||
return memcmp(d32, &canon, DECIMAL32_Bytes)==0;
|
||||
} // decimal32IsCanonical
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal32Canonical -- copy an encoding, ensuring it is canonical */
|
||||
/* d32 is the source decimal32 */
|
||||
/* result is the target (may be the same decimal32) */
|
||||
/* returns result */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal32 * decimal32Canonical(decimal32 *result, const decimal32 *d32) {
|
||||
decNumber dn; // work
|
||||
decContext dc; // ..
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL32);
|
||||
decimal32ToNumber(d32, &dn);
|
||||
decimal32FromNumber(result, &dn, &dc);// result will now be canonical
|
||||
return result;
|
||||
} // decimal32Canonical
|
||||
|
||||
#if DECTRACE || DECCHECK
|
||||
/* Macros for accessing decimal32 fields. These assume the argument
|
||||
is a reference (pointer) to the decimal32 structure, and the
|
||||
decimal32 is in network byte order (big-endian) */
|
||||
// Get sign
|
||||
#define decimal32Sign(d) ((unsigned)(d)->bytes[0]>>7)
|
||||
|
||||
// Get combination field
|
||||
#define decimal32Comb(d) (((d)->bytes[0] & 0x7c)>>2)
|
||||
|
||||
// Get exponent continuation [does not remove bias]
|
||||
#define decimal32ExpCon(d) ((((d)->bytes[0] & 0x03)<<4) \
|
||||
| ((unsigned)(d)->bytes[1]>>4))
|
||||
|
||||
// Set sign [this assumes sign previously 0]
|
||||
#define decimal32SetSign(d, b) { \
|
||||
(d)->bytes[0]|=((unsigned)(b)<<7);}
|
||||
|
||||
// Set exponent continuation [does not apply bias]
|
||||
// This assumes range has been checked and exponent previously 0;
|
||||
// type of exponent must be unsigned
|
||||
#define decimal32SetExpCon(d, e) { \
|
||||
(d)->bytes[0]|=(uByte)((e)>>4); \
|
||||
(d)->bytes[1]|=(uByte)(((e)&0x0F)<<4);}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal32Show -- display a decimal32 in hexadecimal [debug aid] */
|
||||
/* d32 -- the number to show */
|
||||
/* ------------------------------------------------------------------ */
|
||||
// Also shows sign/cob/expconfields extracted - valid bigendian only
|
||||
void decimal32Show(const decimal32 *d32) {
|
||||
char buf[DECIMAL32_Bytes*2+1];
|
||||
Int i, j=0;
|
||||
|
||||
if (DECLITEND) {
|
||||
for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
|
||||
sprintf(&buf[j], "%02x", d32->bytes[3-i]);
|
||||
}
|
||||
printf(" D32> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
|
||||
d32->bytes[3]>>7, (d32->bytes[3]>>2)&0x1f,
|
||||
((d32->bytes[3]&0x3)<<4)| (d32->bytes[2]>>4));
|
||||
}
|
||||
else {
|
||||
for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
|
||||
sprintf(&buf[j], "%02x", d32->bytes[i]);
|
||||
}
|
||||
printf(" D32> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
|
||||
decimal32Sign(d32), decimal32Comb(d32), decimal32ExpCon(d32));
|
||||
}
|
||||
} // decimal32Show
|
||||
#endif
|
||||
@@ -0,0 +1,81 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal 32-bit format module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2006. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECIMAL32)
|
||||
#define DECIMAL32
|
||||
#define DEC32NAME "decimal32" /* Short name */
|
||||
#define DEC32FULLNAME "Decimal 32-bit Number" /* Verbose name */
|
||||
#define DEC32AUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
/* parameters for decimal32s */
|
||||
#define DECIMAL32_Bytes 4 /* length */
|
||||
#define DECIMAL32_Pmax 7 /* maximum precision (digits) */
|
||||
#define DECIMAL32_Emax 96 /* maximum adjusted exponent */
|
||||
#define DECIMAL32_Emin -95 /* minimum adjusted exponent */
|
||||
#define DECIMAL32_Bias 101 /* bias for the exponent */
|
||||
#define DECIMAL32_String 15 /* maximum string length, +1 */
|
||||
#define DECIMAL32_EconL 6 /* exp. continuation length */
|
||||
/* highest biased exponent (Elimit-1) */
|
||||
#define DECIMAL32_Ehigh (DECIMAL32_Emax+DECIMAL32_Bias-DECIMAL32_Pmax+1)
|
||||
|
||||
/* check enough digits, if pre-defined */
|
||||
#if defined(DECNUMDIGITS)
|
||||
#if (DECNUMDIGITS<DECIMAL32_Pmax)
|
||||
#error decimal32.h needs pre-defined DECNUMDIGITS>=7 for safe use
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef DECNUMDIGITS
|
||||
#define DECNUMDIGITS DECIMAL32_Pmax /* size if not already defined*/
|
||||
#endif
|
||||
#ifndef DECNUMBER
|
||||
#include "decNumber.h" /* context and number library */
|
||||
#endif
|
||||
|
||||
/* Decimal 32-bit type, accessible by bytes */
|
||||
typedef struct {
|
||||
uint8_t bytes[DECIMAL32_Bytes]; /* decimal32: 1, 5, 6, 20 bits*/
|
||||
} decimal32;
|
||||
|
||||
/* special values [top byte excluding sign bit; last two bits are */
|
||||
/* don't-care for Infinity on input, last bit don't-care for NaN] */
|
||||
#if !defined(DECIMAL_NaN)
|
||||
#define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */
|
||||
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */
|
||||
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */
|
||||
#endif
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Routines */
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* String conversions */
|
||||
decimal32 * decimal32FromString(decimal32 *, const char *, decContext *);
|
||||
char * decimal32ToString(const decimal32 *, char *);
|
||||
char * decimal32ToEngString(const decimal32 *, char *);
|
||||
|
||||
/* decNumber conversions */
|
||||
decimal32 * decimal32FromNumber(decimal32 *, const decNumber *,
|
||||
decContext *);
|
||||
decNumber * decimal32ToNumber(const decimal32 *, decNumber *);
|
||||
|
||||
/* Format-dependent utilities */
|
||||
uint32_t decimal32IsCanonical(const decimal32 *);
|
||||
decimal32 * decimal32Canonical(decimal32 *, const decimal32 *);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,839 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal 64-bit format module */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2009. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* This module comprises the routines for decimal64 format numbers. */
|
||||
/* Conversions are supplied to and from decNumber and String. */
|
||||
/* */
|
||||
/* This is used when decNumber provides operations, either for all */
|
||||
/* operations or as a proxy between decNumber and decSingle. */
|
||||
/* */
|
||||
/* Error handling is the same as decNumber (qv.). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
#include <string.h> // [for memset/memcpy]
|
||||
#include <stdio.h> // [for printf]
|
||||
|
||||
#define DECNUMDIGITS 16 // make decNumbers with space for 16
|
||||
#include "decNumber.h" // base number library
|
||||
#include "decNumberLocal.h" // decNumber local types, etc.
|
||||
#include "decimal64.h" // our primary include
|
||||
|
||||
/* Utility routines and tables [in decimal64.c]; externs for C++ */
|
||||
// DPD2BIN and the reverse are renamed to prevent link-time conflict
|
||||
// if decQuad is also built in the same executable
|
||||
#define DPD2BIN DPD2BINx
|
||||
#define BIN2DPD BIN2DPDx
|
||||
extern const uInt COMBEXP[32], COMBMSD[32];
|
||||
extern const uShort DPD2BIN[1024];
|
||||
extern const uShort BIN2DPD[1000];
|
||||
extern const uByte BIN2CHAR[4001];
|
||||
|
||||
extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
|
||||
extern void decDigitsToDPD(const decNumber *, uInt *, Int);
|
||||
|
||||
#if DECTRACE || DECCHECK
|
||||
void decimal64Show(const decimal64 *); // for debug
|
||||
extern void decNumberShow(const decNumber *); // ..
|
||||
#endif
|
||||
|
||||
/* Useful macro */
|
||||
// Clear a structure (e.g., a decNumber)
|
||||
#define DEC_clear(d) memset(d, 0, sizeof(*d))
|
||||
|
||||
/* define and include the tables to use for conversions */
|
||||
#define DEC_BIN2CHAR 1
|
||||
#define DEC_DPD2BIN 1
|
||||
#define DEC_BIN2DPD 1 // used for all sizes
|
||||
#include "decDPD.h" // lookup tables
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal64FromNumber -- convert decNumber to decimal64 */
|
||||
/* */
|
||||
/* ds is the target decimal64 */
|
||||
/* dn is the source number (assumed valid) */
|
||||
/* set is the context, used only for reporting errors */
|
||||
/* */
|
||||
/* The set argument is used only for status reporting and for the */
|
||||
/* rounding mode (used if the coefficient is more than DECIMAL64_Pmax */
|
||||
/* digits or an overflow is detected). If the exponent is out of the */
|
||||
/* valid range then Overflow or Underflow will be raised. */
|
||||
/* After Underflow a subnormal result is possible. */
|
||||
/* */
|
||||
/* DEC_Clamped is set if the number has to be 'folded down' to fit, */
|
||||
/* by reducing its exponent and multiplying the coefficient by a */
|
||||
/* power of ten, or if the exponent on a zero had to be clamped. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal64 * decimal64FromNumber(decimal64 *d64, const decNumber *dn,
|
||||
decContext *set) {
|
||||
uInt status=0; // status accumulator
|
||||
Int ae; // adjusted exponent
|
||||
decNumber dw; // work
|
||||
decContext dc; // ..
|
||||
uInt comb, exp; // ..
|
||||
uInt uiwork; // for macros
|
||||
uInt targar[2]={0, 0}; // target 64-bit
|
||||
#define targhi targar[1] // name the word with the sign
|
||||
#define targlo targar[0] // and the other
|
||||
|
||||
// If the number has too many digits, or the exponent could be
|
||||
// out of range then reduce the number under the appropriate
|
||||
// constraints. This could push the number to Infinity or zero,
|
||||
// so this check and rounding must be done before generating the
|
||||
// decimal64]
|
||||
ae=dn->exponent+dn->digits-1; // [0 if special]
|
||||
if (dn->digits>DECIMAL64_Pmax // too many digits
|
||||
|| ae>DECIMAL64_Emax // likely overflow
|
||||
|| ae<DECIMAL64_Emin) { // likely underflow
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL64); // [no traps]
|
||||
dc.round=set->round; // use supplied rounding
|
||||
decNumberPlus(&dw, dn, &dc); // (round and check)
|
||||
// [this changes -0 to 0, so enforce the sign...]
|
||||
dw.bits|=dn->bits&DECNEG;
|
||||
status=dc.status; // save status
|
||||
dn=&dw; // use the work number
|
||||
} // maybe out of range
|
||||
|
||||
if (dn->bits&DECSPECIAL) { // a special value
|
||||
if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
|
||||
else { // sNaN or qNaN
|
||||
if ((*dn->lsu!=0 || dn->digits>1) // non-zero coefficient
|
||||
&& (dn->digits<DECIMAL64_Pmax)) { // coefficient fits
|
||||
decDigitsToDPD(dn, targar, 0);
|
||||
}
|
||||
if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
|
||||
else targhi|=DECIMAL_sNaN<<24;
|
||||
} // a NaN
|
||||
} // special
|
||||
|
||||
else { // is finite
|
||||
if (decNumberIsZero(dn)) { // is a zero
|
||||
// set and clamp exponent
|
||||
if (dn->exponent<-DECIMAL64_Bias) {
|
||||
exp=0; // low clamp
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
else {
|
||||
exp=dn->exponent+DECIMAL64_Bias; // bias exponent
|
||||
if (exp>DECIMAL64_Ehigh) { // top clamp
|
||||
exp=DECIMAL64_Ehigh;
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
}
|
||||
comb=(exp>>5) & 0x18; // msd=0, exp top 2 bits ..
|
||||
}
|
||||
else { // non-zero finite number
|
||||
uInt msd; // work
|
||||
Int pad=0; // coefficient pad digits
|
||||
|
||||
// the dn is known to fit, but it may need to be padded
|
||||
exp=(uInt)(dn->exponent+DECIMAL64_Bias); // bias exponent
|
||||
if (exp>DECIMAL64_Ehigh) { // fold-down case
|
||||
pad=exp-DECIMAL64_Ehigh;
|
||||
exp=DECIMAL64_Ehigh; // [to maximum]
|
||||
status|=DEC_Clamped;
|
||||
}
|
||||
|
||||
// fastpath common case
|
||||
if (DECDPUN==3 && pad==0) {
|
||||
uInt dpd[6]={0,0,0,0,0,0};
|
||||
uInt i;
|
||||
Int d=dn->digits;
|
||||
for (i=0; d>0; i++, d-=3) dpd[i]=BIN2DPD[dn->lsu[i]];
|
||||
targlo =dpd[0];
|
||||
targlo|=dpd[1]<<10;
|
||||
targlo|=dpd[2]<<20;
|
||||
if (dn->digits>6) {
|
||||
targlo|=dpd[3]<<30;
|
||||
targhi =dpd[3]>>2;
|
||||
targhi|=dpd[4]<<8;
|
||||
}
|
||||
msd=dpd[5]; // [did not really need conversion]
|
||||
}
|
||||
else { // general case
|
||||
decDigitsToDPD(dn, targar, pad);
|
||||
// save and clear the top digit
|
||||
msd=targhi>>18;
|
||||
targhi&=0x0003ffff;
|
||||
}
|
||||
|
||||
// create the combination field
|
||||
if (msd>=8) comb=0x18 | ((exp>>7) & 0x06) | (msd & 0x01);
|
||||
else comb=((exp>>5) & 0x18) | msd;
|
||||
}
|
||||
targhi|=comb<<26; // add combination field ..
|
||||
targhi|=(exp&0xff)<<18; // .. and exponent continuation
|
||||
} // finite
|
||||
|
||||
if (dn->bits&DECNEG) targhi|=0x80000000; // add sign bit
|
||||
|
||||
// now write to storage; this is now always endian
|
||||
if (DECLITEND) {
|
||||
// lo int then hi
|
||||
UBFROMUI(d64->bytes, targar[0]);
|
||||
UBFROMUI(d64->bytes+4, targar[1]);
|
||||
}
|
||||
else {
|
||||
// hi int then lo
|
||||
UBFROMUI(d64->bytes, targar[1]);
|
||||
UBFROMUI(d64->bytes+4, targar[0]);
|
||||
}
|
||||
|
||||
if (status!=0) decContextSetStatus(set, status); // pass on status
|
||||
// decimal64Show(d64);
|
||||
return d64;
|
||||
} // decimal64FromNumber
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal64ToNumber -- convert decimal64 to decNumber */
|
||||
/* d64 is the source decimal64 */
|
||||
/* dn is the target number, with appropriate space */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decNumber * decimal64ToNumber(const decimal64 *d64, decNumber *dn) {
|
||||
uInt msd; // coefficient MSD
|
||||
uInt exp; // exponent top two bits
|
||||
uInt comb; // combination field
|
||||
Int need; // work
|
||||
uInt uiwork; // for macros
|
||||
uInt sourar[2]; // source 64-bit
|
||||
#define sourhi sourar[1] // name the word with the sign
|
||||
#define sourlo sourar[0] // and the lower word
|
||||
|
||||
// load source from storage; this is endian
|
||||
if (DECLITEND) {
|
||||
sourlo=UBTOUI(d64->bytes ); // directly load the low int
|
||||
sourhi=UBTOUI(d64->bytes+4); // then the high int
|
||||
}
|
||||
else {
|
||||
sourhi=UBTOUI(d64->bytes ); // directly load the high int
|
||||
sourlo=UBTOUI(d64->bytes+4); // then the low int
|
||||
}
|
||||
|
||||
comb=(sourhi>>26)&0x1f; // combination field
|
||||
|
||||
decNumberZero(dn); // clean number
|
||||
if (sourhi&0x80000000) dn->bits=DECNEG; // set sign if negative
|
||||
|
||||
msd=COMBMSD[comb]; // decode the combination field
|
||||
exp=COMBEXP[comb]; // ..
|
||||
|
||||
if (exp==3) { // is a special
|
||||
if (msd==0) {
|
||||
dn->bits|=DECINF;
|
||||
return dn; // no coefficient needed
|
||||
}
|
||||
else if (sourhi&0x02000000) dn->bits|=DECSNAN;
|
||||
else dn->bits|=DECNAN;
|
||||
msd=0; // no top digit
|
||||
}
|
||||
else { // is a finite number
|
||||
dn->exponent=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias; // unbiased
|
||||
}
|
||||
|
||||
// get the coefficient
|
||||
sourhi&=0x0003ffff; // clean coefficient continuation
|
||||
if (msd) { // non-zero msd
|
||||
sourhi|=msd<<18; // prefix to coefficient
|
||||
need=6; // process 6 declets
|
||||
}
|
||||
else { // msd=0
|
||||
if (!sourhi) { // top word 0
|
||||
if (!sourlo) return dn; // easy: coefficient is 0
|
||||
need=3; // process at least 3 declets
|
||||
if (sourlo&0xc0000000) need++; // process 4 declets
|
||||
// [could reduce some more, here]
|
||||
}
|
||||
else { // some bits in top word, msd=0
|
||||
need=4; // process at least 4 declets
|
||||
if (sourhi&0x0003ff00) need++; // top declet!=0, process 5
|
||||
}
|
||||
} //msd=0
|
||||
|
||||
decDigitsFromDPD(dn, sourar, need); // process declets
|
||||
return dn;
|
||||
} // decimal64ToNumber
|
||||
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* to-scientific-string -- conversion to numeric string */
|
||||
/* to-engineering-string -- conversion to numeric string */
|
||||
/* */
|
||||
/* decimal64ToString(d64, string); */
|
||||
/* decimal64ToEngString(d64, string); */
|
||||
/* */
|
||||
/* d64 is the decimal64 format number to convert */
|
||||
/* string is the string where the result will be laid out */
|
||||
/* */
|
||||
/* string must be at least 24 characters */
|
||||
/* */
|
||||
/* No error is possible, and no status can be set. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
char * decimal64ToEngString(const decimal64 *d64, char *string){
|
||||
decNumber dn; // work
|
||||
decimal64ToNumber(d64, &dn);
|
||||
decNumberToEngString(&dn, string);
|
||||
return string;
|
||||
} // decimal64ToEngString
|
||||
|
||||
char * decimal64ToString(const decimal64 *d64, char *string){
|
||||
uInt msd; // coefficient MSD
|
||||
Int exp; // exponent top two bits or full
|
||||
uInt comb; // combination field
|
||||
char *cstart; // coefficient start
|
||||
char *c; // output pointer in string
|
||||
const uByte *u; // work
|
||||
char *s, *t; // .. (source, target)
|
||||
Int dpd; // ..
|
||||
Int pre, e; // ..
|
||||
uInt uiwork; // for macros
|
||||
|
||||
uInt sourar[2]; // source 64-bit
|
||||
#define sourhi sourar[1] // name the word with the sign
|
||||
#define sourlo sourar[0] // and the lower word
|
||||
|
||||
// load source from storage; this is endian
|
||||
if (DECLITEND) {
|
||||
sourlo=UBTOUI(d64->bytes ); // directly load the low int
|
||||
sourhi=UBTOUI(d64->bytes+4); // then the high int
|
||||
}
|
||||
else {
|
||||
sourhi=UBTOUI(d64->bytes ); // directly load the high int
|
||||
sourlo=UBTOUI(d64->bytes+4); // then the low int
|
||||
}
|
||||
|
||||
c=string; // where result will go
|
||||
if (((Int)sourhi)<0) *c++='-'; // handle sign
|
||||
|
||||
comb=(sourhi>>26)&0x1f; // combination field
|
||||
msd=COMBMSD[comb]; // decode the combination field
|
||||
exp=COMBEXP[comb]; // ..
|
||||
|
||||
if (exp==3) {
|
||||
if (msd==0) { // infinity
|
||||
strcpy(c, "Inf");
|
||||
strcpy(c+3, "inity");
|
||||
return string; // easy
|
||||
}
|
||||
if (sourhi&0x02000000) *c++='s'; // sNaN
|
||||
strcpy(c, "NaN"); // complete word
|
||||
c+=3; // step past
|
||||
if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; // zero payload
|
||||
// otherwise drop through to add integer; set correct exp
|
||||
exp=0; msd=0; // setup for following code
|
||||
}
|
||||
else exp=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias;
|
||||
|
||||
// convert 16 digits of significand to characters
|
||||
cstart=c; // save start of coefficient
|
||||
if (msd) *c++='0'+(char)msd; // non-zero most significant digit
|
||||
|
||||
// Now decode the declets. After extracting each one, it is
|
||||
// decoded to binary and then to a 4-char sequence by table lookup;
|
||||
// the 4-chars are a 1-char length (significant digits, except 000
|
||||
// has length 0). This allows us to left-align the first declet
|
||||
// with non-zero content, then remaining ones are full 3-char
|
||||
// length. We use fixed-length memcpys because variable-length
|
||||
// causes a subroutine call in GCC. (These are length 4 for speed
|
||||
// and are safe because the array has an extra terminator byte.)
|
||||
#define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; \
|
||||
if (c!=cstart) {memcpy(c, u+1, 4); c+=3;} \
|
||||
else if (*u) {memcpy(c, u+4-*u, 4); c+=*u;}
|
||||
|
||||
dpd=(sourhi>>8)&0x3ff; // declet 1
|
||||
dpd2char;
|
||||
dpd=((sourhi&0xff)<<2) | (sourlo>>30); // declet 2
|
||||
dpd2char;
|
||||
dpd=(sourlo>>20)&0x3ff; // declet 3
|
||||
dpd2char;
|
||||
dpd=(sourlo>>10)&0x3ff; // declet 4
|
||||
dpd2char;
|
||||
dpd=(sourlo)&0x3ff; // declet 5
|
||||
dpd2char;
|
||||
|
||||
if (c==cstart) *c++='0'; // all zeros -- make 0
|
||||
|
||||
if (exp==0) { // integer or NaN case -- easy
|
||||
*c='\0'; // terminate
|
||||
return string;
|
||||
}
|
||||
|
||||
/* non-0 exponent */
|
||||
e=0; // assume no E
|
||||
pre=c-cstart+exp;
|
||||
// [here, pre-exp is the digits count (==1 for zero)]
|
||||
if (exp>0 || pre<-5) { // need exponential form
|
||||
e=pre-1; // calculate E value
|
||||
pre=1; // assume one digit before '.'
|
||||
} // exponential form
|
||||
|
||||
/* modify the coefficient, adding 0s, '.', and E+nn as needed */
|
||||
s=c-1; // source (LSD)
|
||||
if (pre>0) { // ddd.ddd (plain), perhaps with E
|
||||
char *dotat=cstart+pre;
|
||||
if (dotat<c) { // if embedded dot needed...
|
||||
t=c; // target
|
||||
for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
|
||||
*t='.'; // insert the dot
|
||||
c++; // length increased by one
|
||||
}
|
||||
|
||||
// finally add the E-part, if needed; it will never be 0, and has
|
||||
// a maximum length of 3 digits
|
||||
if (e!=0) {
|
||||
*c++='E'; // starts with E
|
||||
*c++='+'; // assume positive
|
||||
if (e<0) {
|
||||
*(c-1)='-'; // oops, need '-'
|
||||
e=-e; // uInt, please
|
||||
}
|
||||
u=&BIN2CHAR[e*4]; // -> length byte
|
||||
memcpy(c, u+4-*u, 4); // copy fixed 4 characters [is safe]
|
||||
c+=*u; // bump pointer appropriately
|
||||
}
|
||||
*c='\0'; // add terminator
|
||||
//printf("res %s\n", string);
|
||||
return string;
|
||||
} // pre>0
|
||||
|
||||
/* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
|
||||
t=c+1-pre;
|
||||
*(t+1)='\0'; // can add terminator now
|
||||
for (; s>=cstart; s--, t--) *t=*s; // shift whole coefficient right
|
||||
c=cstart;
|
||||
*c++='0'; // always starts with 0.
|
||||
*c++='.';
|
||||
for (; pre<0; pre++) *c++='0'; // add any 0's after '.'
|
||||
//printf("res %s\n", string);
|
||||
return string;
|
||||
} // decimal64ToString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* to-number -- conversion from numeric string */
|
||||
/* */
|
||||
/* decimal64FromString(result, string, set); */
|
||||
/* */
|
||||
/* result is the decimal64 format number which gets the result of */
|
||||
/* the conversion */
|
||||
/* *string is the character string which should contain a valid */
|
||||
/* number (which may be a special value) */
|
||||
/* set is the context */
|
||||
/* */
|
||||
/* The context is supplied to this routine is used for error handling */
|
||||
/* (setting of status and traps) and for the rounding mode, only. */
|
||||
/* If an error occurs, the result will be a valid decimal64 NaN. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal64 * decimal64FromString(decimal64 *result, const char *string,
|
||||
decContext *set) {
|
||||
decContext dc; // work
|
||||
decNumber dn; // ..
|
||||
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL64); // no traps, please
|
||||
dc.round=set->round; // use supplied rounding
|
||||
|
||||
decNumberFromString(&dn, string, &dc); // will round if needed
|
||||
|
||||
decimal64FromNumber(result, &dn, &dc);
|
||||
if (dc.status!=0) { // something happened
|
||||
decContextSetStatus(set, dc.status); // .. pass it on
|
||||
}
|
||||
return result;
|
||||
} // decimal64FromString
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal64IsCanonical -- test whether encoding is canonical */
|
||||
/* d64 is the source decimal64 */
|
||||
/* returns 1 if the encoding of d64 is canonical, 0 otherwise */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
uInt decimal64IsCanonical(const decimal64 *d64) {
|
||||
decNumber dn; // work
|
||||
decimal64 canon; // ..
|
||||
decContext dc; // ..
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL64);
|
||||
decimal64ToNumber(d64, &dn);
|
||||
decimal64FromNumber(&canon, &dn, &dc);// canon will now be canonical
|
||||
return memcmp(d64, &canon, DECIMAL64_Bytes)==0;
|
||||
} // decimal64IsCanonical
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal64Canonical -- copy an encoding, ensuring it is canonical */
|
||||
/* d64 is the source decimal64 */
|
||||
/* result is the target (may be the same decimal64) */
|
||||
/* returns result */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
decimal64 * decimal64Canonical(decimal64 *result, const decimal64 *d64) {
|
||||
decNumber dn; // work
|
||||
decContext dc; // ..
|
||||
decContextDefault(&dc, DEC_INIT_DECIMAL64);
|
||||
decimal64ToNumber(d64, &dn);
|
||||
decimal64FromNumber(result, &dn, &dc);// result will now be canonical
|
||||
return result;
|
||||
} // decimal64Canonical
|
||||
|
||||
#if DECTRACE || DECCHECK
|
||||
/* Macros for accessing decimal64 fields. These assume the
|
||||
argument is a reference (pointer) to the decimal64 structure,
|
||||
and the decimal64 is in network byte order (big-endian) */
|
||||
// Get sign
|
||||
#define decimal64Sign(d) ((unsigned)(d)->bytes[0]>>7)
|
||||
|
||||
// Get combination field
|
||||
#define decimal64Comb(d) (((d)->bytes[0] & 0x7c)>>2)
|
||||
|
||||
// Get exponent continuation [does not remove bias]
|
||||
#define decimal64ExpCon(d) ((((d)->bytes[0] & 0x03)<<6) \
|
||||
| ((unsigned)(d)->bytes[1]>>2))
|
||||
|
||||
// Set sign [this assumes sign previously 0]
|
||||
#define decimal64SetSign(d, b) { \
|
||||
(d)->bytes[0]|=((unsigned)(b)<<7);}
|
||||
|
||||
// Set exponent continuation [does not apply bias]
|
||||
// This assumes range has been checked and exponent previously 0;
|
||||
// type of exponent must be unsigned
|
||||
#define decimal64SetExpCon(d, e) { \
|
||||
(d)->bytes[0]|=(uByte)((e)>>6); \
|
||||
(d)->bytes[1]|=(uByte)(((e)&0x3F)<<2);}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decimal64Show -- display a decimal64 in hexadecimal [debug aid] */
|
||||
/* d64 -- the number to show */
|
||||
/* ------------------------------------------------------------------ */
|
||||
// Also shows sign/cob/expconfields extracted
|
||||
void decimal64Show(const decimal64 *d64) {
|
||||
char buf[DECIMAL64_Bytes*2+1];
|
||||
Int i, j=0;
|
||||
|
||||
if (DECLITEND) {
|
||||
for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
|
||||
sprintf(&buf[j], "%02x", d64->bytes[7-i]);
|
||||
}
|
||||
printf(" D64> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
|
||||
d64->bytes[7]>>7, (d64->bytes[7]>>2)&0x1f,
|
||||
((d64->bytes[7]&0x3)<<6)| (d64->bytes[6]>>2));
|
||||
}
|
||||
else { // big-endian
|
||||
for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
|
||||
sprintf(&buf[j], "%02x", d64->bytes[i]);
|
||||
}
|
||||
printf(" D64> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
|
||||
decimal64Sign(d64), decimal64Comb(d64), decimal64ExpCon(d64));
|
||||
}
|
||||
} // decimal64Show
|
||||
#endif
|
||||
|
||||
/* ================================================================== */
|
||||
/* Shared utility routines and tables */
|
||||
/* ================================================================== */
|
||||
// define and include the conversion tables to use for shared code
|
||||
#if DECDPUN==3
|
||||
#define DEC_DPD2BIN 1
|
||||
#else
|
||||
#define DEC_DPD2BCD 1
|
||||
#endif
|
||||
#include "decDPD.h" // lookup tables
|
||||
|
||||
// The maximum number of decNumberUnits needed for a working copy of
|
||||
// the units array is the ceiling of digits/DECDPUN, where digits is
|
||||
// the maximum number of digits in any of the formats for which this
|
||||
// is used. decimal128.h must not be included in this module, so, as
|
||||
// a very special case, that number is defined as a literal here.
|
||||
#define DECMAX754 34
|
||||
#define DECMAXUNITS ((DECMAX754+DECDPUN-1)/DECDPUN)
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Combination field lookup tables (uInts to save measurable work) */
|
||||
/* */
|
||||
/* COMBEXP - 2-bit most-significant-bits of exponent */
|
||||
/* [11 if an Infinity or NaN] */
|
||||
/* COMBMSD - 4-bit most-significant-digit */
|
||||
/* [0=Infinity, 1=NaN if COMBEXP=11] */
|
||||
/* */
|
||||
/* Both are indexed by the 5-bit combination field (0-31) */
|
||||
/* ------------------------------------------------------------------ */
|
||||
const uInt COMBEXP[32]={0, 0, 0, 0, 0, 0, 0, 0,
|
||||
1, 1, 1, 1, 1, 1, 1, 1,
|
||||
2, 2, 2, 2, 2, 2, 2, 2,
|
||||
0, 0, 1, 1, 2, 2, 3, 3};
|
||||
const uInt COMBMSD[32]={0, 1, 2, 3, 4, 5, 6, 7,
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 8, 9, 8, 9, 0, 1};
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decDigitsToDPD -- pack coefficient into DPD form */
|
||||
/* */
|
||||
/* dn is the source number (assumed valid, max DECMAX754 digits) */
|
||||
/* targ is 1, 2, or 4-element uInt array, which the caller must */
|
||||
/* have cleared to zeros */
|
||||
/* shift is the number of 0 digits to add on the right (normally 0) */
|
||||
/* */
|
||||
/* The coefficient must be known small enough to fit. The full */
|
||||
/* coefficient is copied, including the leading 'odd' digit. This */
|
||||
/* digit is retrieved and packed into the combination field by the */
|
||||
/* caller. */
|
||||
/* */
|
||||
/* The target uInts are altered only as necessary to receive the */
|
||||
/* digits of the decNumber. When more than one uInt is needed, they */
|
||||
/* are filled from left to right (that is, the uInt at offset 0 will */
|
||||
/* end up with the least-significant digits). */
|
||||
/* */
|
||||
/* shift is used for 'fold-down' padding. */
|
||||
/* */
|
||||
/* No error is possible. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
#if DECDPUN<=4
|
||||
// Constant multipliers for divide-by-power-of five using reciprocal
|
||||
// multiply, after removing powers of 2 by shifting, and final shift
|
||||
// of 17 [we only need up to **4]
|
||||
static const uInt multies[]={131073, 26215, 5243, 1049, 210};
|
||||
// QUOT10 -- macro to return the quotient of unit u divided by 10**n
|
||||
#define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
|
||||
#endif
|
||||
void decDigitsToDPD(const decNumber *dn, uInt *targ, Int shift) {
|
||||
Int cut; // work
|
||||
Int n; // output bunch counter
|
||||
Int digits=dn->digits; // digit countdown
|
||||
uInt dpd; // densely packed decimal value
|
||||
uInt bin; // binary value 0-999
|
||||
uInt *uout=targ; // -> current output uInt
|
||||
uInt uoff=0; // -> current output offset [from right]
|
||||
const Unit *inu=dn->lsu; // -> current input unit
|
||||
Unit uar[DECMAXUNITS]; // working copy of units, iff shifted
|
||||
#if DECDPUN!=3 // not fast path
|
||||
Unit in; // current unit
|
||||
#endif
|
||||
|
||||
if (shift!=0) { // shift towards most significant required
|
||||
// shift the units array to the left by pad digits and copy
|
||||
// [this code is a special case of decShiftToMost, which could
|
||||
// be used instead if exposed and the array were copied first]
|
||||
const Unit *source; // ..
|
||||
Unit *target, *first; // ..
|
||||
uInt next=0; // work
|
||||
|
||||
source=dn->lsu+D2U(digits)-1; // where msu comes from
|
||||
target=uar+D2U(digits)-1+D2U(shift);// where upper part of first cut goes
|
||||
cut=DECDPUN-MSUDIGITS(shift); // where to slice
|
||||
if (cut==0) { // unit-boundary case
|
||||
for (; source>=dn->lsu; source--, target--) *target=*source;
|
||||
}
|
||||
else {
|
||||
first=uar+D2U(digits+shift)-1; // where msu will end up
|
||||
for (; source>=dn->lsu; source--, target--) {
|
||||
// split the source Unit and accumulate remainder for next
|
||||
#if DECDPUN<=4
|
||||
uInt quot=QUOT10(*source, cut);
|
||||
uInt rem=*source-quot*DECPOWERS[cut];
|
||||
next+=quot;
|
||||
#else
|
||||
uInt rem=*source%DECPOWERS[cut];
|
||||
next+=*source/DECPOWERS[cut];
|
||||
#endif
|
||||
if (target<=first) *target=(Unit)next; // write to target iff valid
|
||||
next=rem*DECPOWERS[DECDPUN-cut]; // save remainder for next Unit
|
||||
}
|
||||
} // shift-move
|
||||
// propagate remainder to one below and clear the rest
|
||||
for (; target>=uar; target--) {
|
||||
*target=(Unit)next;
|
||||
next=0;
|
||||
}
|
||||
digits+=shift; // add count (shift) of zeros added
|
||||
inu=uar; // use units in working array
|
||||
}
|
||||
|
||||
/* now densely pack the coefficient into DPD declets */
|
||||
|
||||
#if DECDPUN!=3 // not fast path
|
||||
in=*inu; // current unit
|
||||
cut=0; // at lowest digit
|
||||
bin=0; // [keep compiler quiet]
|
||||
#endif
|
||||
|
||||
for(n=0; digits>0; n++) { // each output bunch
|
||||
#if DECDPUN==3 // fast path, 3-at-a-time
|
||||
bin=*inu; // 3 digits ready for convert
|
||||
digits-=3; // [may go negative]
|
||||
inu++; // may need another
|
||||
|
||||
#else // must collect digit-by-digit
|
||||
Unit dig; // current digit
|
||||
Int j; // digit-in-declet count
|
||||
for (j=0; j<3; j++) {
|
||||
#if DECDPUN<=4
|
||||
Unit temp=(Unit)((uInt)(in*6554)>>16);
|
||||
dig=(Unit)(in-X10(temp));
|
||||
in=temp;
|
||||
#else
|
||||
dig=in%10;
|
||||
in=in/10;
|
||||
#endif
|
||||
if (j==0) bin=dig;
|
||||
else if (j==1) bin+=X10(dig);
|
||||
else /* j==2 */ bin+=X100(dig);
|
||||
digits--;
|
||||
if (digits==0) break; // [also protects *inu below]
|
||||
cut++;
|
||||
if (cut==DECDPUN) {inu++; in=*inu; cut=0;}
|
||||
}
|
||||
#endif
|
||||
// here there are 3 digits in bin, or have used all input digits
|
||||
|
||||
dpd=BIN2DPD[bin];
|
||||
|
||||
// write declet to uInt array
|
||||
*uout|=dpd<<uoff;
|
||||
uoff+=10;
|
||||
if (uoff<32) continue; // no uInt boundary cross
|
||||
uout++;
|
||||
uoff-=32;
|
||||
*uout|=dpd>>(10-uoff); // collect top bits
|
||||
} // n declets
|
||||
return;
|
||||
} // decDigitsToDPD
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* decDigitsFromDPD -- unpack a format's coefficient */
|
||||
/* */
|
||||
/* dn is the target number, with 7, 16, or 34-digit space. */
|
||||
/* sour is a 1, 2, or 4-element uInt array containing only declets */
|
||||
/* declets is the number of (right-aligned) declets in sour to */
|
||||
/* be processed. This may be 1 more than the obvious number in */
|
||||
/* a format, as any top digit is prefixed to the coefficient */
|
||||
/* continuation field. It also may be as small as 1, as the */
|
||||
/* caller may pre-process leading zero declets. */
|
||||
/* */
|
||||
/* When doing the 'extra declet' case care is taken to avoid writing */
|
||||
/* extra digits when there are leading zeros, as these could overflow */
|
||||
/* the units array when DECDPUN is not 3. */
|
||||
/* */
|
||||
/* The target uInts are used only as necessary to process declets */
|
||||
/* declets into the decNumber. When more than one uInt is needed, */
|
||||
/* they are used from left to right (that is, the uInt at offset 0 */
|
||||
/* provides the least-significant digits). */
|
||||
/* */
|
||||
/* dn->digits is set, but not the sign or exponent. */
|
||||
/* No error is possible [the redundant 888 codes are allowed]. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
void decDigitsFromDPD(decNumber *dn, const uInt *sour, Int declets) {
|
||||
|
||||
uInt dpd; // collector for 10 bits
|
||||
Int n; // counter
|
||||
Unit *uout=dn->lsu; // -> current output unit
|
||||
Unit *last=uout; // will be unit containing msd
|
||||
const uInt *uin=sour; // -> current input uInt
|
||||
uInt uoff=0; // -> current input offset [from right]
|
||||
|
||||
#if DECDPUN!=3
|
||||
uInt bcd; // BCD result
|
||||
uInt nibble; // work
|
||||
Unit out=0; // accumulator
|
||||
Int cut=0; // power of ten in current unit
|
||||
#endif
|
||||
#if DECDPUN>4
|
||||
uInt const *pow; // work
|
||||
#endif
|
||||
|
||||
// Expand the densely-packed integer, right to left
|
||||
for (n=declets-1; n>=0; n--) { // count down declets of 10 bits
|
||||
dpd=*uin>>uoff;
|
||||
uoff+=10;
|
||||
if (uoff>32) { // crossed uInt boundary
|
||||
uin++;
|
||||
uoff-=32; // [if using this code for wider, check this]
|
||||
dpd|=*uin<<(10-uoff); // get waiting bits
|
||||
}
|
||||
dpd&=0x3ff; // clear uninteresting bits
|
||||
|
||||
#if DECDPUN==3
|
||||
if (dpd==0) *uout=0;
|
||||
else {
|
||||
*uout=DPD2BIN[dpd]; // convert 10 bits to binary 0-999
|
||||
last=uout; // record most significant unit
|
||||
}
|
||||
uout++;
|
||||
} // n
|
||||
|
||||
#else // DECDPUN!=3
|
||||
if (dpd==0) { // fastpath [e.g., leading zeros]
|
||||
// write out three 0 digits (nibbles); out may have digit(s)
|
||||
cut++;
|
||||
if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
|
||||
if (n==0) break; // [as below, works even if MSD=0]
|
||||
cut++;
|
||||
if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
|
||||
cut++;
|
||||
if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
|
||||
continue;
|
||||
}
|
||||
|
||||
bcd=DPD2BCD[dpd]; // convert 10 bits to 12 bits BCD
|
||||
|
||||
// now accumulate the 3 BCD nibbles into units
|
||||
nibble=bcd & 0x00f;
|
||||
if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
|
||||
cut++;
|
||||
if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
|
||||
bcd>>=4;
|
||||
|
||||
// if this is the last declet and the remaining nibbles in bcd
|
||||
// are 00 then process no more nibbles, because this could be
|
||||
// the 'odd' MSD declet and writing any more Units would then
|
||||
// overflow the unit array
|
||||
if (n==0 && !bcd) break;
|
||||
|
||||
nibble=bcd & 0x00f;
|
||||
if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
|
||||
cut++;
|
||||
if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
|
||||
bcd>>=4;
|
||||
|
||||
nibble=bcd & 0x00f;
|
||||
if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
|
||||
cut++;
|
||||
if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
|
||||
} // n
|
||||
if (cut!=0) { // some more left over
|
||||
*uout=out; // write out final unit
|
||||
if (out) last=uout; // and note if non-zero
|
||||
}
|
||||
#endif
|
||||
|
||||
// here, last points to the most significant unit with digits;
|
||||
// inspect it to get the final digits count -- this is essentially
|
||||
// the same code as decGetDigits in decNumber.c
|
||||
dn->digits=(last-dn->lsu)*DECDPUN+1; // floor of digits, plus
|
||||
// must be at least 1 digit
|
||||
#if DECDPUN>1
|
||||
if (*last<10) return; // common odd digit or 0
|
||||
dn->digits++; // must be 2 at least
|
||||
#if DECDPUN>2
|
||||
if (*last<100) return; // 10-99
|
||||
dn->digits++; // must be 3 at least
|
||||
#if DECDPUN>3
|
||||
if (*last<1000) return; // 100-999
|
||||
dn->digits++; // must be 4 at least
|
||||
#if DECDPUN>4
|
||||
for (pow=&DECPOWERS[4]; *last>=*pow; pow++) dn->digits++;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
return;
|
||||
} //decDigitsFromDPD
|
||||
@@ -0,0 +1,83 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal 64-bit format module header */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2000, 2005. All rights reserved. */
|
||||
/* */
|
||||
/* This software is made available under the terms of the */
|
||||
/* ICU License -- ICU 1.8.1 and later. */
|
||||
/* */
|
||||
/* The description and User's Guide ("The decNumber C Library") for */
|
||||
/* this software is called decNumber.pdf. This document is */
|
||||
/* available, together with arithmetic and format specifications, */
|
||||
/* testcases, and Web links, on the General Decimal Arithmetic page. */
|
||||
/* */
|
||||
/* Please send comments, suggestions, and corrections to the author: */
|
||||
/* mfc@uk.ibm.com */
|
||||
/* Mike Cowlishaw, IBM Fellow */
|
||||
/* IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if !defined(DECIMAL64)
|
||||
#define DECIMAL64
|
||||
#define DEC64NAME "decimal64" /* Short name */
|
||||
#define DEC64FULLNAME "Decimal 64-bit Number" /* Verbose name */
|
||||
#define DEC64AUTHOR "Mike Cowlishaw" /* Who to blame */
|
||||
|
||||
|
||||
/* parameters for decimal64s */
|
||||
#define DECIMAL64_Bytes 8 /* length */
|
||||
#define DECIMAL64_Pmax 16 /* maximum precision (digits) */
|
||||
#define DECIMAL64_Emax 384 /* maximum adjusted exponent */
|
||||
#define DECIMAL64_Emin -383 /* minimum adjusted exponent */
|
||||
#define DECIMAL64_Bias 398 /* bias for the exponent */
|
||||
#define DECIMAL64_String 24 /* maximum string length, +1 */
|
||||
#define DECIMAL64_EconL 8 /* exp. continuation length */
|
||||
/* highest biased exponent (Elimit-1) */
|
||||
#define DECIMAL64_Ehigh (DECIMAL64_Emax+DECIMAL64_Bias-DECIMAL64_Pmax+1)
|
||||
|
||||
/* check enough digits, if pre-defined */
|
||||
#if defined(DECNUMDIGITS)
|
||||
#if (DECNUMDIGITS<DECIMAL64_Pmax)
|
||||
#error decimal64.h needs pre-defined DECNUMDIGITS>=16 for safe use
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef DECNUMDIGITS
|
||||
#define DECNUMDIGITS DECIMAL64_Pmax /* size if not already defined*/
|
||||
#endif
|
||||
#ifndef DECNUMBER
|
||||
#include "decNumber.h" /* context and number library */
|
||||
#endif
|
||||
|
||||
/* Decimal 64-bit type, accessible by bytes */
|
||||
typedef struct {
|
||||
uint8_t bytes[DECIMAL64_Bytes]; /* decimal64: 1, 5, 8, 50 bits*/
|
||||
} decimal64;
|
||||
|
||||
/* special values [top byte excluding sign bit; last two bits are */
|
||||
/* don't-care for Infinity on input, last bit don't-care for NaN] */
|
||||
#if !defined(DECIMAL_NaN)
|
||||
#define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */
|
||||
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */
|
||||
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */
|
||||
#endif
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* Routines */
|
||||
/* ---------------------------------------------------------------- */
|
||||
/* String conversions */
|
||||
decimal64 * decimal64FromString(decimal64 *, const char *, decContext *);
|
||||
char * decimal64ToString(const decimal64 *, char *);
|
||||
char * decimal64ToEngString(const decimal64 *, char *);
|
||||
|
||||
/* decNumber conversions */
|
||||
decimal64 * decimal64FromNumber(decimal64 *, const decNumber *,
|
||||
decContext *);
|
||||
decNumber * decimal64ToNumber(const decimal64 *, decNumber *);
|
||||
|
||||
/* Format-dependent utilities */
|
||||
uint32_t decimal64IsCanonical(const decimal64 *);
|
||||
decimal64 * decimal64Canonical(decimal64 *, const decimal64 *);
|
||||
|
||||
#endif
|
||||
Binary file not shown.
@@ -0,0 +1,38 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001, 2007. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example1.c -- convert the first two argument words to decNumber,
|
||||
// add them together, and display the result
|
||||
|
||||
#define DECNUMDIGITS 34 // work with up to 34 digits
|
||||
#include "decNumber.h" // base number library
|
||||
#include <stdio.h> // for printf
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
decNumber a, b; // working numbers
|
||||
decContext set; // working context
|
||||
char string[DECNUMDIGITS+14]; // conversion buffer
|
||||
|
||||
decContextTestEndian(0); // warn if DECLITEND is wrong
|
||||
|
||||
if (argc<3) { // not enough words
|
||||
printf("Please supply two numbers to add.\n");
|
||||
return 1;
|
||||
}
|
||||
decContextDefault(&set, DEC_INIT_BASE); // initialize
|
||||
set.traps=0; // no traps, thank you
|
||||
set.digits=DECNUMDIGITS; // set precision
|
||||
|
||||
decNumberFromString(&a, argv[1], &set);
|
||||
decNumberFromString(&b, argv[2], &set);
|
||||
|
||||
decNumberAdd(&a, &a, &b, &set); // a=a+b
|
||||
decNumberToString(&a, string);
|
||||
|
||||
printf("%s + %s => %s\n", argv[1], argv[2], string);
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,52 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example2.c -- calculate compound interest
|
||||
// Arguments are investment, rate (%), and years
|
||||
|
||||
#define DECNUMDIGITS 38 // work with up to 38 digits
|
||||
#include "decNumber.h" // base number library
|
||||
#include <stdio.h> // for printf
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int need=3;
|
||||
if (argc<need+1) { // not enough words
|
||||
printf("Please supply %d number(s).\n", need);
|
||||
return 1;
|
||||
}
|
||||
|
||||
{ // excerpt for User's Guide starts here--------------------------|
|
||||
decNumber one, mtwo, hundred; // constants
|
||||
decNumber start, rate, years; // parameters
|
||||
decNumber total; // result
|
||||
decContext set; // working context
|
||||
char string[DECNUMDIGITS+14]; // conversion buffer
|
||||
|
||||
decContextDefault(&set, DEC_INIT_BASE); // initialize
|
||||
set.traps=0; // no traps
|
||||
set.digits=25; // precision 25
|
||||
decNumberFromString(&one, "1", &set); // set constants
|
||||
decNumberFromString(&mtwo, "-2", &set);
|
||||
decNumberFromString(&hundred, "100", &set);
|
||||
|
||||
decNumberFromString(&start, argv[1], &set); // parameter words
|
||||
decNumberFromString(&rate, argv[2], &set);
|
||||
decNumberFromString(&years, argv[3], &set);
|
||||
|
||||
decNumberDivide(&rate, &rate, &hundred, &set); // rate=rate/100
|
||||
decNumberAdd(&rate, &rate, &one, &set); // rate=rate+1
|
||||
decNumberPower(&rate, &rate, &years, &set); // rate=rate^years
|
||||
decNumberMultiply(&total, &rate, &start, &set); // total=rate*start
|
||||
decNumberRescale(&total, &total, &mtwo, &set); // two digits please
|
||||
|
||||
decNumberToString(&total, string);
|
||||
printf("%s at %s%% for %s years => %s\n",
|
||||
argv[1], argv[2], argv[3], string);
|
||||
|
||||
} //---------------------------------------------------------------|
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,64 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example3.c -- calculate compound interest, passive checking
|
||||
// Arguments are investment, rate (%), and years
|
||||
|
||||
#define DECNUMDIGITS 38 // work with up to 38 digits
|
||||
#include "decNumber.h" // base number library
|
||||
#include <stdio.h> // for printf
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int need=3;
|
||||
if (argc<need+1) { // not enough words
|
||||
printf("Please supply %d number(s).\n", need);
|
||||
return 1;
|
||||
}
|
||||
|
||||
{ // start of Example 2 segment
|
||||
decNumber one, mtwo, hundred; // constants
|
||||
decNumber start, rate, years; // parameters
|
||||
decNumber total; // result
|
||||
decContext set; // working context
|
||||
char string[DECNUMDIGITS+14]; // conversion buffer
|
||||
|
||||
decContextDefault(&set, DEC_INIT_BASE); // initialize
|
||||
set.traps=0; // no traps
|
||||
set.digits=25; // precision 25
|
||||
decNumberFromString(&one, "1", &set); // set constants
|
||||
decNumberFromString(&mtwo, "-2", &set);
|
||||
decNumberFromString(&hundred, "100", &set);
|
||||
|
||||
// [snip...
|
||||
decNumberFromString(&start, argv[1], &set); // parameter words
|
||||
decNumberFromString(&rate, argv[2], &set);
|
||||
decNumberFromString(&years, argv[3], &set);
|
||||
if (set.status & DEC_Errors) {
|
||||
printf("An input argument word was invalid [%s]\n",
|
||||
decContextStatusToString(&set));
|
||||
return 1;
|
||||
}
|
||||
decNumberDivide(&rate, &rate, &hundred, &set); // rate=rate/100
|
||||
decNumberAdd(&rate, &rate, &one, &set); // rate=rate+1
|
||||
decNumberPower(&rate, &rate, &years, &set); // rate=rate^years
|
||||
decNumberMultiply(&total, &rate, &start, &set); // total=rate*start
|
||||
decNumberRescale(&total, &total, &mtwo, &set); // two digits please
|
||||
if (set.status & DEC_Errors) {
|
||||
set.status &= DEC_Errors; // keep only errors
|
||||
printf("Result could not be calculated [%s]\n",
|
||||
decContextStatusToString(&set));
|
||||
return 1;
|
||||
}
|
||||
// ...snip]
|
||||
|
||||
decNumberToString(&total, string);
|
||||
printf("%s at %s%% for %s years => %s\n",
|
||||
argv[1], argv[2], argv[3], string);
|
||||
|
||||
} //---------------------------------------------------------------|
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,61 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example4.c -- add two numbers, active error handling
|
||||
// Arguments are two numbers
|
||||
|
||||
#define DECNUMDIGITS 38 // work with up to 38 digits
|
||||
#include "decNumber.h" // base number library
|
||||
#include <stdio.h> // for printf
|
||||
|
||||
// [snip...
|
||||
#include <signal.h> // signal handling
|
||||
#include <setjmp.h> // setjmp/longjmp
|
||||
|
||||
jmp_buf preserve; // stack snapshot
|
||||
|
||||
void signalHandler(int); // prototype for GCC
|
||||
void signalHandler(int sig) {
|
||||
signal(SIGFPE, signalHandler); // re-enable
|
||||
longjmp(preserve, sig); // branch to preserved point
|
||||
}
|
||||
// ...snip]
|
||||
int main(int argc, char *argv[]) {
|
||||
decNumber a, b; // working numbers
|
||||
decContext set; // working context
|
||||
char string[DECNUMDIGITS+14]; // conversion buffer
|
||||
int value; // work variable
|
||||
|
||||
if (argc<3) { // not enough words
|
||||
printf("Please supply two numbers to add.\n");
|
||||
return 1;
|
||||
}
|
||||
decContextDefault(&set, DEC_INIT_BASE); // initialize
|
||||
|
||||
// [snip...
|
||||
signal(SIGFPE, signalHandler); // set up signal handler
|
||||
value=setjmp(preserve); // preserve and test environment
|
||||
if (value) { // (non-0 after longjmp)
|
||||
set.status &= DEC_Errors; // keep only errors
|
||||
printf("Signal trapped [%s].\n", decContextStatusToString(&set));
|
||||
return 1;
|
||||
}
|
||||
// ...snip]
|
||||
|
||||
// [change from Example 1, here]
|
||||
// leave traps enabled
|
||||
set.digits=DECNUMDIGITS; // set precision
|
||||
|
||||
decNumberFromString(&a, argv[1], &set);
|
||||
decNumberFromString(&b, argv[2], &set);
|
||||
|
||||
decNumberAdd(&a, &a, &b, &set); // A=A+B
|
||||
decNumberToString(&a, string);
|
||||
|
||||
printf("%s + %s => %s\n", argv[1], argv[2], string);
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,36 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001, 2007. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example5.c -- decimal64 conversions
|
||||
|
||||
#include "decimal64.h" // decimal64 and decNumber library
|
||||
#include <stdio.h> // for (s)printf
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
decimal64 a; // working decimal64 number
|
||||
decNumber d; // working number
|
||||
decContext set; // working context
|
||||
char string[DECIMAL64_String]; // number->string buffer
|
||||
char hexes[25]; // decimal64->hex buffer
|
||||
int i; // counter
|
||||
|
||||
if (argc<2) { // not enough words
|
||||
printf("Please supply a number.\n");
|
||||
return 1;
|
||||
}
|
||||
decContextDefault(&set, DEC_INIT_DECIMAL64); // initialize
|
||||
|
||||
decimal64FromString(&a, argv[1], &set);
|
||||
// lay out the decimal64 as eight hexadecimal pairs
|
||||
for (i=0; i<8; i++) {
|
||||
sprintf(&hexes[i*3], "%02x ", a.bytes[i]);
|
||||
}
|
||||
decimal64ToNumber(&a, &d);
|
||||
decNumberToString(&d, string);
|
||||
printf("%s => %s=> %s\n", argv[1], hexes, string);
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,61 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example6.c -- calculate compound interest, using Packed Decimal
|
||||
// Values are investment, rate (%), and years
|
||||
|
||||
#include "decPacked.h" // base number library
|
||||
#include <stdio.h> // for printf
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
{ // excerpt for User's Guide starts here--------------------------|
|
||||
decNumber one, mtwo, hundred; // constants
|
||||
decNumber start, rate, years; // parameters
|
||||
decNumber total; // result
|
||||
decContext set; // working context
|
||||
|
||||
uint8_t startpack[]={0x01, 0x00, 0x00, 0x0C}; // investment=100000
|
||||
int32_t startscale=0;
|
||||
uint8_t ratepack[]={0x06, 0x5C}; // rate=6.5%
|
||||
int32_t ratescale=1;
|
||||
uint8_t yearspack[]={0x02, 0x0C}; // years=20
|
||||
int32_t yearsscale=0;
|
||||
uint8_t respack[16]; // result, packed
|
||||
int32_t resscale; // ..
|
||||
char hexes[49]; // for packed->hex
|
||||
int i; // counter
|
||||
|
||||
if (argc<0) printf("%s", argv[1]); // noop for warning
|
||||
|
||||
decContextDefault(&set, DEC_INIT_BASE); // initialize
|
||||
set.traps=0; // no traps
|
||||
set.digits=25; // precision 25
|
||||
decNumberFromString(&one, "1", &set); // set constants
|
||||
decNumberFromString(&mtwo, "-2", &set);
|
||||
decNumberFromString(&hundred, "100", &set);
|
||||
|
||||
decPackedToNumber(startpack, sizeof(startpack), &startscale, &start);
|
||||
decPackedToNumber(ratepack, sizeof(ratepack), &ratescale, &rate);
|
||||
decPackedToNumber(yearspack, sizeof(yearspack), &yearsscale, &years);
|
||||
|
||||
decNumberDivide(&rate, &rate, &hundred, &set); // rate=rate/100
|
||||
decNumberAdd(&rate, &rate, &one, &set); // rate=rate+1
|
||||
decNumberPower(&rate, &rate, &years, &set); // rate=rate^years
|
||||
decNumberMultiply(&total, &rate, &start, &set); // total=rate*start
|
||||
decNumberRescale(&total, &total, &mtwo, &set); // two digits please
|
||||
|
||||
decPackedFromNumber(respack, sizeof(respack), &resscale, &total);
|
||||
|
||||
// lay out the total as sixteen hexadecimal pairs
|
||||
for (i=0; i<16; i++) {
|
||||
sprintf(&hexes[i*3], "%02x ", respack[i]);
|
||||
}
|
||||
printf("Result: %s (scale=%ld)\n", hexes, (long int)resscale);
|
||||
|
||||
} //---------------------------------------------------------------|
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,35 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001, 2008. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example7.c -- using decQuad to add two numbers together
|
||||
|
||||
// compile: example7.c decContext.c decQuad.c
|
||||
|
||||
#include "decQuad.h" // decQuad library
|
||||
#include <stdio.h> // for printf
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
decQuad a, b; // working decQuads
|
||||
decContext set; // working context
|
||||
char string[DECQUAD_String]; // number->string buffer
|
||||
|
||||
decContextTestEndian(0); // warn if DECLITEND is wrong
|
||||
|
||||
if (argc<3) { // not enough words
|
||||
printf("Please supply two numbers to add.\n");
|
||||
return 1;
|
||||
}
|
||||
decContextDefault(&set, DEC_INIT_DECQUAD); // initialize
|
||||
|
||||
decQuadFromString(&a, argv[1], &set);
|
||||
decQuadFromString(&b, argv[2], &set);
|
||||
decQuadAdd(&a, &a, &b, &set); // a=a+b
|
||||
decQuadToString(&a, string);
|
||||
|
||||
printf("%s + %s => %s\n", argv[1], argv[2], string);
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,39 @@
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Decimal Number Library Demonstration program */
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Copyright (c) IBM Corporation, 2001, 2007. All rights reserved. */
|
||||
/* ----------------------------------------------------------------+- */
|
||||
/* right margin -->| */
|
||||
|
||||
// example8.c -- using decQuad with the decNumber module
|
||||
|
||||
// compile: example8.c decContext.c decQuad.c
|
||||
// and: decNumber.c decimal128.c decimal64.c
|
||||
|
||||
#include "decQuad.h" // decQuad library
|
||||
#include "decimal128.h" // interface to decNumber
|
||||
#include <stdio.h> // for printf
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
decQuad a; // working decQuad
|
||||
decNumber numa, numb; // working decNumbers
|
||||
decContext set; // working context
|
||||
char string[DECQUAD_String]; // number->string buffer
|
||||
|
||||
if (argc<3) { // not enough words
|
||||
printf("Please supply two numbers for power(2*a, b).\n");
|
||||
return 1;
|
||||
}
|
||||
decContextDefault(&set, DEC_INIT_DECQUAD); // initialize
|
||||
|
||||
decQuadFromString(&a, argv[1], &set); // get a
|
||||
decQuadAdd(&a, &a, &a, &set); // double a
|
||||
decQuadToNumber(&a, &numa); // convert to decNumber
|
||||
decNumberFromString(&numb, argv[2], &set);
|
||||
decNumberPower(&numa, &numa, &numb, &set); // numa=numa**numb
|
||||
decQuadFromNumber(&a, &numa, &set); // back via a Quad
|
||||
decQuadToString(&a, string); // ..
|
||||
|
||||
printf("power(2*%s, %s) => %s\n", argv[1], argv[2], string);
|
||||
return 0;
|
||||
} // main
|
||||
@@ -0,0 +1,81 @@
|
||||
This is the readme.txt for the decNumber package. It includes
|
||||
instructions for compiling and testing the package; please read them.
|
||||
---------------------------------------------------------------------
|
||||
|
||||
decNumber is distributed in two forms; as a complete package from
|
||||
the International Components for Unicode (ICU) site (under an as-is
|
||||
license), or as a collection of Open Source files from the GCC source
|
||||
repository (under the GPL license).
|
||||
|
||||
If you are using the GCC files, you can obtain the documentation, the
|
||||
example files mentioned below, and this readme from the General
|
||||
Decimal Arithmetic web page -- http://speleotrove.com/decimal/ (the
|
||||
URL for the open source files is also linked from there).
|
||||
|
||||
|
||||
The ICU package
|
||||
---------------
|
||||
|
||||
The ICU package includes the files:
|
||||
|
||||
* readme.txt (this file)
|
||||
|
||||
* ICU-license.html
|
||||
|
||||
* decNumber.pdf (documentation)
|
||||
|
||||
* The .c and .h file for each module in the package (see the
|
||||
decNumber documentation), together with other included files.
|
||||
|
||||
* The .c files for each of the examples (example1.c through
|
||||
example8.c).
|
||||
|
||||
The ICU package is made available under the terms of the ICU License
|
||||
(ICU 1.8.1 and later) included in the package as ICU-license.html.
|
||||
Your use of that package indicates your acceptance of the terms and
|
||||
conditions of that Agreement.
|
||||
|
||||
|
||||
To use and check decNumber
|
||||
--------------------------
|
||||
|
||||
Please read the appropriate license and documentation before using
|
||||
this package. If you are upgrading an existing use of decNumber
|
||||
(with version <= 3.37) please read the Changes Appendix for later
|
||||
versions -- you may need to change the DECLITEND flag.
|
||||
|
||||
1. Compile and link example1.c, decNumber.c, and decContext.c
|
||||
For instance, use:
|
||||
|
||||
gcc -o example1 example1.c decNumber.c decContext.c
|
||||
|
||||
Note: If your compiler does not provide stdint.h or if your C
|
||||
compiler does not handle line comments (// ...), then see the
|
||||
User's Guide section in the documentation for further information
|
||||
(including a sample minimal stdint.h).
|
||||
|
||||
The use of compiler optimization is strongly recommended (e.g.,
|
||||
-O3 for GCC or /O2 for Visual Studio).
|
||||
|
||||
2. Run example1 with two numeric arguments, for example:
|
||||
|
||||
example1 1.23 1.27
|
||||
|
||||
this should display:
|
||||
|
||||
1.23 + 1.27 => 2.50
|
||||
|
||||
3. Similarly, try the other examples, at will.
|
||||
|
||||
Examples 2->4 require three files to be compiled, like Example 1.
|
||||
|
||||
Example 5 requires decimal64.c in addition to the core modules.
|
||||
|
||||
Example 6 requires decPacked.c in addition to the core modules.
|
||||
|
||||
Example 7 requires only example7.c decContext.c and decQuad.c
|
||||
|
||||
Example 8 requires example8.c, decContext.c, and decQuad.c, plus
|
||||
decNumber.c, decimal128.c, and decimal64.c (the latter
|
||||
for shared tables and code)
|
||||
|
||||
+12
-5
@@ -292,7 +292,7 @@ uint16_t* stack_restore(jq_state *jq){
|
||||
assert(path_len >= 0);
|
||||
jq->path = jv_array_slice(jq->path, 0, path_len);
|
||||
} else {
|
||||
assert(path_len == 0);
|
||||
fork->path_len = 0;
|
||||
}
|
||||
jv_free(jq->value_at_path);
|
||||
jq->value_at_path = fork->value_at_path;
|
||||
@@ -509,21 +509,25 @@ jv jq_next(jq_state *jq) {
|
||||
uint16_t v = *pc++;
|
||||
jv* var = frame_local_var(jq, v, level);
|
||||
jv max = stack_pop(jq);
|
||||
if (raising) goto do_backtrack;
|
||||
if (raising) {
|
||||
jv_free(max);
|
||||
goto do_backtrack;
|
||||
}
|
||||
if (jv_get_kind(*var) != JV_KIND_NUMBER ||
|
||||
jv_get_kind(max) != JV_KIND_NUMBER) {
|
||||
set_error(jq, jv_invalid_with_msg(jv_string_fmt("Range bounds must be numeric")));
|
||||
jv_free(max);
|
||||
goto do_backtrack;
|
||||
} else if (jv_number_value(jv_copy(*var)) >= jv_number_value(jv_copy(max))) {
|
||||
} else if (jv_number_value(*var) >= jv_number_value(max)) {
|
||||
/* finished iterating */
|
||||
jv_free(max);
|
||||
goto do_backtrack;
|
||||
} else {
|
||||
jv curr = jv_copy(*var);
|
||||
jv curr = *var;
|
||||
*var = jv_number(jv_number_value(*var) + 1);
|
||||
|
||||
struct stack_pos spos = stack_get_pos(jq);
|
||||
stack_push(jq, jv_copy(max));
|
||||
stack_push(jq, max);
|
||||
stack_save(jq, pc - 3, spos);
|
||||
|
||||
stack_push(jq, curr);
|
||||
@@ -1010,6 +1014,9 @@ jq_state *jq_init(void) {
|
||||
jq->attrs = jv_object();
|
||||
jq->path = jv_null();
|
||||
jq->value_at_path = jv_null();
|
||||
|
||||
jq->nomem_handler = NULL;
|
||||
jq->nomem_handler_data = NULL;
|
||||
return jq;
|
||||
}
|
||||
|
||||
|
||||
+66
-9
@@ -6,20 +6,32 @@
|
||||
#include "jq.h"
|
||||
|
||||
static void jv_test();
|
||||
static void run_jq_tests(jv, int, FILE *);
|
||||
static void run_jq_tests(jv, int, FILE *, int, int);
|
||||
|
||||
|
||||
int jq_testsuite(jv libdirs, int verbose, int argc, char* argv[]) {
|
||||
FILE *testdata = stdin;
|
||||
int skip = -1;
|
||||
int take = -1;
|
||||
jv_test();
|
||||
if (argc > 0) {
|
||||
testdata = fopen(argv[0], "r");
|
||||
if (!testdata) {
|
||||
perror("fopen");
|
||||
exit(1);
|
||||
for(int i = 0; i < argc; i++) {
|
||||
if (!strcmp(argv[i], "--skip")) {
|
||||
skip = atoi(argv[i+1]);
|
||||
i++;
|
||||
} else if (!strcmp(argv[i], "--take")) {
|
||||
take = atoi(argv[i+1]);
|
||||
i++;
|
||||
} else {
|
||||
testdata = fopen(argv[i], "r");
|
||||
if (!testdata) {
|
||||
perror("fopen");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
run_jq_tests(libdirs, verbose, testdata);
|
||||
run_jq_tests(libdirs, verbose, testdata, skip, take);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -53,7 +65,7 @@ static void test_err_cb(void *data, jv e) {
|
||||
jv_free(e);
|
||||
}
|
||||
|
||||
static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
|
||||
static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int take) {
|
||||
char prog[4096];
|
||||
char buf[4096];
|
||||
struct err_data err_msg;
|
||||
@@ -63,6 +75,9 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
|
||||
int check_msg = 0;
|
||||
jq_state *jq = NULL;
|
||||
|
||||
int tests_to_skip = skip > 0 ? skip : 0;
|
||||
int tests_to_take = take;
|
||||
|
||||
jq = jq_init();
|
||||
assert(jq);
|
||||
if (jv_get_kind(lib_dirs) == JV_KIND_NULL)
|
||||
@@ -80,9 +95,37 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
|
||||
continue;
|
||||
}
|
||||
if (prog[strlen(prog)-1] == '\n') prog[strlen(prog)-1] = 0;
|
||||
printf("Testing '%s' at line number %u\n", prog, lineno);
|
||||
|
||||
if (skip > 0) {
|
||||
skip--;
|
||||
|
||||
// skip past test data
|
||||
while (fgets(buf, sizeof(buf), testdata)) {
|
||||
lineno++;
|
||||
if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
|
||||
break;
|
||||
}
|
||||
|
||||
must_fail = 0;
|
||||
check_msg = 0;
|
||||
|
||||
continue;
|
||||
} else if (skip == 0) {
|
||||
printf("Skipped %d tests\n", tests_to_skip);
|
||||
skip = -1;
|
||||
}
|
||||
|
||||
if (take > 0) {
|
||||
take--;
|
||||
} else if (take == 0) {
|
||||
printf("Hit the number of tests limit (%d), breaking\n", tests_to_take);
|
||||
take = -1;
|
||||
break;
|
||||
}
|
||||
|
||||
int pass = 1;
|
||||
tests++;
|
||||
printf("Test #%d: '%s' at line number %u\n", tests + tests_to_skip, prog, lineno);
|
||||
int compiled = jq_compile(jq, prog);
|
||||
|
||||
if (must_fail) {
|
||||
@@ -179,7 +222,21 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
|
||||
passed+=pass;
|
||||
}
|
||||
jq_teardown(&jq);
|
||||
printf("%d of %d tests passed (%d malformed)\n", passed,tests,invalid);
|
||||
|
||||
int total_skipped = tests_to_skip;
|
||||
|
||||
if (skip > 0) {
|
||||
total_skipped = tests_to_skip - skip;
|
||||
}
|
||||
|
||||
printf("%d of %d tests passed (%d malformed, %d skipped)\n",
|
||||
passed, tests, invalid, total_skipped);
|
||||
|
||||
if (skip > 0) {
|
||||
printf("WARN: skipped past the end of file, exiting with status 2\n");
|
||||
exit(2);
|
||||
}
|
||||
|
||||
if (passed != tests) exit(1);
|
||||
}
|
||||
|
||||
|
||||
@@ -54,16 +54,19 @@ jv jv_invalid_with_msg(jv);
|
||||
jv jv_invalid_get_msg(jv);
|
||||
int jv_invalid_has_msg(jv);
|
||||
|
||||
|
||||
jv jv_null(void);
|
||||
jv jv_true(void);
|
||||
jv jv_false(void);
|
||||
jv jv_bool(int);
|
||||
|
||||
jv jv_number(double);
|
||||
jv jv_number_with_literal(const char*);
|
||||
double jv_number_value(jv);
|
||||
int jv_is_integer(jv);
|
||||
|
||||
int jv_number_has_literal(jv n);
|
||||
const char* jv_number_get_literal(jv);
|
||||
|
||||
jv jv_array(void);
|
||||
jv jv_array_sized(int);
|
||||
int jv_array_length(jv);
|
||||
|
||||
+7
-7
@@ -37,7 +37,7 @@ static void memory_exhausted() {
|
||||
if (nomem_handler.handler)
|
||||
nomem_handler.handler(nomem_handler.data); // Maybe handler() will longjmp() to safety
|
||||
// Or not
|
||||
fprintf(stderr, "error: cannot allocate memory\n");
|
||||
fprintf(stderr, "jq: error: cannot allocate memory\n");
|
||||
abort();
|
||||
}
|
||||
#else /* USE_TLS */
|
||||
@@ -59,16 +59,16 @@ static void tsd_fini(void) {
|
||||
|
||||
static void tsd_init(void) {
|
||||
if (pthread_key_create(&nomem_handler_key, NULL) != 0) {
|
||||
fprintf(stderr, "error: cannot create thread specific key");
|
||||
fprintf(stderr, "jq: error: cannot create thread specific key");
|
||||
abort();
|
||||
}
|
||||
if (atexit(tsd_fini) != 0) {
|
||||
fprintf(stderr, "error: cannot set an exit handler");
|
||||
fprintf(stderr, "jq: error: cannot set an exit handler");
|
||||
abort();
|
||||
}
|
||||
struct nomem_handler *nomem_handler = calloc(1, sizeof(struct nomem_handler));
|
||||
if (pthread_setspecific(nomem_handler_key, nomem_handler) != 0) {
|
||||
fprintf(stderr, "error: cannot set thread specific data");
|
||||
fprintf(stderr, "jq: error: cannot set thread specific data");
|
||||
abort();
|
||||
}
|
||||
}
|
||||
@@ -80,7 +80,7 @@ void jv_nomem_handler(jv_nomem_handler_f handler, void *data) {
|
||||
nomem_handler = pthread_getspecific(nomem_handler_key);
|
||||
if (nomem_handler == NULL) {
|
||||
handler(data);
|
||||
fprintf(stderr, "error: cannot allocate memory\n");
|
||||
fprintf(stderr, "jq: error: cannot allocate memory\n");
|
||||
abort();
|
||||
}
|
||||
nomem_handler->handler = handler;
|
||||
@@ -95,7 +95,7 @@ static void memory_exhausted() {
|
||||
if (nomem_handler)
|
||||
nomem_handler->handler(nomem_handler->data); // Maybe handler() will longjmp() to safety
|
||||
// Or not
|
||||
fprintf(stderr, "error: cannot allocate memory\n");
|
||||
fprintf(stderr, "jq: error: cannot allocate memory\n");
|
||||
abort();
|
||||
}
|
||||
|
||||
@@ -110,7 +110,7 @@ void jv_nomem_handler(jv_nomem_handler_f handler, void *data) {
|
||||
}
|
||||
|
||||
static void memory_exhausted() {
|
||||
fprintf(stderr, "error: cannot allocate memory\n");
|
||||
fprintf(stderr, "jq: error: cannot allocate memory\n");
|
||||
abort();
|
||||
}
|
||||
|
||||
|
||||
+27
-12
@@ -2,6 +2,16 @@
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include "jv_alloc.h"
|
||||
#include "jv_type_private.h"
|
||||
|
||||
// making this static verbose function here
|
||||
// until we introduce a less confusing naming scheme
|
||||
// of jv_* API with regards to the memory management
|
||||
static double jv_number_get_value_and_consume(jv number) {
|
||||
double value = jv_number_value(number);
|
||||
jv_free(number);
|
||||
return value;
|
||||
}
|
||||
|
||||
static int parse_slice(jv j, jv slice, int* pstart, int* pend) {
|
||||
// Array slices
|
||||
@@ -32,6 +42,8 @@ static int parse_slice(jv j, jv slice, int* pstart, int* pend) {
|
||||
} else {
|
||||
double dstart = jv_number_value(start_jv);
|
||||
double dend = jv_number_value(end_jv);
|
||||
jv_free(start_jv);
|
||||
jv_free(end_jv);
|
||||
if (dstart < 0) dstart += len;
|
||||
if (dend < 0) dend += len;
|
||||
if (dstart < 0) dstart = 0;
|
||||
@@ -69,6 +81,7 @@ jv jv_get(jv t, jv k) {
|
||||
jv_free(v);
|
||||
v = jv_null();
|
||||
}
|
||||
jv_free(k);
|
||||
} else {
|
||||
jv_free(t);
|
||||
jv_free(k);
|
||||
@@ -135,6 +148,7 @@ jv jv_set(jv t, jv k, jv v) {
|
||||
(jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
|
||||
if (isnull) t = jv_array();
|
||||
t = jv_array_set(t, (int)jv_number_value(k), v);
|
||||
jv_free(k);
|
||||
} else if (jv_get_kind(k) == JV_KIND_OBJECT &&
|
||||
(jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
|
||||
if (isnull) t = jv_array();
|
||||
@@ -202,6 +216,7 @@ jv jv_has(jv t, jv k) {
|
||||
jv_get_kind(k) == JV_KIND_NUMBER) {
|
||||
jv elem = jv_array_get(t, (int)jv_number_value(k));
|
||||
ret = jv_bool(jv_is_valid(elem));
|
||||
jv_free(k);
|
||||
jv_free(elem);
|
||||
} else {
|
||||
ret = jv_invalid_with_msg(jv_string_fmt("Cannot check whether %s has a %s key",
|
||||
@@ -240,6 +255,7 @@ static jv jv_dels(jv t, jv keys) {
|
||||
ends = jv_array_append(ends, jv_number(end));
|
||||
} else {
|
||||
jv_free(new_array);
|
||||
jv_free(key);
|
||||
new_array = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an array slice must be numbers"));
|
||||
goto arr_out;
|
||||
}
|
||||
@@ -258,7 +274,7 @@ static jv jv_dels(jv t, jv keys) {
|
||||
jv_array_foreach(t, i, elem) {
|
||||
int del = 0;
|
||||
while (neg_idx < jv_array_length(jv_copy(neg_keys))) {
|
||||
int delidx = len + (int)jv_number_value(jv_array_get(jv_copy(neg_keys), neg_idx));
|
||||
int delidx = len + (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(neg_keys), neg_idx));
|
||||
if (i == delidx) {
|
||||
del = 1;
|
||||
}
|
||||
@@ -268,7 +284,7 @@ static jv jv_dels(jv t, jv keys) {
|
||||
neg_idx++;
|
||||
}
|
||||
while (nonneg_idx < jv_array_length(jv_copy(nonneg_keys))) {
|
||||
int delidx = (int)jv_number_value(jv_array_get(jv_copy(nonneg_keys), nonneg_idx));
|
||||
int delidx = (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(nonneg_keys), nonneg_idx));
|
||||
if (i == delidx) {
|
||||
del = 1;
|
||||
}
|
||||
@@ -278,8 +294,8 @@ static jv jv_dels(jv t, jv keys) {
|
||||
nonneg_idx++;
|
||||
}
|
||||
for (int sidx=0; !del && sidx<jv_array_length(jv_copy(starts)); sidx++) {
|
||||
if ((int)jv_number_value(jv_array_get(jv_copy(starts), sidx)) <= i &&
|
||||
i < (int)jv_number_value(jv_array_get(jv_copy(ends), sidx))) {
|
||||
if ((int)jv_number_get_value_and_consume(jv_array_get(jv_copy(starts), sidx)) <= i &&
|
||||
i < (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(ends), sidx))) {
|
||||
del = 1;
|
||||
}
|
||||
}
|
||||
@@ -511,14 +527,13 @@ int jv_cmp(jv a, jv b) {
|
||||
break;
|
||||
|
||||
case JV_KIND_NUMBER: {
|
||||
double da = jv_number_value(a), db = jv_number_value(b);
|
||||
|
||||
// handle NaN as though it were null
|
||||
if (da != da) r = jv_cmp(jv_null(), jv_number(db));
|
||||
else if (db != db) r = jv_cmp(jv_number(da), jv_null());
|
||||
else if (da < db) r = -1;
|
||||
else if (da == db) r = 0;
|
||||
else r = 1;
|
||||
if (jvp_number_is_nan(a)) {
|
||||
r = jv_cmp(jv_null(), jv_copy(b));
|
||||
} else if (jvp_number_is_nan(b)) {
|
||||
r = jv_cmp(jv_copy(a), jv_null());
|
||||
} else {
|
||||
r = jvp_number_cmp(a, b);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#include "jv_dtoa_tsd.h"
|
||||
#include "jv_dtoa.h"
|
||||
#include "jv_alloc.h"
|
||||
|
||||
|
||||
static pthread_key_t dtoa_ctx_key;
|
||||
static pthread_once_t dtoa_ctx_once = PTHREAD_ONCE_INIT;
|
||||
|
||||
static void tsd_dtoa_ctx_dtor(struct dtoa_context *ctx) {
|
||||
if (ctx) {
|
||||
jvp_dtoa_context_free(ctx);
|
||||
jv_mem_free(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
static void tsd_dtoa_ctx_fini() {
|
||||
struct dtoa_context *ctx = pthread_getspecific(dtoa_ctx_key);
|
||||
tsd_dtoa_ctx_dtor(ctx);
|
||||
pthread_setspecific(dtoa_ctx_key, NULL);
|
||||
}
|
||||
|
||||
static void tsd_dtoa_ctx_init() {
|
||||
if (pthread_key_create(&dtoa_ctx_key, tsd_dtoa_ctx_dtor) != 0) {
|
||||
fprintf(stderr, "error: cannot create thread specific key");
|
||||
abort();
|
||||
}
|
||||
atexit(tsd_dtoa_ctx_fini);
|
||||
}
|
||||
|
||||
inline struct dtoa_context *tsd_dtoa_context_get() {
|
||||
pthread_once(&dtoa_ctx_once, tsd_dtoa_ctx_init); // cannot fail
|
||||
struct dtoa_context *ctx = (struct dtoa_context*)pthread_getspecific(dtoa_ctx_key);
|
||||
if (!ctx) {
|
||||
ctx = malloc(sizeof(struct dtoa_context));
|
||||
jvp_dtoa_context_init(ctx);
|
||||
if (pthread_setspecific(dtoa_ctx_key, ctx) != 0) {
|
||||
fprintf(stderr, "error: cannot set thread specific data");
|
||||
abort();
|
||||
}
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
#ifndef JV_DTOA_TSD_H
|
||||
#define JV_DTOA_TSD_H
|
||||
struct dtoa_context *tsd_dtoa_context_get();
|
||||
#endif
|
||||
+24
-6
@@ -124,14 +124,19 @@ static void parser_free(struct jv_parser* p) {
|
||||
|
||||
static pfunc value(struct jv_parser* p, jv val) {
|
||||
if ((p->flags & JV_PARSE_STREAMING)) {
|
||||
if (jv_is_valid(p->next) || p->last_seen == JV_LAST_VALUE)
|
||||
if (jv_is_valid(p->next) || p->last_seen == JV_LAST_VALUE) {
|
||||
jv_free(val);
|
||||
return "Expected separator between values";
|
||||
}
|
||||
if (p->stacklen > 0)
|
||||
p->last_seen = JV_LAST_VALUE;
|
||||
else
|
||||
p->last_seen = JV_LAST_NONE;
|
||||
} else {
|
||||
if (jv_is_valid(p->next)) return "Expected separator between values";
|
||||
if (jv_is_valid(p->next)) {
|
||||
jv_free(val);
|
||||
return "Expected separator between values";
|
||||
}
|
||||
}
|
||||
jv_free(p->next);
|
||||
p->next = val;
|
||||
@@ -256,8 +261,12 @@ static pfunc stream_token(struct jv_parser* p, char ch) {
|
||||
break;
|
||||
|
||||
case ':':
|
||||
if (p->stacklen == 0 || jv_get_kind(jv_array_get(jv_copy(p->path), p->stacklen - 1)) == JV_KIND_NUMBER)
|
||||
last = jv_invalid();
|
||||
if (p->stacklen == 0 || jv_get_kind(last = jv_array_get(jv_copy(p->path), p->stacklen - 1)) == JV_KIND_NUMBER) {
|
||||
jv_free(last);
|
||||
return "':' not as part of an object";
|
||||
}
|
||||
jv_free(last);
|
||||
if (!jv_is_valid(p->next) || p->last_seen == JV_LAST_NONE)
|
||||
return "Expected string key before ':'";
|
||||
if (jv_get_kind(p->next) != JV_KIND_STRING)
|
||||
@@ -492,11 +501,20 @@ static pfunc check_literal(struct jv_parser* p) {
|
||||
} else {
|
||||
// FIXME: better parser
|
||||
p->tokenbuf[p->tokenpos] = 0;
|
||||
char* end = 0;
|
||||
double d = jvp_strtod(&p->dtoa, p->tokenbuf, &end);
|
||||
if (end == 0 || *end != 0)
|
||||
#ifdef USE_DECNUM
|
||||
jv number = jv_number_with_literal(p->tokenbuf);
|
||||
if (jv_get_kind(number) == JV_KIND_INVALID) {
|
||||
return "Invalid numeric literal";
|
||||
}
|
||||
TRY(value(p, number));
|
||||
#else
|
||||
char *end = 0;
|
||||
double d = jvp_strtod(&p->dtoa, p->tokenbuf, &end);
|
||||
if (end == 0 || *end != 0) {
|
||||
return "Invalid numeric literal";
|
||||
}
|
||||
TRY(value(p, jv_number(d)));
|
||||
#endif
|
||||
}
|
||||
p->tokenpos = 0;
|
||||
return 0;
|
||||
|
||||
+25
-16
@@ -11,8 +11,10 @@
|
||||
|
||||
#include "jv.h"
|
||||
#include "jv_dtoa.h"
|
||||
#include "jv_dtoa_tsd.h"
|
||||
#include "jv_unicode.h"
|
||||
#include "jv_alloc.h"
|
||||
#include "jv_type_private.h"
|
||||
|
||||
#ifndef MAX_PRINT_DEPTH
|
||||
#define MAX_PRINT_DEPTH (256)
|
||||
@@ -229,16 +231,29 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
|
||||
put_str("true", F, S, flags & JV_PRINT_ISATTY);
|
||||
break;
|
||||
case JV_KIND_NUMBER: {
|
||||
double d = jv_number_value(x);
|
||||
if (d != d) {
|
||||
// JSON doesn't have NaN, so we'll render it as "null"
|
||||
put_str("null", F, S, flags & JV_PRINT_ISATTY);
|
||||
if (jvp_number_is_nan(x)) {
|
||||
jv_dump_term(C, jv_null(), flags, indent, F, S);
|
||||
} else {
|
||||
// Normalise infinities to something we can print in valid JSON
|
||||
if (d > DBL_MAX) d = DBL_MAX;
|
||||
if (d < -DBL_MAX) d = -DBL_MAX;
|
||||
put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY);
|
||||
#ifdef USE_DECNUM
|
||||
const char * literal_data = jv_number_get_literal(x);
|
||||
if (literal_data) {
|
||||
put_str(literal_data, F, S, flags & JV_PRINT_ISATTY);
|
||||
} else {
|
||||
#endif
|
||||
double d = jv_number_value(x);
|
||||
if (d != d) {
|
||||
// JSON doesn't have NaN, so we'll render it as "null"
|
||||
put_str("null", F, S, flags & JV_PRINT_ISATTY);
|
||||
} else {
|
||||
// Normalise infinities to something we can print in valid JSON
|
||||
if (d > DBL_MAX) d = DBL_MAX;
|
||||
if (d < -DBL_MAX) d = -DBL_MAX;
|
||||
put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY);
|
||||
}
|
||||
}
|
||||
#ifdef USE_DECNUM
|
||||
}
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
case JV_KIND_STRING:
|
||||
@@ -357,10 +372,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
|
||||
}
|
||||
|
||||
void jv_dumpf(jv x, FILE *f, int flags) {
|
||||
struct dtoa_context C;
|
||||
jvp_dtoa_context_init(&C);
|
||||
jv_dump_term(&C, x, flags, 0, f, 0);
|
||||
jvp_dtoa_context_free(&C);
|
||||
jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, f, 0);
|
||||
}
|
||||
|
||||
void jv_dump(jv x, int flags) {
|
||||
@@ -376,11 +388,8 @@ void jv_show(jv x, int flags) {
|
||||
}
|
||||
|
||||
jv jv_dump_string(jv x, int flags) {
|
||||
struct dtoa_context C;
|
||||
jvp_dtoa_context_init(&C);
|
||||
jv s = jv_string("");
|
||||
jv_dump_term(&C, x, flags, 0, 0, &s);
|
||||
jvp_dtoa_context_free(&C);
|
||||
jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, 0, &s);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
#ifndef JV_TYPE_PRIVATE
|
||||
#define JV_TYPE_PRIVATE
|
||||
|
||||
int jvp_number_cmp(jv, jv);
|
||||
int jvp_number_is_nan(jv);
|
||||
|
||||
#endif //JV_TYPE_PRIVATE
|
||||
+491
-283
File diff suppressed because it is too large.
Load diff
+434
-61
@@ -13,11 +13,245 @@
|
||||
#define FLEX_SCANNER
|
||||
#define YY_FLEX_MAJOR_VERSION 2
|
||||
#define YY_FLEX_MINOR_VERSION 6
|
||||
#define YY_FLEX_SUBMINOR_VERSION 0
|
||||
#define YY_FLEX_SUBMINOR_VERSION 4
|
||||
#if YY_FLEX_SUBMINOR_VERSION > 0
|
||||
#define FLEX_BETA
|
||||
#endif
|
||||
|
||||
#ifdef yy_create_buffer
|
||||
#define jq_yy_create_buffer_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_create_buffer jq_yy_create_buffer
|
||||
#endif
|
||||
|
||||
#ifdef yy_delete_buffer
|
||||
#define jq_yy_delete_buffer_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_delete_buffer jq_yy_delete_buffer
|
||||
#endif
|
||||
|
||||
#ifdef yy_scan_buffer
|
||||
#define jq_yy_scan_buffer_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_scan_buffer jq_yy_scan_buffer
|
||||
#endif
|
||||
|
||||
#ifdef yy_scan_string
|
||||
#define jq_yy_scan_string_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_scan_string jq_yy_scan_string
|
||||
#endif
|
||||
|
||||
#ifdef yy_scan_bytes
|
||||
#define jq_yy_scan_bytes_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_scan_bytes jq_yy_scan_bytes
|
||||
#endif
|
||||
|
||||
#ifdef yy_init_buffer
|
||||
#define jq_yy_init_buffer_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_init_buffer jq_yy_init_buffer
|
||||
#endif
|
||||
|
||||
#ifdef yy_flush_buffer
|
||||
#define jq_yy_flush_buffer_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_flush_buffer jq_yy_flush_buffer
|
||||
#endif
|
||||
|
||||
#ifdef yy_load_buffer_state
|
||||
#define jq_yy_load_buffer_state_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_load_buffer_state jq_yy_load_buffer_state
|
||||
#endif
|
||||
|
||||
#ifdef yy_switch_to_buffer
|
||||
#define jq_yy_switch_to_buffer_ALREADY_DEFINED
|
||||
#else
|
||||
#define yy_switch_to_buffer jq_yy_switch_to_buffer
|
||||
#endif
|
||||
|
||||
#ifdef yypush_buffer_state
|
||||
#define jq_yypush_buffer_state_ALREADY_DEFINED
|
||||
#else
|
||||
#define yypush_buffer_state jq_yypush_buffer_state
|
||||
#endif
|
||||
|
||||
#ifdef yypop_buffer_state
|
||||
#define jq_yypop_buffer_state_ALREADY_DEFINED
|
||||
#else
|
||||
#define yypop_buffer_state jq_yypop_buffer_state
|
||||
#endif
|
||||
|
||||
#ifdef yyensure_buffer_stack
|
||||
#define jq_yyensure_buffer_stack_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyensure_buffer_stack jq_yyensure_buffer_stack
|
||||
#endif
|
||||
|
||||
#ifdef yylex
|
||||
#define jq_yylex_ALREADY_DEFINED
|
||||
#else
|
||||
#define yylex jq_yylex
|
||||
#endif
|
||||
|
||||
#ifdef yyrestart
|
||||
#define jq_yyrestart_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyrestart jq_yyrestart
|
||||
#endif
|
||||
|
||||
#ifdef yylex_init
|
||||
#define jq_yylex_init_ALREADY_DEFINED
|
||||
#else
|
||||
#define yylex_init jq_yylex_init
|
||||
#endif
|
||||
|
||||
#ifdef yylex_init_extra
|
||||
#define jq_yylex_init_extra_ALREADY_DEFINED
|
||||
#else
|
||||
#define yylex_init_extra jq_yylex_init_extra
|
||||
#endif
|
||||
|
||||
#ifdef yylex_destroy
|
||||
#define jq_yylex_destroy_ALREADY_DEFINED
|
||||
#else
|
||||
#define yylex_destroy jq_yylex_destroy
|
||||
#endif
|
||||
|
||||
#ifdef yyget_debug
|
||||
#define jq_yyget_debug_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_debug jq_yyget_debug
|
||||
#endif
|
||||
|
||||
#ifdef yyset_debug
|
||||
#define jq_yyset_debug_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_debug jq_yyset_debug
|
||||
#endif
|
||||
|
||||
#ifdef yyget_extra
|
||||
#define jq_yyget_extra_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_extra jq_yyget_extra
|
||||
#endif
|
||||
|
||||
#ifdef yyset_extra
|
||||
#define jq_yyset_extra_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_extra jq_yyset_extra
|
||||
#endif
|
||||
|
||||
#ifdef yyget_in
|
||||
#define jq_yyget_in_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_in jq_yyget_in
|
||||
#endif
|
||||
|
||||
#ifdef yyset_in
|
||||
#define jq_yyset_in_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_in jq_yyset_in
|
||||
#endif
|
||||
|
||||
#ifdef yyget_out
|
||||
#define jq_yyget_out_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_out jq_yyget_out
|
||||
#endif
|
||||
|
||||
#ifdef yyset_out
|
||||
#define jq_yyset_out_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_out jq_yyset_out
|
||||
#endif
|
||||
|
||||
#ifdef yyget_leng
|
||||
#define jq_yyget_leng_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_leng jq_yyget_leng
|
||||
#endif
|
||||
|
||||
#ifdef yyget_text
|
||||
#define jq_yyget_text_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_text jq_yyget_text
|
||||
#endif
|
||||
|
||||
#ifdef yyget_lineno
|
||||
#define jq_yyget_lineno_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_lineno jq_yyget_lineno
|
||||
#endif
|
||||
|
||||
#ifdef yyset_lineno
|
||||
#define jq_yyset_lineno_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_lineno jq_yyset_lineno
|
||||
#endif
|
||||
|
||||
#ifdef yyget_column
|
||||
#define jq_yyget_column_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_column jq_yyget_column
|
||||
#endif
|
||||
|
||||
#ifdef yyset_column
|
||||
#define jq_yyset_column_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_column jq_yyset_column
|
||||
#endif
|
||||
|
||||
#ifdef yywrap
|
||||
#define jq_yywrap_ALREADY_DEFINED
|
||||
#else
|
||||
#define yywrap jq_yywrap
|
||||
#endif
|
||||
|
||||
#ifdef yyget_lval
|
||||
#define jq_yyget_lval_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_lval jq_yyget_lval
|
||||
#endif
|
||||
|
||||
#ifdef yyset_lval
|
||||
#define jq_yyset_lval_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_lval jq_yyset_lval
|
||||
#endif
|
||||
|
||||
#ifdef yyget_lloc
|
||||
#define jq_yyget_lloc_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyget_lloc jq_yyget_lloc
|
||||
#endif
|
||||
|
||||
#ifdef yyset_lloc
|
||||
#define jq_yyset_lloc_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyset_lloc jq_yyset_lloc
|
||||
#endif
|
||||
|
||||
#ifdef yyalloc
|
||||
#define jq_yyalloc_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyalloc jq_yyalloc
|
||||
#endif
|
||||
|
||||
#ifdef yyrealloc
|
||||
#define jq_yyrealloc_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyrealloc jq_yyrealloc
|
||||
#endif
|
||||
|
||||
#ifdef yyfree
|
||||
#define jq_yyfree_ALREADY_DEFINED
|
||||
#else
|
||||
#define yyfree jq_yyfree
|
||||
#endif
|
||||
|
||||
/* First, we deal with platform-specific or compiler-specific issues. */
|
||||
|
||||
/* begin standard C headers. */
|
||||
@@ -88,29 +322,23 @@ typedef unsigned int flex_uint32_t;
|
||||
#define UINT32_MAX (4294967295U)
|
||||
#endif
|
||||
|
||||
#ifndef SIZE_MAX
|
||||
#define SIZE_MAX (~(size_t)0)
|
||||
#endif
|
||||
|
||||
#endif /* ! C99 */
|
||||
|
||||
#endif /* ! FLEXINT_H */
|
||||
|
||||
#ifdef __cplusplus
|
||||
/* begin standard C++ headers. */
|
||||
|
||||
/* The "const" storage-class-modifier is valid. */
|
||||
#define YY_USE_CONST
|
||||
|
||||
#else /* ! __cplusplus */
|
||||
|
||||
/* C99 requires __STDC__ to be defined as 1. */
|
||||
#if defined (__STDC__)
|
||||
|
||||
#define YY_USE_CONST
|
||||
|
||||
#endif /* defined (__STDC__) */
|
||||
#endif /* ! __cplusplus */
|
||||
|
||||
#ifdef YY_USE_CONST
|
||||
/* TODO: this is always defined, so inline it */
|
||||
#define yyconst const
|
||||
|
||||
#if defined(__GNUC__) && __GNUC__ >= 3
|
||||
#define yynoreturn __attribute__((__noreturn__))
|
||||
#else
|
||||
#define yyconst
|
||||
#define yynoreturn
|
||||
#endif
|
||||
|
||||
/* An opaque pointer. */
|
||||
@@ -165,7 +393,7 @@ struct yy_buffer_state
|
||||
/* Size of input buffer in bytes, not including room for EOB
|
||||
* characters.
|
||||
*/
|
||||
yy_size_t yy_buf_size;
|
||||
int yy_buf_size;
|
||||
|
||||
/* Number of characters read into yy_ch_buf, not including EOB
|
||||
* characters.
|
||||
@@ -193,7 +421,7 @@ struct yy_buffer_state
|
||||
|
||||
int yy_bs_lineno; /**< The line count. */
|
||||
int yy_bs_column; /**< The column count. */
|
||||
|
||||
|
||||
/* Whether to try to fill the input buffer when we reach the
|
||||
* end of it.
|
||||
*/
|
||||
@@ -204,21 +432,21 @@ struct yy_buffer_state
|
||||
};
|
||||
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
|
||||
|
||||
void jq_yyrestart (FILE *input_file ,yyscan_t yyscanner );
|
||||
void jq_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE jq_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
|
||||
void jq_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void jq_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
|
||||
void jq_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
|
||||
void jq_yypop_buffer_state (yyscan_t yyscanner );
|
||||
void yyrestart ( FILE *input_file , yyscan_t yyscanner );
|
||||
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
|
||||
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
|
||||
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
|
||||
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
|
||||
void yypop_buffer_state ( yyscan_t yyscanner );
|
||||
|
||||
YY_BUFFER_STATE jq_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE jq_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE jq_yy_scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
|
||||
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
|
||||
|
||||
void *jq_yyalloc (yy_size_t ,yyscan_t yyscanner );
|
||||
void *jq_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
|
||||
void jq_yyfree (void * ,yyscan_t yyscanner );
|
||||
void *yyalloc ( yy_size_t , yyscan_t yyscanner );
|
||||
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
|
||||
void yyfree ( void * , yyscan_t yyscanner );
|
||||
|
||||
/* Begin user sect3 */
|
||||
|
||||
@@ -247,50 +475,50 @@ void jq_yyfree (void * ,yyscan_t yyscanner );
|
||||
|
||||
#define YY_EXTRA_TYPE int
|
||||
|
||||
int jq_yylex_init (yyscan_t* scanner);
|
||||
int yylex_init (yyscan_t* scanner);
|
||||
|
||||
int jq_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
|
||||
int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
|
||||
|
||||
/* Accessor methods to globals.
|
||||
These are made visible to non-reentrant scanners for convenience. */
|
||||
|
||||
int jq_yylex_destroy (yyscan_t yyscanner );
|
||||
int yylex_destroy ( yyscan_t yyscanner );
|
||||
|
||||
int jq_yyget_debug (yyscan_t yyscanner );
|
||||
int yyget_debug ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_debug (int debug_flag ,yyscan_t yyscanner );
|
||||
void yyset_debug ( int debug_flag , yyscan_t yyscanner );
|
||||
|
||||
YY_EXTRA_TYPE jq_yyget_extra (yyscan_t yyscanner );
|
||||
YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
|
||||
void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
|
||||
|
||||
FILE *jq_yyget_in (yyscan_t yyscanner );
|
||||
FILE *yyget_in ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_in (FILE * _in_str ,yyscan_t yyscanner );
|
||||
void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
|
||||
|
||||
FILE *jq_yyget_out (yyscan_t yyscanner );
|
||||
FILE *yyget_out ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_out (FILE * _out_str ,yyscan_t yyscanner );
|
||||
void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
|
||||
|
||||
yy_size_t jq_yyget_leng (yyscan_t yyscanner );
|
||||
int yyget_leng ( yyscan_t yyscanner );
|
||||
|
||||
char *jq_yyget_text (yyscan_t yyscanner );
|
||||
char *yyget_text ( yyscan_t yyscanner );
|
||||
|
||||
int jq_yyget_lineno (yyscan_t yyscanner );
|
||||
int yyget_lineno ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_lineno (int _line_number ,yyscan_t yyscanner );
|
||||
void yyset_lineno ( int _line_number , yyscan_t yyscanner );
|
||||
|
||||
int jq_yyget_column (yyscan_t yyscanner );
|
||||
int yyget_column ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_column (int _column_no ,yyscan_t yyscanner );
|
||||
void yyset_column ( int _column_no , yyscan_t yyscanner );
|
||||
|
||||
YYSTYPE * jq_yyget_lval (yyscan_t yyscanner );
|
||||
YYSTYPE * yyget_lval ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
|
||||
void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner );
|
||||
|
||||
YYLTYPE *jq_yyget_lloc (yyscan_t yyscanner );
|
||||
YYLTYPE *yyget_lloc ( yyscan_t yyscanner );
|
||||
|
||||
void jq_yyset_lloc (YYLTYPE * yylloc_param ,yyscan_t yyscanner );
|
||||
void yyset_lloc ( YYLTYPE * yylloc_param , yyscan_t yyscanner );
|
||||
|
||||
/* Macros after this point can all be overridden by user definitions in
|
||||
* section 1.
|
||||
@@ -298,18 +526,18 @@ void jq_yyset_lval (YYSTYPE * yylval_param ,yyscan_t yyscanner );
|
||||
|
||||
#ifndef YY_SKIP_YYWRAP
|
||||
#ifdef __cplusplus
|
||||
extern "C" int jq_yywrap (yyscan_t yyscanner );
|
||||
extern "C" int yywrap ( yyscan_t yyscanner );
|
||||
#else
|
||||
extern int jq_yywrap (yyscan_t yyscanner );
|
||||
extern int yywrap ( yyscan_t yyscanner );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef yytext_ptr
|
||||
static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
|
||||
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
|
||||
#endif
|
||||
|
||||
#ifdef YY_NEED_STRLEN
|
||||
static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
|
||||
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
|
||||
#endif
|
||||
|
||||
#ifndef YY_NO_INPUT
|
||||
@@ -337,10 +565,10 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
|
||||
#ifndef YY_DECL
|
||||
#define YY_DECL_IS_OURS 1
|
||||
|
||||
extern int jq_yylex \
|
||||
(YYSTYPE * yylval_param,YYLTYPE * yylloc_param ,yyscan_t yyscanner);
|
||||
extern int yylex \
|
||||
(YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner);
|
||||
|
||||
#define YY_DECL int jq_yylex \
|
||||
#define YY_DECL int yylex \
|
||||
(YYSTYPE * yylval_param, YYLTYPE * yylloc_param , yyscan_t yyscanner)
|
||||
#endif /* !YY_DECL */
|
||||
|
||||
@@ -358,9 +586,154 @@ extern int jq_yylex \
|
||||
#undef YY_DECL
|
||||
#endif
|
||||
|
||||
#ifndef jq_yy_create_buffer_ALREADY_DEFINED
|
||||
#undef yy_create_buffer
|
||||
#endif
|
||||
#ifndef jq_yy_delete_buffer_ALREADY_DEFINED
|
||||
#undef yy_delete_buffer
|
||||
#endif
|
||||
#ifndef jq_yy_scan_buffer_ALREADY_DEFINED
|
||||
#undef yy_scan_buffer
|
||||
#endif
|
||||
#ifndef jq_yy_scan_string_ALREADY_DEFINED
|
||||
#undef yy_scan_string
|
||||
#endif
|
||||
#ifndef jq_yy_scan_bytes_ALREADY_DEFINED
|
||||
#undef yy_scan_bytes
|
||||
#endif
|
||||
#ifndef jq_yy_init_buffer_ALREADY_DEFINED
|
||||
#undef yy_init_buffer
|
||||
#endif
|
||||
#ifndef jq_yy_flush_buffer_ALREADY_DEFINED
|
||||
#undef yy_flush_buffer
|
||||
#endif
|
||||
#ifndef jq_yy_load_buffer_state_ALREADY_DEFINED
|
||||
#undef yy_load_buffer_state
|
||||
#endif
|
||||
#ifndef jq_yy_switch_to_buffer_ALREADY_DEFINED
|
||||
#undef yy_switch_to_buffer
|
||||
#endif
|
||||
#ifndef jq_yypush_buffer_state_ALREADY_DEFINED
|
||||
#undef yypush_buffer_state
|
||||
#endif
|
||||
#ifndef jq_yypop_buffer_state_ALREADY_DEFINED
|
||||
#undef yypop_buffer_state
|
||||
#endif
|
||||
#ifndef jq_yyensure_buffer_stack_ALREADY_DEFINED
|
||||
#undef yyensure_buffer_stack
|
||||
#endif
|
||||
#ifndef jq_yylex_ALREADY_DEFINED
|
||||
#undef yylex
|
||||
#endif
|
||||
#ifndef jq_yyrestart_ALREADY_DEFINED
|
||||
#undef yyrestart
|
||||
#endif
|
||||
#ifndef jq_yylex_init_ALREADY_DEFINED
|
||||
#undef yylex_init
|
||||
#endif
|
||||
#ifndef jq_yylex_init_extra_ALREADY_DEFINED
|
||||
#undef yylex_init_extra
|
||||
#endif
|
||||
#ifndef jq_yylex_destroy_ALREADY_DEFINED
|
||||
#undef yylex_destroy
|
||||
#endif
|
||||
#ifndef jq_yyget_debug_ALREADY_DEFINED
|
||||
#undef yyget_debug
|
||||
#endif
|
||||
#ifndef jq_yyset_debug_ALREADY_DEFINED
|
||||
#undef yyset_debug
|
||||
#endif
|
||||
#ifndef jq_yyget_extra_ALREADY_DEFINED
|
||||
#undef yyget_extra
|
||||
#endif
|
||||
#ifndef jq_yyset_extra_ALREADY_DEFINED
|
||||
#undef yyset_extra
|
||||
#endif
|
||||
#ifndef jq_yyget_in_ALREADY_DEFINED
|
||||
#undef yyget_in
|
||||
#endif
|
||||
#ifndef jq_yyset_in_ALREADY_DEFINED
|
||||
#undef yyset_in
|
||||
#endif
|
||||
#ifndef jq_yyget_out_ALREADY_DEFINED
|
||||
#undef yyget_out
|
||||
#endif
|
||||
#ifndef jq_yyset_out_ALREADY_DEFINED
|
||||
#undef yyset_out
|
||||
#endif
|
||||
#ifndef jq_yyget_leng_ALREADY_DEFINED
|
||||
#undef yyget_leng
|
||||
#endif
|
||||
#ifndef jq_yyget_text_ALREADY_DEFINED
|
||||
#undef yyget_text
|
||||
#endif
|
||||
#ifndef jq_yyget_lineno_ALREADY_DEFINED
|
||||
#undef yyget_lineno
|
||||
#endif
|
||||
#ifndef jq_yyset_lineno_ALREADY_DEFINED
|
||||
#undef yyset_lineno
|
||||
#endif
|
||||
#ifndef jq_yyget_column_ALREADY_DEFINED
|
||||
#undef yyget_column
|
||||
#endif
|
||||
#ifndef jq_yyset_column_ALREADY_DEFINED
|
||||
#undef yyset_column
|
||||
#endif
|
||||
#ifndef jq_yywrap_ALREADY_DEFINED
|
||||
#undef yywrap
|
||||
#endif
|
||||
#ifndef jq_yyget_lval_ALREADY_DEFINED
|
||||
#undef yyget_lval
|
||||
#endif
|
||||
#ifndef jq_yyset_lval_ALREADY_DEFINED
|
||||
#undef yyset_lval
|
||||
#endif
|
||||
#ifndef jq_yyget_lloc_ALREADY_DEFINED
|
||||
#undef yyget_lloc
|
||||
#endif
|
||||
#ifndef jq_yyset_lloc_ALREADY_DEFINED
|
||||
#undef yyset_lloc
|
||||
#endif
|
||||
#ifndef jq_yyalloc_ALREADY_DEFINED
|
||||
#undef yyalloc
|
||||
#endif
|
||||
#ifndef jq_yyrealloc_ALREADY_DEFINED
|
||||
#undef yyrealloc
|
||||
#endif
|
||||
#ifndef jq_yyfree_ALREADY_DEFINED
|
||||
#undef yyfree
|
||||
#endif
|
||||
#ifndef jq_yytext_ALREADY_DEFINED
|
||||
#undef yytext
|
||||
#endif
|
||||
#ifndef jq_yyleng_ALREADY_DEFINED
|
||||
#undef yyleng
|
||||
#endif
|
||||
#ifndef jq_yyin_ALREADY_DEFINED
|
||||
#undef yyin
|
||||
#endif
|
||||
#ifndef jq_yyout_ALREADY_DEFINED
|
||||
#undef yyout
|
||||
#endif
|
||||
#ifndef jq_yy_flex_debug_ALREADY_DEFINED
|
||||
#undef yy_flex_debug
|
||||
#endif
|
||||
#ifndef jq_yylineno_ALREADY_DEFINED
|
||||
#undef yylineno
|
||||
#endif
|
||||
#ifndef jq_yytables_fload_ALREADY_DEFINED
|
||||
#undef yytables_fload
|
||||
#endif
|
||||
#ifndef jq_yytables_destroy_ALREADY_DEFINED
|
||||
#undef yytables_destroy
|
||||
#endif
|
||||
#ifndef jq_yyTABLES_NAME_ALREADY_DEFINED
|
||||
#undef yyTABLES_NAME
|
||||
#endif
|
||||
|
||||
#line 130 "src/lexer.l"
|
||||
|
||||
|
||||
#line 365 "src/lexer.h"
|
||||
#line 738 "src/lexer.h"
|
||||
#undef jq_yyIN_HEADER
|
||||
#endif /* jq_yyHEADER_H */
|
||||
+21
-14
@@ -26,7 +26,8 @@ struct lib_loading_state {
|
||||
block *defs;
|
||||
uint64_t ct;
|
||||
};
|
||||
static int load_library(jq_state *jq, jv lib_path, int is_data, int raw,
|
||||
static int load_library(jq_state *jq, jv lib_path,
|
||||
int is_data, int raw, int optional,
|
||||
const char *as, block *out_block,
|
||||
struct lib_loading_state *lib_state);
|
||||
|
||||
@@ -239,7 +240,11 @@ static int process_dependencies(jq_state *jq, jv jq_origin, jv lib_origin, block
|
||||
block bk = *src_block;
|
||||
int nerrors = 0;
|
||||
|
||||
jv_array_foreach(deps, i, dep) {
|
||||
// XXX This is a backward jv_array_foreach because bindings go in reverse
|
||||
for (int i = jv_array_length(jv_copy(deps)); i > 0; ) {
|
||||
i--;
|
||||
jv dep = jv_array_get(jv_copy(deps), i);
|
||||
|
||||
const char *as_str = NULL;
|
||||
int is_data = jv_get_kind(jv_object_get(jv_copy(dep), jv_string("is_data"))) == JV_KIND_TRUE;
|
||||
int raw = 0;
|
||||
@@ -279,7 +284,7 @@ static int process_dependencies(jq_state *jq, jv jq_origin, jv lib_origin, block
|
||||
if (is_data) {
|
||||
// Can't reuse data libs because the wrong name is bound
|
||||
block dep_def_block;
|
||||
nerrors += load_library(jq, resolved, is_data, raw, as_str, &dep_def_block, lib_state);
|
||||
nerrors += load_library(jq, resolved, is_data, raw, optional, as_str, &dep_def_block, lib_state);
|
||||
if (nerrors == 0) {
|
||||
// Bind as both $data::data and $data for backward compatibility vs common sense
|
||||
bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, as_str);
|
||||
@@ -298,7 +303,7 @@ static int process_dependencies(jq_state *jq, jv jq_origin, jv lib_origin, block
|
||||
bk = block_bind_library(lib_state->defs[state_idx], bk, OP_IS_CALL_PSEUDO, as_str);
|
||||
} else { // Not found. Add it to the table before binding.
|
||||
block dep_def_block = gen_noop();
|
||||
nerrors += load_library(jq, resolved, is_data, raw, as_str, &dep_def_block, lib_state);
|
||||
nerrors += load_library(jq, resolved, is_data, raw, optional, as_str, &dep_def_block, lib_state);
|
||||
// resolved has been freed
|
||||
if (nerrors == 0) {
|
||||
// Bind the library to the program
|
||||
@@ -317,7 +322,7 @@ static int process_dependencies(jq_state *jq, jv jq_origin, jv lib_origin, block
|
||||
|
||||
// Loads the library at lib_path into lib_state, putting the library's defs
|
||||
// into *out_block
|
||||
static int load_library(jq_state *jq, jv lib_path, int is_data, int raw, const char *as, block *out_block, struct lib_loading_state *lib_state) {
|
||||
static int load_library(jq_state *jq, jv lib_path, int is_data, int raw, int optional, const char *as, block *out_block, struct lib_loading_state *lib_state) {
|
||||
int nerrors = 0;
|
||||
struct locfile* src = NULL;
|
||||
block program;
|
||||
@@ -328,12 +333,15 @@ static int load_library(jq_state *jq, jv lib_path, int is_data, int raw, const c
|
||||
data = jv_load_file(jv_string_value(lib_path), 1);
|
||||
int state_idx;
|
||||
if (!jv_is_valid(data)) {
|
||||
if (jv_invalid_has_msg(jv_copy(data)))
|
||||
data = jv_invalid_get_msg(data);
|
||||
else
|
||||
data = jv_string("unknown error");
|
||||
jq_report_error(jq, jv_string_fmt("jq: error loading data file %s: %s\n", jv_string_value(lib_path), jv_string_value(data)));
|
||||
nerrors++;
|
||||
program = gen_noop();
|
||||
if (!optional) {
|
||||
if (jv_invalid_has_msg(jv_copy(data)))
|
||||
data = jv_invalid_get_msg(data);
|
||||
else
|
||||
data = jv_string("unknown error");
|
||||
jq_report_error(jq, jv_string_fmt("jq: error loading data file %s: %s\n", jv_string_value(lib_path), jv_string_value(data)));
|
||||
nerrors++;
|
||||
}
|
||||
goto out;
|
||||
} else if (is_data) {
|
||||
// import "foo" as $bar;
|
||||
@@ -342,6 +350,7 @@ static int load_library(jq_state *jq, jv lib_path, int is_data, int raw, const c
|
||||
// import "foo" as bar;
|
||||
src = locfile_init(jq, jv_string_value(lib_path), jv_string_value(data), jv_string_length_bytes(jv_copy(data)));
|
||||
nerrors += jq_parse_library(src, &program);
|
||||
locfile_free(src);
|
||||
if (nerrors == 0) {
|
||||
char *lib_origin = strdup(jv_string_value(lib_path));
|
||||
nerrors += process_dependencies(jq, jq_get_jq_origin(jq),
|
||||
@@ -356,10 +365,8 @@ static int load_library(jq_state *jq, jv lib_path, int is_data, int raw, const c
|
||||
lib_state->defs = jv_mem_realloc(lib_state->defs, lib_state->ct * sizeof(block));
|
||||
lib_state->names[state_idx] = strdup(jv_string_value(lib_path));
|
||||
lib_state->defs[state_idx] = program;
|
||||
*out_block = program;
|
||||
if (src)
|
||||
locfile_free(src);
|
||||
out:
|
||||
*out_block = program;
|
||||
jv_free(lib_path);
|
||||
jv_free(data);
|
||||
return nerrors;
|
||||
|
||||
+16
-6
@@ -212,12 +212,12 @@ static int process(jq_state *jq, jv value, int flags, int dumpopts) {
|
||||
jv_free(exit_code);
|
||||
jv error_message = jq_get_error_message(jq);
|
||||
if (jv_get_kind(error_message) == JV_KIND_STRING) {
|
||||
fprintf(stderr, "%s", jv_string_value(error_message));
|
||||
fprintf(stderr, "jq: error: %s", jv_string_value(error_message));
|
||||
} else if (jv_get_kind(error_message) == JV_KIND_NULL) {
|
||||
// Halt with no output
|
||||
} else if (jv_is_valid(error_message)) {
|
||||
error_message = jv_dump_string(jv_copy(error_message), 0);
|
||||
fprintf(stderr, "%s\n", jv_string_value(error_message));
|
||||
fprintf(stderr, "jq: error: %s\n", jv_string_value(error_message));
|
||||
} // else no message on stderr; use --debug-trace to see a message
|
||||
fflush(stderr);
|
||||
jv_free(error_message);
|
||||
@@ -394,6 +394,16 @@ int main(int argc, char* argv[]) {
|
||||
options |= RAW_OUTPUT | RAW_NO_LF;
|
||||
if (!short_opts) continue;
|
||||
}
|
||||
if (isoption(argv[i], 'b', "binary", &short_opts)) {
|
||||
#ifdef WIN32
|
||||
fflush(stdout);
|
||||
fflush(stderr);
|
||||
_setmode(fileno(stdin), _O_BINARY);
|
||||
_setmode(fileno(stdout), _O_BINARY);
|
||||
_setmode(fileno(stderr), _O_BINARY);
|
||||
if (!short_opts) continue;
|
||||
#endif
|
||||
}
|
||||
if (isoption(argv[i], 0, "tab", &short_opts)) {
|
||||
dumpopts &= ~JV_PRINT_INDENT_FLAGS(7);
|
||||
dumpopts |= JV_PRINT_TAB | JV_PRINT_PRETTY;
|
||||
@@ -576,7 +586,7 @@ int main(int argc, char* argv[]) {
|
||||
|
||||
char *origin = strdup(argv[0]);
|
||||
if (origin == NULL) {
|
||||
fprintf(stderr, "Error: out of memory\n");
|
||||
fprintf(stderr, "jq: error: out of memory\n");
|
||||
exit(1);
|
||||
}
|
||||
jq_set_attr(jq, jv_string("JQ_ORIGIN"), jv_string(dirname(origin)));
|
||||
@@ -668,11 +678,11 @@ int main(int argc, char* argv[]) {
|
||||
if (!(options & SEQ)) {
|
||||
// --seq -> errors are not fatal
|
||||
ret = JQ_OK_NO_OUTPUT;
|
||||
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
|
||||
fprintf(stderr, "jq: parse error: %s\n", jv_string_value(msg));
|
||||
jv_free(msg);
|
||||
break;
|
||||
}
|
||||
fprintf(stderr, "ignoring parse error: %s\n", jv_string_value(msg));
|
||||
fprintf(stderr, "jq: ignoring parse error: %s\n", jv_string_value(msg));
|
||||
jv_free(msg);
|
||||
}
|
||||
}
|
||||
@@ -683,7 +693,7 @@ int main(int argc, char* argv[]) {
|
||||
out:
|
||||
badwrite = ferror(stdout);
|
||||
if (fclose(stdout)!=0 || badwrite) {
|
||||
fprintf(stderr,"Error: writing output failed: %s\n", strerror(errno));
|
||||
fprintf(stderr,"jq: error: writing output failed: %s\n", strerror(errno));
|
||||
ret = JQ_ERROR_SYSTEM;
|
||||
}
|
||||
|
||||
|
||||
+1283
-1176
File diff suppressed because it is too large.
Load diff
+10
-6
@@ -1,8 +1,9 @@
|
||||
/* A Bison parser, made by GNU Bison 3.0.5. */
|
||||
/* A Bison parser, made by GNU Bison 3.3.2. */
|
||||
|
||||
/* Bison interface for Yacc-like parsers in C
|
||||
|
||||
Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.
|
||||
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 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
|
||||
@@ -30,6 +31,9 @@
|
||||
This special exception was added by the Free Software Foundation in
|
||||
version 2.2 of Bison. */
|
||||
|
||||
/* Undocumented macros, especially those whose name start with YY_,
|
||||
are private implementation details. Do not rely on them. */
|
||||
|
||||
#ifndef YY_YY_SRC_PARSER_H_INCLUDED
|
||||
# define YY_YY_SRC_PARSER_H_INCLUDED
|
||||
/* Debug traces. */
|
||||
@@ -40,7 +44,7 @@
|
||||
extern int yydebug;
|
||||
#endif
|
||||
/* "%code requires" blocks. */
|
||||
#line 11 "src/parser.y" /* yacc.c:1910 */
|
||||
#line 11 "src/parser.y" /* yacc.c:1927 */
|
||||
|
||||
#include "locfile.h"
|
||||
struct lexer_param;
|
||||
@@ -57,7 +61,7 @@ struct lexer_param;
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#line 61 "src/parser.h" /* yacc.c:1910 */
|
||||
#line 65 "src/parser.h" /* yacc.c:1927 */
|
||||
|
||||
/* Token type. */
|
||||
#ifndef YYTOKENTYPE
|
||||
@@ -163,12 +167,12 @@ struct lexer_param;
|
||||
|
||||
union YYSTYPE
|
||||
{
|
||||
#line 31 "src/parser.y" /* yacc.c:1910 */
|
||||
#line 31 "src/parser.y" /* yacc.c:1927 */
|
||||
|
||||
jv literal;
|
||||
block blk;
|
||||
|
||||
#line 172 "src/parser.h" /* yacc.c:1910 */
|
||||
#line 176 "src/parser.h" /* yacc.c:1927 */
|
||||
};
|
||||
|
||||
typedef union YYSTYPE YYSTYPE;
|
||||
|
||||
+42
-14
@@ -172,7 +172,7 @@ static jv check_object_key(block k) {
|
||||
char errbuf[15];
|
||||
return jv_string_fmt("Cannot use %s (%s) as object key",
|
||||
jv_kind_name(block_const_kind(k)),
|
||||
jv_dump_string_trunc(jv_copy(block_const(k)), errbuf, sizeof(errbuf)));
|
||||
jv_dump_string_trunc(block_const(k), errbuf, sizeof(errbuf)));
|
||||
}
|
||||
return jv_invalid();
|
||||
}
|
||||
@@ -216,19 +216,25 @@ static block constant_fold(block a, block b, int op) {
|
||||
jv res = jv_invalid();
|
||||
|
||||
if (block_const_kind(a) == JV_KIND_NUMBER) {
|
||||
double na = jv_number_value(block_const(a));
|
||||
double nb = jv_number_value(block_const(b));
|
||||
jv jv_a = block_const(a);
|
||||
jv jv_b = block_const(b);
|
||||
|
||||
double na = jv_number_value(jv_a);
|
||||
double nb = jv_number_value(jv_b);
|
||||
|
||||
int cmp = jv_cmp(jv_a, jv_b);
|
||||
|
||||
switch (op) {
|
||||
case '+': res = jv_number(na + nb); break;
|
||||
case '-': res = jv_number(na - nb); break;
|
||||
case '*': res = jv_number(na * nb); break;
|
||||
case '/': res = jv_number(na / nb); break;
|
||||
case EQ: res = (na == nb ? jv_true() : jv_false()); break;
|
||||
case NEQ: res = (na != nb ? jv_true() : jv_false()); break;
|
||||
case '<': res = (na < nb ? jv_true() : jv_false()); break;
|
||||
case '>': res = (na > nb ? jv_true() : jv_false()); break;
|
||||
case LESSEQ: res = (na <= nb ? jv_true() : jv_false()); break;
|
||||
case GREATEREQ: res = (na >= nb ? jv_true() : jv_false()); break;
|
||||
case EQ: res = (cmp == 0 ? jv_true() : jv_false()); break;
|
||||
case NEQ: res = (cmp != 0 ? jv_true() : jv_false()); break;
|
||||
case '<': res = (cmp < 0 ? jv_true() : jv_false()); break;
|
||||
case '>': res = (cmp > 0 ? jv_true() : jv_false()); break;
|
||||
case LESSEQ: res = (cmp <= 0 ? jv_true() : jv_false()); break;
|
||||
case GREATEREQ: res = (cmp >= 0 ? jv_true() : jv_false()); break;
|
||||
default: break;
|
||||
}
|
||||
} else if (op == '+' && block_const_kind(a) == JV_KIND_STRING) {
|
||||
@@ -576,7 +582,10 @@ Param:
|
||||
$$ = gen_param_regular(jv_string_value($2));
|
||||
jv_free($2);
|
||||
} |
|
||||
|
||||
'$' Keyword {
|
||||
$$ = gen_param_regular(jv_string_value($2));
|
||||
jv_free($2);
|
||||
} |
|
||||
IDENT {
|
||||
$$ = gen_param(jv_string_value($1));
|
||||
jv_free($1);
|
||||
@@ -685,6 +694,12 @@ Term '[' Exp ']' '?' {
|
||||
Term '[' Exp ']' %prec NONOPT {
|
||||
$$ = gen_index($1, $3);
|
||||
} |
|
||||
Term '.' '[' Exp ']' '?' {
|
||||
$$ = gen_index_opt($1, $4);
|
||||
} |
|
||||
Term '.' '[' Exp ']' %prec NONOPT {
|
||||
$$ = gen_index($1, $4);
|
||||
} |
|
||||
Term '[' ']' '?' {
|
||||
$$ = block_join($1, gen_op_simple(EACH_OPT));
|
||||
} |
|
||||
@@ -734,14 +749,19 @@ FORMAT {
|
||||
else
|
||||
$$ = BLOCK(gen_subexp(gen_const(jv_object())), $2, gen_op_simple(POP));
|
||||
} |
|
||||
'$' LOC {
|
||||
$$ = gen_const(JV_OBJECT(jv_string("file"), jv_copy(locations->fname),
|
||||
jv_string("line"), jv_number(locfile_get_line(locations, @$.start) + 1)));
|
||||
} |
|
||||
'$' IDENT {
|
||||
$$ = gen_location(@$, locations, gen_op_unbound(LOADV, jv_string_value($2)));
|
||||
jv_free($2);
|
||||
} |
|
||||
'$' Keyword {
|
||||
if (strcmp(jv_string_value($2), "__loc__") == 0) {
|
||||
$$ = gen_const(JV_OBJECT(jv_string("file"), jv_copy(locations->fname),
|
||||
jv_string("line"), jv_number(locfile_get_line(locations, @$.start) + 1)));
|
||||
} else {
|
||||
$$ = gen_location(@$, locations, gen_op_unbound(LOADV, jv_string_value($2)));
|
||||
}
|
||||
jv_free($2);
|
||||
} |
|
||||
IDENT {
|
||||
const char *s = jv_string_value($1);
|
||||
if (strcmp(s, "false") == 0)
|
||||
@@ -939,10 +959,18 @@ IDENT ':' ExpD {
|
||||
$$ = gen_dictpair(gen_const($2),
|
||||
gen_location(@$, locations, gen_op_unbound(LOADV, jv_string_value($2))));
|
||||
}
|
||||
| '$' Keyword {
|
||||
$$ = gen_dictpair(gen_const($2),
|
||||
gen_location(@$, locations, gen_op_unbound(LOADV, jv_string_value($2))));
|
||||
}
|
||||
| IDENT {
|
||||
$$ = gen_dictpair(gen_const(jv_copy($1)),
|
||||
gen_index(gen_noop(), gen_const($1)));
|
||||
}
|
||||
| Keyword {
|
||||
$$ = gen_dictpair(gen_const(jv_copy($1)),
|
||||
gen_index(gen_noop(), gen_const($1)));
|
||||
}
|
||||
| '(' Exp ')' ':' ExpD {
|
||||
jv msg = check_object_key($2);
|
||||
if (jv_is_valid(msg)) {
|
||||
|
||||
+1
-1
@@ -275,7 +275,7 @@ static int jq_util_input_read_more(jq_util_input_state *state) {
|
||||
// System-level input error on the stream. It will be closed (below).
|
||||
// TODO: report it. Can't use 'state->err_cb()' as it is hard-coded for
|
||||
// 'open' related problems.
|
||||
fprintf(stderr,"Input error: %s\n", strerror(errno));
|
||||
fprintf(stderr,"jq: error: %s\n", strerror(errno));
|
||||
}
|
||||
if (state->current_input) {
|
||||
if (state->current_input == stdin) {
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
Skipped 9 tests
|
||||
Testing '.[0]' at line number 37
|
||||
Hit the number of tests limit (1), breaking
|
||||
1 of 1 tests passed (0 malformed)
|
||||
==9681== 17 bytes in 1 blocks are definitely lost in loss record 4 of 45
|
||||
==9681== at 0x100180545: malloc (vg_replace_malloc.c:302)
|
||||
==9681== by 0x1000240D8: jv_mem_alloc (jv_alloc.c:122)
|
||||
==9681== by 0x10001F425: jv_number_with_literal (jv.c:193)
|
||||
==9681== by 0x10002F9C8: check_literal (jv_parse.c:508)
|
||||
==9681== by 0x10002EAA4: jv_parser_next (jv_parse.c:797)
|
||||
==9681== by 0x10002FBF2: jv_parse_sized (jv_parse.c:830)
|
||||
==9681== by 0x10003544B: jq_yylex (lexer.l:90)
|
||||
==9681== by 0x100036FB4: yylex (parser.y:153)
|
||||
==9681== by 0x100037352: yyparse (parser.c:2292)
|
||||
==9681== by 0x10003B0FD: jq_parse (parser.y:967)
|
||||
==9681== by 0x100032CD4: load_program (linker.c:374)
|
||||
==9681== by 0x10001C5B3: jq_compile_args (execute.c:1172)
|
||||
==9681==
|
||||
|
||||
|
||||
Skipped 10 tests
|
||||
Testing '.[2]' at line number 41
|
||||
Hit the number of tests limit (1), breaking
|
||||
1 of 1 tests passed (0 malformed)
|
||||
==9690== 17 bytes in 1 blocks are definitely lost in loss record 4 of 45
|
||||
==9690== at 0x100180545: malloc (vg_replace_malloc.c:302)
|
||||
==9690== by 0x1000240D8: jv_mem_alloc (jv_alloc.c:122)
|
||||
==9690== by 0x10001F425: jv_number_with_literal (jv.c:193)
|
||||
==9690== by 0x10002F9C8: check_literal (jv_parse.c:508)
|
||||
==9690== by 0x10002EAA4: jv_parser_next (jv_parse.c:797)
|
||||
==9690== by 0x10002FBF2: jv_parse_sized (jv_parse.c:830)
|
||||
==9690== by 0x10003544B: jq_yylex (lexer.l:90)
|
||||
==9690== by 0x100036FB4: yylex (parser.y:153)
|
||||
==9690== by 0x100037352: yyparse (parser.c:2292)
|
||||
==9690== by 0x10003B0FD: jq_parse (parser.y:967)
|
||||
==9690== by 0x100032CD4: load_program (linker.c:374)
|
||||
==9690== by 0x10001C5B3: jq_compile_args (execute.c:1172)
|
||||
==9690==
|
||||
|
||||
Skipped 12 tests
|
||||
Testing '.[2:4]' at line number 49
|
||||
Hit the number of tests limit (1), breaking
|
||||
1 of 1 tests passed (0 malformed)
|
||||
==9713== 34 bytes in 2 blocks are definitely lost in loss record 15 of 45
|
||||
==9713== at 0x100180545: malloc (vg_replace_malloc.c:302)
|
||||
==9713== by 0x1000240D8: jv_mem_alloc (jv_alloc.c:122)
|
||||
==9713== by 0x10001F425: jv_number_with_literal (jv.c:193)
|
||||
==9713== by 0x10002F9C8: check_literal (jv_parse.c:508)
|
||||
==9713== by 0x10002EAA4: jv_parser_next (jv_parse.c:797)
|
||||
==9713== by 0x10002FBF2: jv_parse_sized (jv_parse.c:830)
|
||||
==9713== by 0x10003544B: jq_yylex (lexer.l:90)
|
||||
==9713== by 0x100036FB4: yylex (parser.y:153)
|
||||
==9713== by 0x100037352: yyparse (parser.c:2292)
|
||||
==9713== by 0x10003B0FD: jq_parse (parser.y:967)
|
||||
==9713== by 0x100032CD4: load_program (linker.c:374)
|
||||
==9713== by 0x10001C5B3: jq_compile_args (execute.c:1172)
|
||||
==9713==
|
||||
|
||||
Skipped 13 tests
|
||||
Testing '.[2:4]' at line number 53
|
||||
Hit the number of tests limit (1), breaking
|
||||
1 of 1 tests passed (0 malformed)
|
||||
==9714== 34 bytes in 2 blocks are definitely lost in loss record 15 of 45
|
||||
==9714== at 0x100180545: malloc (vg_replace_malloc.c:302)
|
||||
==9714== by 0x1000240D8: jv_mem_alloc (jv_alloc.c:122)
|
||||
==9714== by 0x10001F425: jv_number_with_literal (jv.c:193)
|
||||
==9714== by 0x10002F9C8: check_literal (jv_parse.c:508)
|
||||
==9714== by 0x10002EAA4: jv_parser_next (jv_parse.c:797)
|
||||
==9714== by 0x10002FBF2: jv_parse_sized (jv_parse.c:830)
|
||||
==9714== by 0x10003544B: jq_yylex (lexer.l:90)
|
||||
==9714== by 0x100036FB4: yylex (parser.y:153)
|
||||
==9714== by 0x100037352: yyparse (parser.c:2292)
|
||||
==9714== by 0x10003B0FD: jq_parse (parser.y:967)
|
||||
==9714== by 0x100032CD4: load_program (linker.c:374)
|
||||
==9714== by 0x10001C5B3: jq_compile_args (execute.c:1172)
|
||||
==9714==
|
||||
|
||||
Skipped 14 tests
|
||||
Testing '.[:3]' at line number 57
|
||||
Hit the number of tests limit (1), breaking
|
||||
1 of 1 tests passed (0 malformed)
|
||||
==9715== 17 bytes in 1 blocks are definitely lost in loss record 4 of 45
|
||||
==9715== at 0x100180545: malloc (vg_replace_malloc.c:302)
|
||||
==9715== by 0x1000240D8: jv_mem_alloc (jv_alloc.c:122)
|
||||
==9715== by 0x10001F425: jv_number_with_literal (jv.c:193)
|
||||
==9715== by 0x10002F9C8: check_literal (jv_parse.c:508)
|
||||
==9715== by 0x10002EAA4: jv_parser_next (jv_parse.c:797)
|
||||
==9715== by 0x10002FBF2: jv_parse_sized (jv_parse.c:830)
|
||||
==9715== by 0x10003544B: jq_yylex (lexer.l:90)
|
||||
==9715== by 0x100036FB4: yylex (parser.y:153)
|
||||
==9715== by 0x100037352: yyparse (parser.c:2292)
|
||||
==9715== by 0x10003B0FD: jq_parse (parser.y:967)
|
||||
==9715== by 0x100032CD4: load_program (linker.c:374)
|
||||
==9715== by 0x10001C5B3: jq_compile_args (execute.c:1172)
|
||||
==9715==
|
||||
|
||||
Skipped 19 tests
|
||||
Testing '.foo, .bar' at line number 78
|
||||
Hit the number of tests limit (1), breaking
|
||||
1 of 1 tests passed (0 malformed)
|
||||
|
||||
+144
-1
@@ -604,6 +604,10 @@ def f(a;b;c;d;e;f): [a+1,b,c,d,e,f]; f(.[0];.[1];.[0];.[0];.[0];.[0])
|
||||
[1,2]
|
||||
[2,2,1,1,1,1]
|
||||
|
||||
def f: 1; def g: f, def f: 2; def g: 3; f, def f: g; f, g; def f: 4; [f, def f: g; def g: 5; f, g]+[f,g]
|
||||
null
|
||||
[4,1,2,3,3,5,4,1,2,3,3]
|
||||
|
||||
# Test precedence of 'def' vs '|'
|
||||
def a: 0; . | a
|
||||
null
|
||||
@@ -851,6 +855,51 @@ false
|
||||
[1,2,3,4,true]
|
||||
true
|
||||
|
||||
# Check short-circuiting
|
||||
any(true, error; .)
|
||||
"badness"
|
||||
true
|
||||
|
||||
all(false, error; .)
|
||||
"badness"
|
||||
false
|
||||
|
||||
any(not)
|
||||
[]
|
||||
false
|
||||
|
||||
all(not)
|
||||
[]
|
||||
true
|
||||
|
||||
any(not)
|
||||
[false]
|
||||
true
|
||||
|
||||
all(not)
|
||||
[false]
|
||||
true
|
||||
|
||||
[any,all]
|
||||
[]
|
||||
[false,true]
|
||||
|
||||
[any,all]
|
||||
[true]
|
||||
[true,true]
|
||||
|
||||
[any,all]
|
||||
[false]
|
||||
[false,false]
|
||||
|
||||
[any,all]
|
||||
[true,false]
|
||||
[true,false]
|
||||
|
||||
[any,all]
|
||||
[null,null,true]
|
||||
[true,false]
|
||||
|
||||
#
|
||||
# Paths
|
||||
#
|
||||
@@ -1382,8 +1431,10 @@ ascii_upcase
|
||||
"useful but not for é"
|
||||
"USEFUL BUT NOT FOR é"
|
||||
|
||||
bsearch(4)
|
||||
bsearch(0,2,4)
|
||||
[1,2,3]
|
||||
-1
|
||||
1
|
||||
-4
|
||||
|
||||
# strptime tests are in optional.test
|
||||
@@ -1417,6 +1468,18 @@ import "data" as $e; import "data" as $d; [$d[].this,$e[].that,$d::d[].this,$e::
|
||||
null
|
||||
"is a test;is too;is a test;is too"
|
||||
|
||||
include "shadow1"; e
|
||||
null
|
||||
2
|
||||
|
||||
include "shadow1"; include "shadow2"; e
|
||||
null
|
||||
3
|
||||
|
||||
import "shadow1" as f; import "shadow2" as f; import "shadow1" as e; [e::e, f::e]
|
||||
null
|
||||
[2,3]
|
||||
|
||||
%%FAIL
|
||||
module (.+1); 0
|
||||
jq: error: Module metadata must be constant at <top-level>, line 1:
|
||||
@@ -1441,6 +1504,10 @@ modulemeta
|
||||
"c"
|
||||
{"whatever":null,"deps":[{"as":"foo","is_data":false,"relpath":"a"},{"search":"./","as":"d","is_data":false,"relpath":"d"},{"search":"./","as":"d2","is_data":false,"relpath":"d"},{"search":"./../lib/jq","as":"e","is_data":false,"relpath":"e"},{"search":"./../lib/jq","as":"f","is_data":false,"relpath":"f"},{"as":"d","is_data":true,"relpath":"data"}]}
|
||||
|
||||
modulemeta | .deps |= length
|
||||
"c"
|
||||
{"whatever":null,"deps":6}
|
||||
|
||||
%%FAIL IGNORE MSG
|
||||
import "syntaxerror" as e; .
|
||||
jq: error: syntax error, unexpected ';', expecting $end (Unix shell quoting issues?) at /home/nico/ws/jq/tests/modules/syntaxerror/syntaxerror.jq, line 1:
|
||||
@@ -1528,6 +1595,17 @@ true
|
||||
true
|
||||
true
|
||||
|
||||
range(5;13)|IN(range(0;10;3))
|
||||
null
|
||||
false
|
||||
true
|
||||
false
|
||||
false
|
||||
true
|
||||
false
|
||||
false
|
||||
false
|
||||
|
||||
range(10;12)|IN(range(10))
|
||||
null
|
||||
false
|
||||
@@ -1568,4 +1646,69 @@ index("")
|
||||
""
|
||||
null
|
||||
|
||||
# check that dead code removal occurs after builtin it generation
|
||||
builtins|length > 10
|
||||
null
|
||||
true
|
||||
|
||||
"-1"|IN(builtins[] / "/"|.[1])
|
||||
null
|
||||
false
|
||||
|
||||
all(builtins[] / "/"; .[1]|tonumber >= 0)
|
||||
null
|
||||
true
|
||||
|
||||
builtins|any(.[:1] == "_")
|
||||
null
|
||||
false
|
||||
|
||||
## Test ability to use keywords (uncomment after eval is pushed)
|
||||
#(.[] as $kw | "\"{\($kw)} as $\($kw) | $\($kw) | {$\($kw)} | {\($kw):.\($kw)}\""|eval|empty),null
|
||||
#["as","def","module","import","include","if","then","else","elif","end","reduce","foreach","and","or","try","catch","label","break","__loc__"]
|
||||
#null
|
||||
#
|
||||
#(.[] as $kw | "\"def f($\($kw)): $\($kw); f(.)\""|eval|empty),null
|
||||
#["as","def","module","import","include","if","then","else","elif","end","reduce","foreach","and","or","try","catch","label","break","__loc__"]
|
||||
#null
|
||||
|
||||
|
||||
#
|
||||
# Tests to cover the new toliteral number functionality
|
||||
# For an example see #1652 and other linked issues
|
||||
#
|
||||
|
||||
# We are backward and sanity compatible
|
||||
|
||||
map(. == 1)
|
||||
[1, 1.0, 1.000, 100e-2, 1e+0, 0.0001e4]
|
||||
[true, true, true, true, true, true]
|
||||
|
||||
# When no arithmetic is involved jq should preserve the literal value
|
||||
|
||||
.[0] | tostring
|
||||
[13911860366432393]
|
||||
"13911860366432393"
|
||||
|
||||
.x | tojson
|
||||
{"x":13911860366432393}
|
||||
"13911860366432393"
|
||||
|
||||
13911860366432393 == 13911860366432392
|
||||
null
|
||||
false
|
||||
|
||||
|
||||
# Applying arithmetic to the value will truncate the result to double
|
||||
|
||||
. - 10
|
||||
13911860366432393
|
||||
13911860366432382
|
||||
|
||||
.[0] - 10
|
||||
[13911860366432393]
|
||||
13911860366432382
|
||||
|
||||
.x - 10
|
||||
{"x":13911860366432393}
|
||||
13911860366432382
|
||||
@@ -0,0 +1,14 @@
|
||||
{
|
||||
macos valgrind 1
|
||||
Memcheck:Leak
|
||||
match-leak-kinds: possible
|
||||
fun:calloc
|
||||
fun:map_images_nolock
|
||||
...
|
||||
fun:_dyld_objc_notify_register
|
||||
fun:_objc_init
|
||||
fun:_os_object_init
|
||||
fun:libdispatch_init
|
||||
fun:libSystem_initializer
|
||||
...
|
||||
}
|
||||
+1
-1
@@ -3,5 +3,5 @@
|
||||
. "${0%/*}/setup" "$@"
|
||||
|
||||
# We set PAGER because there's a mantest for `env` that uses it.
|
||||
(cd $JQBASEDIR/docs && rake mantests) |
|
||||
(cd $JQBASEDIR/docs && pipenv run python3 build_mantests.py) |
|
||||
env PAGER=less $VALGRIND $Q $JQ -L "$mods" --run-tests
|
||||
File renamed without changes.
@@ -0,0 +1 @@
|
||||
def g: 1;
|
||||
@@ -0,0 +1,2 @@
|
||||
def e: 1;
|
||||
def e: 2;
|
||||
@@ -0,0 +1 @@
|
||||
def e: 3;
|
||||
Loaded 100 of 105 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user