typo

Document stream-base.dbd usage when sCalcout is not needed

.ci-local/defaults.set

@@ -0,0 +1,12 @@
+MODULES=calc asyn
+
+# EPICS Base
+BASE_DIRNAME=base
+BASE_REPONAME=epics-base
+BASE_REPOOWNER=epics-base
+BASE_VARNAME=EPICS_BASE
+BASE_RECURSIVE=no
+
+ASYN_REPOOWNER=epics-modules
+
+CALC_REPOOWNER=epics-modules

.github/workflows/ci-scripts-build.yml

@@ -0,0 +1,164 @@
+# .github/workflows/ci-scripts-build.yml for use with EPICS Base ci-scripts
+# (see: https://github.com/epics-base/ci-scripts)
+
+# This is YAML - indentation levels are crucial
+
+# Workflow name, shared by all branches
+
+name: StreamDevice
+
+# Trigger on pushes and PRs to any branch
+on:
+  push:
+    paths-ignore:
+      - 'docs/*'
+      - '.gitattributes'
+      - '.gitignore'
+      - '**/*.html'
+      - '**/*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/*'
+      - '.gitattributes'
+      - '.gitignore'
+      - '**/*.html'
+      - '**/*.md'
+
+env:
+    SETUP_PATH: .ci-local:.ci
+    EPICS_TEST_IMPRECISE_TIMING: YES
+
+jobs:
+  native:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    # Set environment variables from matrix parameters
+    env:
+      CMP: ${{ matrix.cmp }}
+      BCFG: ${{ matrix.configuration }}
+      BASE: ${{ matrix.base }}
+      WINE: ${{ matrix.wine }}
+      RTEMS: ${{ matrix.rtems }}
+      RTEMS_TARGET: ${{ matrix.rtems_target }}
+      TEST: ${{ matrix.test }}
+      EXTRA: ${{ matrix.extra }}
+      VV: "1"
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Native Linux (WError)
+            os: ubuntu-20.04
+            cmp: gcc
+            configuration: default
+            base: "7.0"
+            extra: "CMD_CPPFLAGS=-Werror"
+            pcre: apt
+
+          - name: Cross mingw64 DLL
+            os: ubuntu-20.04
+            cmp: gcc
+            configuration: default
+            base: "7.0"
+            wine: "64"
+            pcre: no
+
+          - name: Cross mingw64 static
+            os: ubuntu-20.04
+            cmp: gcc
+            configuration: static
+            base: "7.0"
+            wine: "64"
+            pcre: no
+
+          - name: RTEMS 4.10
+            os: ubuntu-20.04
+            cmp: gcc
+            configuration: default
+            base: "7.0"
+            rtems: "4.10"
+            rtems_target: RTEMS-pc386-qemu
+            pcre: no
+ 
+          - name: Native Linux with clang
+            os: ubuntu-20.04
+            cmp: clang
+            configuration: default
+            base: "7.0"
+            pcre: apt
+
+          - name: Native Linux with 3.15
+            os: ubuntu-20.04
+            cmp: gcc
+            configuration: default
+            base: "3.15"
+            pcre: apt
+
+          - name: Native Linux with 3.14
+            os: ubuntu-20.04
+            cmp: gcc
+            configuration: default
+            base: "3.14"
+            pcre: apt
+
+          - name: OSX
+            os: macos-latest
+            cmp: clang
+            configuration: default
+            base: "7.0"
+            pcre: no
+
+          - name: vs2019 DLL
+            os: windows-2019
+            cmp: vs2019
+            configuration: debug
+            base: "7.0"
+            pcre: no
+            extra: "CMD_CFLAGS=-analysis CMD_CXXFLAGS=-analysis"
+
+          - name: vs2019 static
+            os: windows-2019
+            cmp: vs2019
+            configuration: static-debug
+            base: "7.0"
+            pcre: no
+            extra: "CMD_CFLAGS=-analysis CMD_CXXFLAGS=-analysis"
+
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - name: Automatic core dumper analysis
+      uses: mdavidsaver/ci-core-dumper@master
+    - name: "apt-get install"
+      run: |
+        sudo apt-get update
+        sudo apt-get -y install qemu-system-x86 g++-mingw-w64-x86-64 gdb
+      if: runner.os == 'Linux'
+
+    - name: Reset RELEASE
+      shell: bash
+      # 'make' on Mac doesn't understand "undefine PCRE"
+      # so replace the whole file
+      run: |
+        cat <<EOF > configure/RELEASE
+        -include \$(TOP)/../RELEASE.local
+        -include \$(TOP)/../RELEASE.\$(EPICS_HOST_ARCH).local
+        -include \$(TOP)/configure/RELEASE.local
+        EOF
+
+    - name: Prepare and compile dependencies
+      run: python .ci/cue.py prepare
+
+    - name: "apt-get install pcre"
+      if: matrix.pcre == 'apt'
+      shell: bash
+      run: |
+        sudo apt-get -y install libpcre3-dev
+        cat <<EOF >> configure/CONFIG_SITE.local
+        PCRE_INCLUDE=/usr/include
+        PCRE_LIB=/usr/lib
+        EOF
+
+    - name: Build main module
+      run: python .ci/cue.py build

.gitmodules

@@ -0,0 +1,3 @@
+[submodule ".ci"]
+	path = .ci
+	url = https://github.com/epics-base/ci-scripts.git

CHANGELOG.md

@@ -0,0 +1,303 @@
+# Changelog
+
+## Changes in release 2.8.20
+
+Fix missing initialization of `inTerminator` and `outTerminator`.
+Thanks to Krisztián Löki.
+
+New checksums `%<lrc>` and `%<hexlrc>`.
+Thanks to Marcio Paduan Donadio.
+
+Make timestamp output in error and debug messages optional with new
+iocsh variable `streamMsgTimeStamped`. Default is 1.
+
+Reduce number of duplicate error messages. Dead time for repeated messages
+is configurable with new iocsh variable `streamErrorDeadTime`.
+Thanks to Dominic Oram.
+
+Shifted some noisy debug messages to `streamDebug` level 2.
+
+In `STREAM_PROTOCOL_PATH`, allow both `:` and `;` separators on all
+operating systems to make startup scripts OS independent.
+On Windows however, an initial single letter followed by a `:` is detected
+as a drive letter. Thus single letter directories must be separated with
+`;` or followed by `\` or `/` on Windows.
+
+Allow absolute path protocol files. Those will not use
+`STREAM_PROTOCOL_PATH`. 
+Changed the default search path from `"."` to `NULL`.
+
+Only poll for `I/O Intr` records while `interruptAccept` is true,
+in particular not between `iocPause` and `iocRun`.
+
+Added this change log and a document about contributing to StreamDevice.
+
+## Changes in release 2.8.19
+
+Make colorization of error and debug messages optional with new
+iocsh variable `streamDebugColored`. Defaults to 1 when output is a tty
+and 0 otherwise.
+
+## Changes in release 2.8.18
+
+Another format string fix for VxWorks in checksum converter.
+
+## Changes in release 2.8.17
+
+Fix format strings for VxWorks 6.9 in checksum converter.
+
+Fix some compiler warnings on Windows.
+
+Fix some missing header files installations.
+
+## Changes in release 2.8.16
+
+Drop support of upper level `configure/` directory for improved
+compatibility with SynApps.
+
+Fix problem with extra spaces after protocol name in record links.
+
+Make version string generation more robust.
+
+## Changes in release 2.8.15
+
+Do not overwrite `HOST_OPT` flag. 
+
+Fix version string generation for zip downloads.
+
+On Windows use `;` and `\` in `STREAM_PROTOCOL_PATH`.
+(Was not the case before due to typo in macro name.)
+
+Link streamApp with `seq` and `pv` libraries when `SNCSEQ` is defined in
+RELEASE file.
+
+## Changes in release 2.8.14
+
+Fix version string generation from git tags.
+
+## Changes in release 2.8.13
+
+Fix bug with integer datatype handling in redirectons.
+
+## Changes in release 2.8.12
+
+Apply GPL-3.0.
+
+## Changes in release 2.8.11
+
+Fix buffer overrun.
+Thanks to Garth Brown and Bruce Hill.
+
+Fix bug in 64 bit data type handling in array records (`aai`, `aao`,
+`waveform`).
+Thanks to Andrew Johnson.
+
+Fix Windows linker problem.
+Thanks to Freddie Akeroyd.
+
+Allow `(,)` inside protocol parameters. Limitation: Parenthesis must be in
+matching pairs. Commas within inner parenthesis are consideres part of the
+argument. Example: `protocol(arg1, (arg2, still arg 2), arg3)`.
+
+New checksums `%<brksCryo>`, `%<xor8ff>`, `%<nsum8>`, `%<nsum16>`,
+`%<nsum32>`, `%<notsum>`.
+Thanks to Mark Davis.
+
+Some error message cleanup.
+
+## Changes in release 2.8.10
+
+Fixes for Windows / Visual Studio 2010.
+Thanks to Freddie Akeroyd.
+
+Fix infinite loop in `I/O Intr` scanned records.
+
+Enable error messages by default and always show error messages too when
+debug messages are enabled.
+
+Make sure any console output from StreamDevice can be redirected.
+
+Fix some problems when building for old EPICS R3.13.
+
+## Changes in release 2.8.9
+
+Leave `asynTraceMask` alone. Before, streamDevice had set `setTraceMask`
+to 0 initially.
+
+Link with `sscan` module if `SSCAN` is defined in RELEASE file because the
+`calc` module may need it.
+
+Fix in regsub converter: Avoid infinite loop if an empty string is matched.
+Add support for toupper/tolower to regsub converter.
+
+Fix build problem observed on MacOS related to clash between `wait()`
+system function and the StreamDevice `wait` command.
+
+Allow `%%` in addition to `\%` to escape `%` in protocols (compatibility
+with `printf`/`scanf`).
+
+Have separate dbd file for applications without scalcout support built in.
+
+Improved compatibility with SynApps. (fix of the attempt in 2.8.6)
+
+## Changes in release 2.8.8
+
+Fix problem with `in` command hanging forever if it is the the first
+command of the protocol and the device is offline.
+
+## Changes in release 2.8.7
+
+Enable colored error/debug output on Windows.
+
+Changed error/debug hex output highlight from fat to inverse.
+
+Fix build problem on Windows.
+
+## Changes in release 2.8.6
+
+Improved compatibility with SynApps.
+
+Fix redirection to records with names not starting with a letter or
+underscore.
+
+### Fixes/improvements for `mbbo` device support:
+
+Use `.MASK` and `.SHFT` fields even if no `xxVL` field is defined
+(and thus `.VAL` is used instead of `.RVAL`).
+
+Bugfix: Set `mbbo` to unknown state `0xffff` if in readback no state
+matches.
+
+Bugfix: Use defined state alarms when `mbbo` is updated by `@init` handler.
+
+## Changes in release 2.8.5
+
+A `"\?"` at the end of an input format now matches an empty string.
+Used to do so unintendedly in earlier versions but had been changed.
+
+## Changes in release 2.8.4
+
+Bugfix: After `@init` had been triggered with "magic value" 2 in `.PROC`
+field, reset the field to 0.
+
+## Changes in release 2.8.3
+
+Increase limits on filename, protocolname, busname in record links.
+
+Bugfix: Fix typo calcout device support that prevented compiling it.
+
+## Changes in release 2.8.2
+
+Bugfix: Fix string termination reading into char array records (`waveform`,
+`aai`, `aao`, `lsi`, `lso`).
+
+## Changes in release 2.8.1
+
+Allow empty parameter list `()` in record links.
+
+## Changes between 2.7 and 2.8.0
+
+### Build system
+
+Drop support for (buggy) cygnus-2.7.2 gcc (as used in some old cygwin
+version).
+
+Add standard EPICS App build system (`configure/`).
+
+Some re-ordering of directories.
+When upgrading from 2.7 or earlier to 2.8, better start with a fresh
+source directory to avoid problems with files that have moved.
+
+### New Features
+
+Support for 64 bit integers. This affects some conversions (e.g. in `ai`
+and `ao` records).
+
+Device support for new record types `int64in`, `int64out`, `lsi` and `lso`
+added.
+
+Support for new `INT64` and `UINT64` types in `aai`, `aao` and `waveform`
+records.
+
+Allow spaces in protocol parameter list in record link.
+One space after the opening `(`, before and after the separating `,` and
+before the closing `)` ignored. More spaces are part of the parameter.
+
+String format `%s` can now pad with 0-bytes instead of spaces using the
+`0` flag.
+
+New checksums `%<cpi>` and `%<leybold>`.
+
+Properly distinguish beween signed and unsigned integers, e.g. when
+converting to double.
+Allow signed enums to do this: `%#{backwards=-1|stop=0|forwards=1}`.
+
+#### New connection handling
+
+Run `@init` handler each time the device (re-)connects
+(as long as asynDriver detects connection changes), also at each `iocRun`
+(after being paused with `iocPause`), and after each `streamReload`.
+
+Also run `@init` of a record when the "magic value" 2 is written to the
+`.PROC` field or when new `streamReinitRecord` shell function is called.
+
+Trigger monitors when `@init` updates output records (after the intial run
+in `iocInit`).
+
+Use `"COMM"` error code in `.STAT` when device is disconnected.
+
+If write fails because device has disconnected, try to re-connect and re-do
+write once.
+
+### Bug fixes 
+
+Fix parser bug when command reference was followed by `}` without `;`.
+
+Fix potential buffer overrun during `streamReload`.
+After `streamReload`, properly delete handlers and variables that do not
+exist any longer.
+
+Fix for waveforms of unsigned integers.
+
+Several Windows related fixes and support building shared libraries on
+Windows.
+
+Fix C++11 warnings.
+
+Check formatting of `exec` command for errors.
+
+Fix bug in `dbior` output.
+
+Fix BCD `%D` format and allow negative values.
+
+Fix signed hex and octal formats.
+
+Fix in regsub: Do not run regsub again on substituted string.
+
+### Shell functions
+
+New functions `streamReportRecord` and `streamSetLogfile`.
+
+Support output redirection to file of stream shell functions
+and protocol dump via `dbior`.
+
+### Error and debug output
+
+Cleanup some debug and error messages.
+
+Hex bytes in debug/error output are now highlighted.
+
+`StreamError` can now be set before `iocInit`.
+
+Avoid repeating error messages.
+Thanks to Ben Franksen.
+
+### Documentation
+
+HTML files converted to HTML 5. 
+
+Update and improve several chapters.
+
+## Changes in releases up to 2.7.14
+
+Not available. See git log.

Contributing.md

@@ -0,0 +1,81 @@
+# Contributing to StreamDevice
+
+Contributions from the EPICS community (and others) are welcome.
+To ease the integration process, please follow the following guidelines.
+
+All contributions should be done as a pull request to the git repository
+https://github.com/paulscherrerinstitute/StreamDevice. Make sure to provide
+meaningful commit messages (no essay but more than "changes").
+
+For small modifications, a patch file is sufficient. Send it to me or better
+create an issue on https://github.com/paulscherrerinstitute/StreamDevice/issues
+and attach the patch file.
+
+Justify your change requests. Write a short summary for your pull request
+to explain what the change is about and what it improves or which bug it
+fixes. Use the issue system on github to report bugs.
+
+I reserve the right to accept or reject contributions or to request
+modifications before I accept them.
+
+Of course, you may as well report bugs without providing a solution yourself.
+
+## Code compatibility
+
+All code must compile for any EPICS release from at least R3.14.12 up to the
+latest one. Likewise the code must be compatible with any operating system
+supported by EPICS, like Linux, Windows, MacOS, RTEMS and VxWorks.
+In particular VxWorks 5 compatibility rules out many modern C++ features.
+But there are also other platforms that for example do not support C++11, so
+don't use it. 
+There should also be no compiler warning on any OS.
+
+Avoid compiler dependent features like #pragmas, assumptions on byte order,
+type size (in particular the size of pointers and long int) and other
+non-portable things like the availability of certain header files. Make sure
+non-portable code parts are enclosed in proper compiler branches and provide
+working implementations for all architectures.
+
+Make sure that the code in AsynDriverInterface stays compatible with old
+and new versions of asyn driver.
+
+The core of StreamDevice does not depend on EPICS. This is on purpose, to be
+able to use it in other control system frameworks. Modifications should not
+add EPICS dependencies except to StreamEpics and AsynDriverInterface, or the
+new dependency must be in a separate file which can be left out of the build
+without jeopardizing the main functionality of StreamDevice.
+
+The code must not depend on external libraries that may not be available on
+all systems, except if provided as a separate file which can be left out of
+the build on platforms that do not support the library.
+
+## Language
+
+Write in English. That includes all identifiers (variables, functions, ...),
+comments, documentation and commit messages. Check your spelling.
+
+## File formats
+
+All files are in Unix format (\n line terminators). Do not change them to
+any other format (e.g. Windows with \r\n terminators). Do not add new files in
+other formats.
+
+The files must contain only ASCII characters. Do not use any Unicode multi-byte
+characters (including byte order marks) or any pre-Unicode code page dependent
+characters (e.g. umlaut), not even in comments. Do not use form feed, vertical
+tab, or other control characters except newline.
+
+Indents are 4 spaces. Do not use tabs (except in Makefiles). Make sure your
+editor is set up accordingly.
+
+Files must end in a newline and there must be no spaces at the end of lines.
+Do not add excessive amount of newlines at the end of files.
+
+Do not add any editor configurations (e.g. for emacs) to the files. Also do
+not add any configuration files or directories for development environments,
+editors, etc.
+
+-------
+
+Dirk Zimoch <dirk.zimoch@psi.ch>, June 2021
+

GNUmakefile

@@ -5,7 +5,7 @@ else
 include /ioc/tools/driver.makefile
 EXCLUDE_VERSIONS = 3.13.2
 PROJECT=stream
-BUILDCLASSES += Linux
+BUILDCLASSES += vxWorks Linux WIN32
 
 DOCUDIR = docs
 
@@ -24,7 +24,11 @@ HEADERS += src/StreamFormat.h
 HEADERS += src/StreamFormatConverter.h
 HEADERS += src/StreamBuffer.h
 HEADERS += src/StreamError.h
-HEADERS += src/StreamVersion.h
+HEADERS += src/StreamProtocol.h
+HEADERS += src/StreamBusInterface.h
+HEADERS += src/StreamCore.h
+HEADERS += src/MacroMagic.h
+HEADERS += $(COMMON_DIR)/StreamVersion.h
 
 CPPFLAGS += -DSTREAM_INTERNAL -I$(COMMON_DIR)
 

configure/CONFIG

@@ -1,14 +1,29 @@
-#CONFIG
+# CONFIG - Load build configuration data
-include $(TOP)/configure/CONFIG_APP
+#
-# Add any changes to make definitions here
+# Do not make changes to this file!
 
-#CROSS_COMPILER_TARGET_ARCHS = vxWorks-68040
+# Allow user to override where the build rules come from
-#CROSS_COMPILER_TARGET_ARCHS = 
+RULES = $(EPICS_BASE)
 
-# Use this when your IOC and the host use different paths
+# RELEASE files point to other application tops
-# to access the application. Typically this will be 
+include $(TOP)/configure/RELEASE
-# used with the Microsoft FTP server or with NFS mounts. Use
+-include $(TOP)/configure/RELEASE.$(EPICS_HOST_ARCH)
-# is indicated by failure of the cdCommands script on
+-include $(TOP)/configure/RELEASE.$(EPICS_HOST_ARCH).Common
-# vxWorks. You must rebuild in the iocBoot directory 
+ifdef T_A
-# before this takes effect.
+-include $(TOP)/configure/RELEASE.Common.$(T_A)
-#IOCS_APPL_TOP = <the top of the application as seen by the IOC>
+-include $(TOP)/configure/RELEASE.$(EPICS_HOST_ARCH).$(T_A)
+endif
+
+CONFIG = $(RULES)/configure
+include $(CONFIG)/CONFIG
+
+# Override the Base definition:
+INSTALL_LOCATION = $(TOP)
+
+# CONFIG_SITE files contain other build configuration settings
+include $(TOP)/configure/CONFIG_SITE
+-include $(TOP)/configure/CONFIG_SITE.$(EPICS_HOST_ARCH).Common
+ifdef T_A
+ -include $(TOP)/configure/CONFIG_SITE.Common.$(T_A)
+ -include $(TOP)/configure/CONFIG_SITE.$(EPICS_HOST_ARCH).$(T_A)
+endif

configure/CONFIG_APP

@@ -1,26 +0,0 @@
-# CONFIG_APP
-
-include $(TOP)/configure/RELEASE
--include $(TOP)/configure/RELEASE.$(EPICS_HOST_ARCH)
--include $(TOP)/configure/RELEASE.Common.$(T_A)
--include $(TOP)/configure/RELEASE.$(EPICS_HOST_ARCH).$(T_A)
-
-ifneq ($(wildcard $(EPICS_BASE)/configure),)
-CONFIG=$(EPICS_BASE)/configure
-else
-CONFIG=$(EPICS_BASE)/config
-DIRS += config
-endif
-include $(CONFIG)/CONFIG
-
-INSTALL_LOCATION = $(TOP)
-ifdef INSTALL_LOCATION_APP
-INSTALL_LOCATION = $(INSTALL_LOCATION_APP)
-endif
-
-ifdef T_A
--include $(TOP)/configure/O.$(T_A)/CONFIG_APP_INCLUDE
-endif
-
-# dbst based database optimization (default: NO)
-DB_OPT = NO

configure/CONFIG_SITE

@@ -0,0 +1,40 @@
+# CONFIG_SITE
+
+-include $(SUPPORT)/configure/CONFIG_SITE
+
+# Make any application-specific changes to the EPICS build
+#   configuration variables in this file.
+#
+# Host/target specific settings can be specified in files named
+#   CONFIG_SITE.$(EPICS_HOST_ARCH).Common
+#   CONFIG_SITE.Common.$(T_A)
+#   CONFIG_SITE.$(EPICS_HOST_ARCH).$(T_A)
+
+# CHECK_RELEASE controls the consistency checking of the support
+#   applications pointed to by the RELEASE* files.
+# Normally CHECK_RELEASE should be set to YES.
+# Set CHECK_RELEASE to NO to disable checking completely.
+# Set CHECK_RELEASE to WARN to perform consistency checking but
+#   continue building even if conflicts are found.
+CHECK_RELEASE = YES
+
+# Set this when you only want to compile this application
+#   for a subset of the cross-compiled target architectures
+#   that Base is built for.
+#CROSS_COMPILER_TARGET_ARCHS = vxWorks-ppc32
+
+# To install files into a location other than $(TOP) define
+#   INSTALL_LOCATION here.
+#INSTALL_LOCATION=</absolute/path/to/install/top>
+
+# Set this when the IOC and build host use different paths
+#   to the install location. This may be needed to boot from
+#   a Microsoft FTP server say, or on some NFS configurations.
+#IOCS_APPL_TOP = </IOC's/absolute/path/to/install/top>
+
+# These allow developers to override the CONFIG_SITE variable
+# settings without having to modify the configure/CONFIG_SITE
+# file itself.
+-include $(TOP)/../CONFIG_SITE.local
+-include $(TOP)/../configure/CONFIG_SITE.local
+-include $(TOP)/configure/CONFIG_SITE.local

configure/Makefile

@@ -2,11 +2,7 @@
 
 TOP=..
 
-include $(TOP)/configure/CONFIG_APP
+include $(TOP)/configure/CONFIG
-
-# Set the following to NO to disable consistency checking of
-# the support applications defined in $(TOP)/configure/RELEASE
-CHECK_RELEASE = YES
 
 TARGETS = $(CONFIG_TARGETS)
 CONFIGS += $(subst ../,,$(wildcard $(CONFIG_INSTALLS)))

docs/formats.html

@@ -485,6 +485,12 @@ than 9.
 <p>
 This is not a normal "converter", because no user data is converted.
 Instead, a checksum is calculated from the input or output.
+<span class="new">
+Any pre-processing of input, e.g. by the <a href="#regsub">regsub</a> converter
+is ignored for the calculation of the checksum.
+</span>
+</p>
+<p>
 The <em>width</em> field is the byte number from which to start
 calculating the checksum.
 Default is 0, i.e. the first byte of the input or output of the current
@@ -589,6 +595,23 @@ In input, the next byte or bytes must match the checksum.
    href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</a>.</dd>
  <dt><code>%&lt;hexsum8&gt;</code></dt>
   <dd>One byte. The sum of all hex digits. (Other characters are ignored.)</dd>
+ <dt><code>%&lt;lrc&gt;</code></dt>
+  <dd>One byte. The Longitudinal Redundancy Check according to <a target="ex"
+   href="https://en.wikipedia.org/wiki/Longitudinal_redundancy_check">Wikipedia</a>.</dd>
+ <dt><code>%&lt;hexlrc&gt;</code></dt>
+  <dd>One byte. The LRC for the hex digits. (Other characters are ignored.)</dd>
+ <dt><code>%&lt;leybold&gt;</code></dt>
+  <dd>One byte. Used by some Leybold products. 255-bytesum%255 (+32 if result would be <32)</dd>
+ <dt><code>%&lt;brksCryo&gt;</code></dt>
+  <dd>One byte. Used by Brooks Cryopumps.</dd>
+ <dt><code>%&lt;CPI&gt;</code></dt>
+  <dd>One byte. Used by TRIUMF CPI RF amplifier.</dd>
+ <dt><code>%&lt;bitsum&gt;</code> or <code>%&lt;bitsum8&gt;</code></dt>
+  <dd>One byte. Number of 1 bits in all characters.</dd>
+ <dt><code>%&lt;bitsum16&gt;</code></dt>
+  <dd>Two bytes. Number of 1 bits in all characters.</dd>
+ <dt><code>%&lt;bitsum32&gt;</code></dt>
+  <dd>Four bytes. Number of 1 bits in all characters.</dd>
 </dl>
 
 <a name="regex"></a>
@@ -694,10 +717,14 @@ However if an empty string is matched, searching advances by 1 character in orde
 avoid matching the same empty string again.</span>
 </p>
 <p>
-In input this converter pre-processes data received from the device before
+In input, this converter pre-processes data received from the device before
 following converters read it.
 Converters preceding this one will read unmodified input.
 Thus place this converter before those whose input should be pre-processed.
+<span class="new">
+However, <a href="#chksum">checksum</a> converters will always use the unmodified
+input as sent by the device because the modified input would not match the checksum.
+</span>
 </p>
 <p>
 In output it post-processes data already formatted by preceding converters

docs/makepdf

@@ -1,10 +1,22 @@
 #/bin/sh
-if ! wkhtmltopdf -V >/dev/null 2>&1
+wkhtmltopdf --enable-local-file-access -V >/dev/null 2>&1
-then
+case $? in
+  127)
     echo "wkhtmltopdf not installed." >&2
     echo "See https://wkhtmltopdf.org" >&2
     exit 1
-fi
+    ;;
+  0)
+    # have (and need) --enable-local-file-access
+    ENABLE_FILE_ACCESS=--enable-local-file-access
+    ;;
+  1)
+    # have no (and need no) --enable-local-file-access
+    ;;
+  *)
+    # Some error but I don't know what it means. Try anyway.
+    ;;
+esac
 
 PAGES="
 index.html
@@ -43,5 +55,5 @@ osinterface.html
 "
 
 rm -f stream.pdf
-wkhtmltopdf --print-media-type --dpi 1200 --zoom 0.85 --page-size Letter \
+wkhtmltopdf --print-media-type --page-size Letter \
-$PAGES stream.pdf
+$ENABLE_FILE_ACCESS $PAGES stream.pdf

docs/setup.html

@@ -85,7 +85,7 @@ Make sure that the <em>asyn</em> library can be found by adding the path to the
 ASYN=/home/epics/asyn4-30
 </pre>
 
-<h4>Support for <em>sCalcout</em> record</h4>
+<h4 id="scalcout">Support for <em>sCalcout</em> record</h4>
 <p>
 The <a 
 href="https://htmlpreview.github.io/?https://raw.githubusercontent.com/epics-modules/calc/R3-6-1/documentation/sCalcoutRecord.html"
@@ -109,7 +109,10 @@ modules. Release R2-8 or newer is recommended.
 </p>
 <p>
 Support for the <em>sCalcout</em> is optional. <em>StreamDevice</em> works
-as well without <em>sCalcout</em> or <em>SynApps</em>.
+as well without <em>sCalcout</em> or <em>SynApps</em>. If your application does
+not need this record support, you may load <kbd>stream-base.dbd</kbd> instead of
+<kbd>stream.dbd</kbd>, making it optional to include <em>calc</em> as an
+application dependency.
 </p>
 
 <h4>Support for regular expression matching</h4>
@@ -185,13 +188,14 @@ Regular expressions are optional. If you don't want them, you don't need this.
 Go to the <em>StreamDevice</em> directory
 and run <code>make</code> (or <code>gmake</code>).
 This will create and install the <em>stream</em> library and the
-<kbd>stream.dbd</kbd> file and an example IOC application.
+<em>StreamDevice</em> database definition files and an example IOC application.
 </p>
 
 <p>
 To use <em>StreamDevice</em>, your own application must be built with the
 <em>stream</em> and <em>asyn</em> (and optionally <em>pcre</em>) libraries
-and must load <kbd>asyn.dbd</kbd> and <kbd>stream.dbd</kbd>.
+and must load <kbd>asyn.dbd</kbd> and <kbd>stream.dbd</kbd> (or alternatively
+<kbd>stream-base.dbd</kbd>; see <a href="#scalcout">Support for sCalcout record</a>).
 </p>
 <p>
 Include the following lines in your application <kbd>Makefile</kbd>:
@@ -385,25 +389,54 @@ See the <a href="protocol.html">next chapter</a> for protocol files in depth.
 Generation of debug and error messages is controlled with two shell variables,
 <code>streamDebug</code> and <code>streamError</code>.
 Setting those variables to 1 (actually to any number but 0) enables the
-messages.
+messages. A few noisy and rarely useful debug messages are only enabled when
+setting <code>streamDebug</code> to 2.
 Per default debug messages are switched off and error messages are switched on.
 Errors occuring while loading protocol files are always shown.
 </p>
 <p>
-Warning: Enabling debug messages can create a lot of output!
+Warning: Enabling debug messages this way can create a lot of output!
-At the moment, there is no way to set filters on debug or error messages.
+Therefore, some limited debugging can be enabled per record, independent of
+the <code>streamDebug</code> variable using the <code>.TPRO</code> field of
+the record. Currently, setting <code>.TPRO</code> to 1 or 2 enables some
+basic information about the processing of a record and its i/o.
 </p>
 <p>
 Debug output can be redirected to a file with the command
 <code>streamSetLogfile("<var>filename</var>")</code>.
-When called without a filename, debug output is directed back
+If the file already exists, it will be overwritten, not appended to.
-to the console.
+While debug messages are only written to the defined log file, error messages
+are still printed to <var>stderr</var> too.
+Calling <code>streamSetLogfile</code> without a filename directs debug output
+back to <var>stderr</var> and closes the log file.
+</p>
+<p>
+By default, error messages to the console are printed in red color if
+<var>stderr</var> is a tty at startup time, using ANSI color codes. Some
+terminals may not support this properly.
+The variable <code>streamDebugColored</code> can be set to 0 or 1 to
+disable or enable colored error messages explicitly.
+Error messages written to a log file do not use colors.
+</p>
+<p>
+Error and debug messages are prefixed with a time stamp unless the variable
+<code>streamMsgTimeStamped</code> is set to 0.
+</p>
+<p>
+when a device is unresponsive, StreamDevice may produce many repeated timeout 
+messages. To reduce this, you can set <code>streamErrorDeadTime</code>
+to an integer number of seconds. In this case, repeated timeout messages 
+will not be printed during the specified dead time after the last printed
+message. The default dead time is 0, resulting in every message being printed.
 </p>
 
 <h3>Example (vxWorks):</h3>
 <pre>
 streamError=1
 streamDebug=1
+streamDebugColored=1
+streamErrorDeadTime=30
+streamMsgTimeStamped=1
 streamSetLogfile("logfile.txt")
 </pre>
 
@@ -411,6 +444,9 @@ streamSetLogfile("logfile.txt")
 <pre>
 var streamError 1
 var streamDebug 1
+var streamDebugColored 1
+var streamErrorDeadTime 30
+var streamMsgTimeStamped 1
 streamSetLogfile("logfile.txt")
 </pre>
 

docs/stream.css

@@ -1,90 +1,104 @@
-a:link    {color: #0000D0;}
+a:link    { color: #0000D0; }
-a:visited {color: #0000D0;}
+a:visited { color: #0000D0; }
-a:hover   {color: #FF0000;}
+a:hover   { color: #FF0000; }
 
 body {
-    margin-right:1em;
+    margin-right: 1em;
-    margin-left:15em;
+    margin-left: 15em;
-    margin-top:75px;
+    margin-top: 75px;
-    padding-top:1px;
+    padding-top: 1px;
     font-family: Helvetica, Arial, sans-serif;
     font-size: 100%;
-    background-color:#ffffff;
+    background-color: #ffffff;
 }
 
-a[name] { position:relative; top:-11ex;}
+a[name] {
+    position: relative;
+    top: -11ex;
+}
+
+pre, tt, kbd, code {
+    font-size: 95%;
+    font-family: Mono, "Lucida Console", Courier, monospace;
+}
 
 pre {
-    background-color:#f4f4f4;
+    background-color: #f4f4f4;
-    padding:1ex;
+    padding: 1ex;
-    border:1px solid #000000;
+    border: 1px solid #000000;
-    white-space:pre;
+    white-space: pre;
-    margin:2ex;
+    margin: 2ex;
-    page-break-inside:avoid;
+    page-break-inside: avoid;
+    font-size: 85%;
+    white-space: pre-wrap;
 }
 
 kbd {
-    font-weight:bold;
+    font-weight: bold;
+}
+
+code {
+    color: #008000;
 }
 
 dt {
-    margin-top:0.5ex;
+    margin-top: 0.5ex;
 }
 
 h1 {
-    font-size:250%;
+    font-size: 250%;
-    margin-top:0;
+    margin-top: 0;
-    font-style:italic;
+    font-style: italic;
-    font-weight:bold;
+    font-weight: bold;
-    font-family:"Times New Roman", serif;
+    font-family: "Times New Roman", Times, serif;
-    text-align:center;
+    text-align: center;
-    position:fixed;
+    position: fixed;
-    top:0;
+    top: 0;
-    left:0;
+    left: 0;
-    width:100%;
+    width: 100%;
-    line-height:190%;
+    line-height: 190%;
-    background-color:white;
+    background-color: white;
-    border-width:0;
+    border-width: 0;
-    border-bottom:3px solid #1b4486;
+    border-bottom: 3px solid #1b4486;
-    white-space:nowrap;
+    white-space: nowrap;
-    background-image:url(PSI.png);
+    background-image: url(PSI.png);
-    background-repeat:no-repeat;
+    background-repeat: no-repeat;
-    background-position:10px 5px;
+    background-position: 10px 5px;
-    text-shadow:.1em .1em .1em darkgray;
+    text-shadow: .1em .1em .1em lightgray;
-    box-shadow:0 .3em .1em -.2em darkgray;
+    box-shadow: 0 .3em .1em -.2em darkgray;
 }
 
 h2 {
-    font-size:150%;
+    font-size: 140%;
-    margin-bottom:0.5ex;
+    margin-bottom: 0.5ex;
 }
 
 h3 {
-    font-size:120%;
+    font-size: 120%;
-    margin-bottom:0.25ex;
+    margin-bottom: 0.25ex;
 }
 
 h4 {
-    font-size:100%;
+    font-size: 100%;
-    margin-bottom:0.25ex;
+    margin-bottom: 0.25ex;
 }
 
 h1, h2, h3, h4 {
-    page-break-after:avoid;
+    page-break-after: avoid;
 }
 
 p {
-    margin-top:0.75ex;
+    margin-top: 0.75ex;
-    margin-bottom:0.75ex;
+    margin-bottom: 0.75ex;
 }
 
 body h1 + p {
-    margin-top:1.5ex;
+    margin-top: 1.5ex;
-    margin-bottom:0.75ex;
+    margin-bottom: 0.75ex;
 }
 
 footer {
-    font-size:75%;
+    font-size: 75%;
     margin-top: 1em;
     border-top: 1px solid darkgray;
     padding-top: 1em;
@@ -97,44 +111,40 @@ footer a:only-of-type {
 }
 
 small {
-    font-size:75%;
+    font-size: 75%;
-}
-
-code {
-    font-size: 125%;
-    color: #008000;
 }
 
 .indent {
-    text-indent:-4ex;
+    text-indent: -4ex;
-    margin-left:4ex;
+    margin-left: 4ex;
-    margin-top:0.5ex;
+    margin-top: 0.5ex;
-    text-align:left;
+    text-align: left;
 }
 
 .box {
-    margin-left:1ex;
+    margin-left: 1ex;
-    margin-right:1ex;
+    margin-right: 1ex;
-    margin-top:0.5ex;
+    margin-top: 0.5ex;
     padding: 0 1ex;
-    border: 1px solid black;
+    border: thin solid black;
-    text-align:left;
+    text-align: left;
-    background-color:#f0f0f0;
+    background-color: #f0f0f0;
+    page-break-inside: avoid;
 }
 
 #navleft {
-    position:fixed;
+    position: fixed;
-    left:0;
+    left: 0;
-    top:0;
+    top: 0;
-    padding-top:70px;
+    padding-top: 70px;
-    width:14em;
+    width: 14em;
-    height:100%;
+    height: 100%;
-    border-style:solid;
+    border-style: solid;
-    border-color:black;
+    border-color: black;
-    border-width:0 1px 0 0;
+    border-width: 0 1px 0 0;
-    background-color:#e3eaf6;
+    background-color: #e3eaf6;
-    overflow:hidden;
+    overflow: hidden;
-    z-index:0;
+    z-index: 0;
 }
 
 .new {
@@ -142,7 +152,7 @@ code {
 }
 
 a[target=ex]:after {
-  content:" " url(ex.png);
+    content: " " url(ex.png);
 }
 
 a[target=ex]:hover:after {
@@ -150,9 +160,10 @@ a[target=ex]:hover:after {
 }
 
 @media print {
-  a:link    {text-decoration:none;}
+    a:link    { text-decoration: none; }
-  a[target=ex]:after {content:" [" attr(href) "]";}
+    a[target=ex]:after { content:" [" attr(href) "]"; font-size: 75%; }
-  body      {margin:0 4em;}
+    body      { margin: 0 4em; }
-  h1        {position:relative; background-position:0 0;}
+    h1        { position: relative; background-position: 0 0; }
-  #navleft  {display:none;}
+    #navleft  { display: none; }
+    footer    { display: none; }
 }

docs/tipsandtricks.html

@@ -293,9 +293,10 @@ record (stringout, "$(DEVICE):clean_2") {<br>
 <a name="web"></a>
 <h2>I need to read a web page</h2>
 <p>
-First you have to send a correctly formatted HTML request.
+First you have to send a correctly formatted HTML header for a GET request.
-Note that this request must contain the full URL like
+Note that this header must contain the full URL like
-"http://server/page" and must be terminated with <u>two</u> newlines.
+"http://server/page" and must be terminated with <u>two</u>
+CR LF sequences (<code>"\r\n\r\n"</code> or <code>CR LF CR LF</code>).
 The server should be the same as in the
 <a href="setup.html#sta"><code>drvAsynIPPortConfigure</code></a>
 command (if not using a http proxy).
@@ -313,17 +314,18 @@ Read the title of a web page.
 get_title {<br>
 &nbsp;&nbsp;extrainput = ignore;<br>
 &nbsp;&nbsp;replyTimeout = 1000;<br>
-&nbsp;&nbsp;out "GET http://\$1\n\n";<br>
+&nbsp;&nbsp;out "GET http://\$1\r\n\r\n";<br>
 &nbsp;&nbsp;in "%+.1/(?im)&lt;title&gt(.*)&lt\/title&gt;/";<br>
 }
 </code>
 </p>
 <p>
-Terminate the request with two newlines, either explicit like here
+Terminate the request with two carriage return + newlines, either explicit
-<u>or</u> using an 
+like here <u>or</u> using an 
 <a href="protocol.html#sysvar"><code>outTerminator</code></a>.
 The URI (without http:// but including the web server host name)
-is passed as <a href="protocol.html#argvar">argument</a> 1 to <code>\$1</code>.
+is passed as <a href="protocol.html#argvar">argument</a> 1 to <code>\$1</code>
+in this example.
 Note that web servers may be slow, so allow some
 <a href="protocol.html#argvar"><code>replyTimeout</code></a>.
 </p>
@@ -390,7 +392,7 @@ Then we read the number.
 get_title {<br>
 &nbsp;&nbsp;extrainput = ignore;<br>
 &nbsp;&nbsp;replyTimeout = 1000;<br>
-&nbsp;&nbsp;out "GET http://\$1\n\n";<br>
+&nbsp;&nbsp;out "GET http://\$1\r\n\r\n";<br>
 &nbsp;&nbsp;in "%*/Interesting value:/%f more text";<br>
 }
 </code>

src/AsynDriverInterface.cc

@@ -34,18 +34,16 @@ extern "C" {
 #include "iocsh.h"
 #endif
 
-#include "StreamBusInterface.h"
-#include "StreamError.h"
-#include "StreamBuffer.h"
-
 #include "asynDriver.h"
 #include "asynOctet.h"
 #include "asynInt32.h"
 #include "asynUInt32Digital.h"
 #include "asynGpibDriver.h"
 
+#include "StreamBusInterface.h"
+#include "StreamError.h"
+#include "StreamBuffer.h"
 #include "devStream.h"
-
 #include "MacroMagic.h"
 
 #define Z PRINTF_SIZE_T_PREFIX
@@ -887,14 +885,11 @@ readHandler()
             if (pasynOctet->setInputEos(pvtOctet, pasynUser,
                 deveos, (int)deveoslen) == asynSuccess)
             {
-                if (ioAction != AsyncRead)
+                debug2("AsynDriverInterface::readHandler(%s) "
-                {
-                    debug("AsynDriverInterface::readHandler(%s) "
                     "input EOS changed from \"%s\" to \"%s\"\n",
                     clientName(),
                     StreamBuffer(oldeos, oldeoslen).expand()(),
                     StreamBuffer(deveos, deveoslen).expand()());
-                }
                 break;
             }
             deveos++; deveoslen--;
@@ -948,20 +943,18 @@ readHandler()
         eomReason = 0;
         pasynUser->errorMessage[0] = 0;
 
-        debug("AsynDriverInterface::readHandler(%s): ioAction=%s "
-            "read(..., bytesToRead=%" Z "u, ...) "
-            "[timeout=%g sec]\n",
-            clientName(), toStr(ioAction),
-            bytesToRead, pasynUser->timeout);
         status = pasynOctet->read(pvtOctet, pasynUser,
             buffer, bytesToRead, &received, &eomReason);
-        // Even though received is size_t I have seen (size_t)-1 here!
+        // Even though received is size_t I have seen (size_t)-1 here
-        debug("AsynDriverInterface::readHandler(%s): "
+        // in case half a terminator had been read last time!
-            "read returned %s: ioAction=%s received=%" Z "d, "
+        if (!(status == asynTimeout && pasynUser->timeout == 0 && received == 0))
+            debug("AsynDriverInterface::readHandler(%s): ioAction=%s "
+                "read(%" Z "u bytes, timeout=%g sec) returned status %s: received=%" Z "d bytes, "
                 "eomReason=%s, buffer=\"%s\"\n",
-            clientName(), toStr(status), toStr(ioAction),
+                clientName(), toStr(ioAction),
-            received, eomReasonToStr(eomReason),
+                bytesToRead, pasynUser->timeout, toStr(status), received,
-            StreamBuffer(buffer, received).expand()());
+                eomReasonToStr(eomReason), StreamBuffer(buffer, received).expand()());
+
         // asyn 4.16 sets reason to ASYN_EOM_END when device disconnects.
         // What about earlier versions?
         if (!connected) eomReason |= ASYN_EOM_END;
@@ -1037,7 +1030,7 @@ readHandler()
                     // reply timeout
                     if (ioAction == AsyncRead)
                     {
-                        debug("AsynDriverInterface::readHandler(%s): "
+                        debug2("AsynDriverInterface::readHandler(%s): "
                             "no async input, retry in in %g seconds\n",
                             clientName(), replyTimeout);
                         // start next poll after timer expires
@@ -1140,9 +1133,10 @@ readHandler()
     {
         pasynOctet->setInputEos(pvtOctet, pasynUser,
             oldeos, oldeoslen);
-        debug("AsynDriverInterface::readHandler(%s) "
+        debug2("AsynDriverInterface::readHandler(%s) "
-            "input EOS restored to \"%s\"\n",
+            "input EOS restored from \"%s\" to \"%s\"\n",
             clientName(),
+            StreamBuffer(deveos, deveoslen).expand()(),
             StreamBuffer(oldeos, oldeoslen).expand()());
     }
 }
@@ -1360,8 +1354,6 @@ timerExpired()
             // at the moment if another asynUser got input right now.
             // queueRequest might fail if another request was just queued
             pasynManager->isAutoConnect(pasynUser, &autoconnect);
-            debug("%s: polling for I/O Intr: autoconnected: %d, connect: %d\n",
-                clientName(), autoconnect, connected);
             if (autoconnect && !connected)
             {
                 // has explicitely been disconnected
@@ -1375,7 +1367,7 @@ timerExpired()
                 asynStatus status = pasynManager->queueRequest(pasynUser,
                     asynQueuePriorityLow, -1.0);
                 // if this fails, we are already queued by another thread
-                debug("AsynDriverInterface::timerExpired %s: "
+                debug2("AsynDriverInterface::timerExpired %s: "
                     "queueRequest(..., priority=Low, queueTimeout=-1) = %s %s\n",
                     clientName(), toStr(status),
                     status!=asynSuccess ? pasynUser->errorMessage : "");
@@ -1493,7 +1485,7 @@ void AsynDriverInterface::
 handleRequest()
 {
     cancelTimer();
-    debug("AsynDriverInterface::handleRequest(%s) %s\n",
+    debug2("AsynDriverInterface::handleRequest(%s) %s\n",
         clientName(), toStr(ioAction));
     switch (ioAction)
     {

src/BinaryConverter.cc

@@ -22,6 +22,7 @@
 
 #include <ctype.h>
 #include <limits.h>
+
 #include "StreamFormatConverter.h"
 #include "StreamError.h"
 

src/ChecksumConverter.cc

@@ -20,45 +20,64 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
-#include "StreamFormatConverter.h"
+#ifdef vxWorks
-#include "StreamError.h"
+  #include <version.h>
-#include <ctype.h>
+  /* VxWorks has strncasecmp since version 6
-#if defined(__vxworks) || defined(vxWorks)
+     but availability depends on configuration.
-#define PRIX32 "lX"
+     We cannot know.
-#define PRIu32 "lu"
+  */
-#define PRIX8  "X"
+  #define NEED_strncasecmp
-#define SCNx8  "hhx"
+  /* VxWorks does not have inttypes.h and uint32_t differs between versions */
-#define uint_fast8_t uint8_t
+  #if defined(_WRS_VXWORKS_MAJOR) && (_WRS_VXWORKS_MAJOR > 6 || (_WRS_VXWORKS_MAJOR == 6 && _WRS_VXWORKS_MINOR >= 9))
-#define int_fast8_t int8_t
+    #define PRIX32 "X"
-#elif defined(_MSC_VER) && _MSC_VER < 1700 /* Visual Studio 2010 does not have inttypes.h */
+    #define PRIu32 "u"
-#include <stdint.h>
+  #else
-#define PRIX32 "X"
+    #define PRIX32 "lX"
-#define PRIu32 "u"
+    #define PRIu32 "lu"
-#define PRIX8  "X"
+  #endif
-#define SCNx8  "hhx"
+  #define PRIX8  "X"
+#elif defined(_MSC_VER) && _MSC_VER < 1700
+  /* Visual Studio 2010 does not have inttypes.h */
+  #define PRIX32 "X"
+  #define PRIu32 "u"
+  #define PRIX8  "X"
 #else
-#define __STDC_FORMAT_MACROS
+  #define __STDC_FORMAT_MACROS
-#include <stdint.h>
+  #include <inttypes.h>
-#include <inttypes.h>
 #endif
 
-#if defined(__vxworks) || defined(vxWorks) || defined(_WIN32) || defined(__rtems__)
+#include <ctype.h>
-// These systems have no strncasecmp
+#include <stdlib.h>
-#include "epicsVersion.h"
+
-#ifdef BASE_VERSION
+#if defined(__rtems__)
-// 3.13
+  #include <rtems.h>
-static int strncasecmp(const char *s1, const char *s2, size_t n)
+  #if __RTEMS_MAJOR__ < 5
-{
+    /* RTEMS has strncasecmp since version 5 */
+    #define NEED_strncasecmp
+  #endif
+#endif
+
+#ifdef _MSC_VER
+  /* Windows strncasecmp has a different name. */
+  #define strncasecmp _strnicmp
+#endif
+
+#ifdef NEED_strncasecmp
+// Have no strncasecmp but avoid compiler errors in case it exists in future versions
+extern "C" {
+    static int mystrncasecmp(const char *s1, const char *s2, size_t n)
+    {
         int r=0;
         while (n && (r = toupper(*s1)-toupper(*s2)) == 0) { n--; s1++; s2++; };
         return r;
+    }
 }
-#else
+#define strncasecmp mystrncasecmp
-#include "epicsString.h"
-#define strncasecmp epicsStrnCaseCmp
-#endif
 #endif
 
+#include "StreamFormatConverter.h"
+#include "StreamError.h"
+
 typedef uint32_t (*checksumFunc)(const uint8_t* data, size_t len,  uint32_t init);
 
 static uint32_t sum(const uint8_t* data, size_t len, uint32_t sum)
@@ -84,6 +103,33 @@ static uint32_t xor7(const uint8_t* data, size_t len, uint32_t sum)
     return xor8(data, len, sum) & 0x7F;
 }
 
+static uint32_t bitsum(const uint8_t* data, size_t len, uint32_t sum)
+{
+    // number of set bits in each byte
+    const uint8_t table[256] = {
+        0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
+        1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+        1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+        1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+        3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+        1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+        3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+        2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+        3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+        3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+        4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8};
+    while (len--)
+    {
+        sum += table[*data++];
+    }
+    return sum;
+}
+
 static uint32_t crc_0x07(const uint8_t* data, size_t len, uint32_t crc)
 {
     // x^8 + x^2 + x^1 + x^0 (0x07)
@@ -502,6 +548,7 @@ static uint32_t leybold(const uint8_t* data, size_t len, uint32_t sum)
         sum += *data++;
     }
     sum = ~sum;
+    sum &= 0xff;
     if (sum < 32) sum+=32;
     return sum;
 }
@@ -517,6 +564,67 @@ static uint32_t brksCryo(const uint8_t* data, size_t len, uint32_t sum)
     return xsum;
 }
 
+// Longitudinal Redundancy Check
+static uint32_t lrc(const uint8_t* data, size_t len, uint32_t sum)
+{
+    while (len--) {
+        sum = (sum + (*data++)) & 0xFF;
+    }
+
+    sum = ((sum ^ 0xFF) + 1) & 0xFF;
+
+    return sum;
+}
+
+// Longitudinal Redundancy Check using ASCII representation of numbers, 2-by-2
+static uint32_t hexlrc(const uint8_t* data, size_t len, uint32_t sum)
+{
+    uint32_t d;
+    uint32_t final_digit = 0;
+
+    while (len--)
+    {
+        d = toupper(*data++);
+
+        // Convert all hex digits, ignore all other bytes
+        if (isxdigit(d))
+        {
+            // Convert digits from ASCII to number
+            if (isdigit(d)) {
+                d -= '0';
+            }
+            else {
+                d -= 'A' - 0x0A;
+            }
+
+            // For the most significant bits, shift 4 bits
+            if (len % 2) {
+                final_digit = d << 4;
+            // Least significant bits are summed to previous converted digit
+            } else {
+                d += final_digit;
+                final_digit = 0;
+                // Apply lrc rule
+                sum = (sum + d) & 0xFF;
+            }
+        }
+    }
+
+    // Apply lrc rule
+    sum = ((sum ^ 0xFF) + 1) & 0xFF;
+
+    return sum;
+}
+
+// Checksum used by Spellman High Voltage Supplies MPS
+static uint32_t hv_mps(const uint8_t* data, size_t len, uint32_t sum)
+{
+    while (len--)
+    {
+        sum += *data++;
+    }
+    return (~sum & 0x7F) | 0x40;
+}
 
 struct checksum
 {
@@ -560,20 +668,27 @@ static checksum checksumMap[] =
     {"hexsum8", hexsum,           0x00,       0x00,       1}, // 0x2D
     {"cpi",     CPI,              0x00,       0x00,       1}, // 0x7E
     {"leybold", leybold,          0x00,       0x00,       1}, // 0x22
-    {"brksCryo",brksCryo,         0x00,       0x00,       1}  // 0x4A
+    {"brksCryo",brksCryo,         0x00,       0x00,       1}, // 0x4A
+    {"lrc",     lrc,              0x00,       0x00,       1}, // 0x23 
+    {"hexlrc",  hexlrc,           0x00,       0x00,       1}, // 0xA7
+    {"bitsum",  bitsum,           0x00,       0x00,       1}, // 0x21
+    {"bitsum8", bitsum,           0x00,       0x00,       1}, // 0x21
+    {"bitsum16",bitsum,           0x0000,     0x0000,     2}, // 0x0021
+    {"bitsum32",bitsum,           0x00000000, 0x00000000, 4}, // 0x00000021
+    {"hv_mps",  hv_mps,           0xFF,       0x00,       1}  // 0x63
 };
 
 static uint32_t mask[5] = {0, 0xFF, 0xFFFF, 0xFFFFFF, 0xFFFFFFFF};
 
 class ChecksumConverter : public StreamFormatConverter
 {
-    int parse (const StreamFormat&, StreamBuffer&, const char*&, bool);
+    int parse (const StreamFormat&, StreamBuffer&, const char*&, bool scanFormat);
     bool printPseudo(const StreamFormat&, StreamBuffer&);
     ssize_t scanPseudo(const StreamFormat&, StreamBuffer&, size_t& cursor);
 };
 
 int ChecksumConverter::
-parse(const StreamFormat&, StreamBuffer& info, const char*& source, bool)
+parse(const StreamFormat&, StreamBuffer& info, const char*& source, bool scanFormat)
 {
     const char* p = strchr(source, '>');
     if (!p)
@@ -627,7 +742,7 @@ parse(const StreamFormat&, StreamBuffer& info, const char*& source, bool)
             info.append(&xorout, sizeof(xorout));
             info.append(fnum);
             source = p+1;
-            return pseudo_format;
+            return scanFormat ? needs_original_format : pseudo_format;
         }
     }
 
@@ -642,11 +757,16 @@ printPseudo(const StreamFormat& format, StreamBuffer& output)
     const char* info = format.info;
     uint32_t init = extract<uint32_t>(info);
     uint32_t xorout = extract<uint32_t>(info);
-    uint_fast8_t fnum = extract<uint8_t>(info);
+    uint8_t fnum = extract<uint8_t>(info);
 
     size_t start = format.width;
-    size_t length = output.length()-format.width;
+    size_t length = output.length();
-    if (format.prec > 0) length -= format.prec;
+    if (length >= start) length -= start;
+    else length = 0;
+    if (format.prec > 0) {
+        if (length >= (size_t)format.prec) length -= format.prec;
+        else length = 0;
+    }
 
     debug("ChecksumConverter %s: output to check: \"%s\"\n",
         checksumMap[fnum].name, output.expand(start,length)());
@@ -658,8 +778,8 @@ printPseudo(const StreamFormat& format, StreamBuffer& output)
     debug("ChecksumConverter %s: output checksum is 0x%" PRIX32 "\n",
         checksumMap[fnum].name, sum);
 
-    uint_fast8_t i;
+    uint8_t i;
-    uint_fast8_t outchar;
+    uint8_t outchar;
 
     if (format.flags & sign_flag) // decimal
     {
@@ -718,15 +838,19 @@ scanPseudo(const StreamFormat& format, StreamBuffer& input, size_t& cursor)
     uint32_t init = extract<uint32_t>(info);
     uint32_t xorout = extract<uint32_t>(info);
     size_t start = format.width;
-    uint_fast8_t fnum = extract<uint8_t>(info);
+    uint8_t fnum = extract<uint8_t>(info);
-    size_t length = cursor-format.width;
+    size_t length = cursor;
+    if (length >= start) length -= start;
+    else length = 0;
+    if (format.prec > 0) {
+        if (length >= (size_t)format.prec) length -= format.prec;
+        else length = 0;
+    }
 
-    if (format.prec > 0) length -= format.prec;
+    debug("ChecksumConverter %s: input to check: \"%s\"\n",
-
-    debug("ChecksumConverter %s: input to check: \"%s\n",
         checksumMap[fnum].name, input.expand(start,length)());
 
-    uint_fast8_t nDigits =
+    uint8_t nDigits =
         // get number of decimal digits from number of bytes: ceil(bytes*2.5)
         format.flags & sign_flag ? (checksumMap[fnum].bytes + 1) * 25 / 10 - 2 :
         format.flags & (zero_flag|left_flag) ? 2 * checksumMap[fnum].bytes :
@@ -735,8 +859,8 @@ scanPseudo(const StreamFormat& format, StreamBuffer& input, size_t& cursor)
 
     if ((ssize_t)( input.length() - cursor ) < expectedLength)
     {
-        debug("ChecksumConverter %s: Input '%s' too short for checksum\n",
+        debug("ChecksumConverter %s: Input '%s' too short (%zu-%zu<%zu) for checksum\n",
-            checksumMap[fnum].name, input.expand(cursor)());
+            checksumMap[fnum].name, input.expand(cursor)(), input.length(), cursor, expectedLength);
         return -1;
     }
 
@@ -747,7 +871,7 @@ scanPseudo(const StreamFormat& format, StreamBuffer& input, size_t& cursor)
     debug("ChecksumConverter %s: input checksum is 0x%0*" PRIX32 "\n",
         checksumMap[fnum].name, 2*checksumMap[fnum].bytes, sum);
 
-    uint_fast8_t inchar;
+    unsigned int inchar;
 
     if (format.flags & sign_flag) // decimal
     {
@@ -769,12 +893,12 @@ scanPseudo(const StreamFormat& format, StreamBuffer& input, size_t& cursor)
     else
     if (format.flags & alt_flag) // lsb first (little endian)
     {
-        uint_fast8_t i;
+        uint8_t i;
         for (i = 0; i < checksumMap[fnum].bytes; i++)
         {
             if (format.flags & zero_flag) // ASCII
             {
-                if (sscanf(input(cursor+2*i), "%2" SCNx8, (int8_t *) &inchar) != 1)
+                if (sscanf(input(cursor+2*i), "%2x", &inchar) != 1)
                 {
                     debug("ChecksumConverter %s: Input byte '%s' is not a hex byte\n",
                         checksumMap[fnum].name, input.expand(cursor+2*i,2)());
@@ -812,13 +936,13 @@ scanPseudo(const StreamFormat& format, StreamBuffer& input, size_t& cursor)
     }
     else // msb first (big endian)
     {
-        int_fast8_t i;
+        int8_t i;
-        uint_fast8_t j;
+        uint8_t j;
         for (i = checksumMap[fnum].bytes-1, j = 0; i >= 0; i--, j++)
         {
             if (format.flags & zero_flag) // ASCII
             {
-                sscanf(input(cursor+2*i), "%2" SCNx8, (int8_t *) &inchar);
+                sscanf(input(cursor+2*i), "%2x", &inchar);
             }
             else
             if (format.flags & left_flag) // poor man's hex: 0x30 - 0x3F

src/EnumConverter.cc

@@ -20,10 +20,11 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
+#include <stdlib.h>
+
 #include "StreamFormatConverter.h"
 #include "StreamError.h"
 #include "StreamProtocol.h"
-#include <stdlib.h>
 
 // Enum %{string0|string1|...}
 
@@ -76,7 +77,7 @@ parse(const StreamFormat& fmt, StreamBuffer& info,
                 numEnums = -(numEnums+1);
                 info.append('\0');
                 memcpy(info(n), &numEnums, sizeof(numEnums));
-                debug("EnumConverter::parse %ld choices with default: %s\n",
+                debug2("EnumConverter::parse %ld choices with default: %s\n",
                     -numEnums, info.expand()());
                 return enum_format;
             }
@@ -99,7 +100,7 @@ parse(const StreamFormat& fmt, StreamBuffer& info,
             if (*source++ == '}')
             {
                 memcpy(info(n), &numEnums, sizeof(numEnums));
-                debug("EnumConverter::parse %ld choices: %s\n",
+                debug2("EnumConverter::parse %ld choices: %s\n",
                     numEnums, info.expand()());
                 return enum_format;
             }

src/Makefile

@@ -27,12 +27,12 @@ include $(TOP)/configure/CONFIG
 -include CONFIG_STREAM
 -include ../CONFIG_STREAM
 
-LIBRARY_DEFAULT = stream
+LIBRARY_IOC = stream
 
-DBD += $(LIBRARY_DEFAULT).dbd
+DBD += stream.dbd
-DBD += $(LIBRARY_DEFAULT)-base.dbd
+DBD += stream-base.dbd
-ifdef CALC
+ifneq ($(words $(CALC) $(SYNAPPS)), 0)
-DBD += $(LIBRARY_DEFAULT)-scalcout.dbd
+DBD += stream-scalcout.dbd
 endif
 
 ifdef ASYN
@@ -42,7 +42,7 @@ $(warning Asyn not included! Didn't you set ASYN in your RELEASE file?)
 endif
 
 ifeq ($(LOADABLE_MODULE),YES)
-SRCS += $(LIBRARY_DEFAULT)_registerRecordDeviceDriver.cpp
+SRCS += stream_registerRecordDeviceDriver.cpp
 endif
 SRCS += $(BUSSES:%=%Interface.cc)
 SRCS += $(FORMATS:%=%Converter.cc)
@@ -60,6 +60,9 @@ ifneq ($(words $(PCRE_LIB) $(PCRE_INCLUDE)),0)
 LIB_SYS_LIBS_DEFAULT += pcre
 LIB_SYS_LIBS_WIN32 += $(PCRE_LIB)\\pcre
 SHRLIB_DEPLIB_DIRS += $(PCRE_LIB)
+ifdef ENABLE_STATIC
+CPPFLAGS += -DPCRE_STATIC
+endif
 endif
 endif
 
@@ -71,6 +74,10 @@ INC += StreamFormatConverter.h
 INC += StreamBuffer.h
 INC += StreamError.h
 INC += StreamVersion.h
+INC += StreamProtocol.h
+INC += StreamBusInterface.h
+INC += StreamCore.h
+INC += MacroMagic.h
 
 # switch off annoying rset warnings in 3.16+
 CPPFLAGS += -DUSE_TYPED_RSET
@@ -94,28 +101,28 @@ streamReferences: ../CONFIG_STREAM
 	$(PERL) ../makeref.pl Converter $(FORMATS) >> $@
 
 # create stream-base.dbd from all RECORDTYPES except scalcout record
-$(COMMON_DIR)/$(LIBRARY_DEFAULT)-base.dbd: ../CONFIG_STREAM
+$(COMMON_DIR)/stream-base.dbd: ../CONFIG_STREAM
 	$(PERL) ../makedbd.pl $(if $(ASYN),--with-asyn) $(if $(BASE_3_14),,-3.13) $(filter-out scalcout, $(RECORDTYPES)) > $@
 
-$(LIBRARY_DEFAULT)-base.dbd$(DEP): ../CONFIG_STREAM
+stream-base.dbd$(DEP): ../CONFIG_STREAM
-	echo $(LIBRARY_DEFAULT)-base.dbd: $< > $@
+        echo stream-base.dbd: $< > $@
 
-STREAM_DBD_FILES = $(LIBRARY_DEFAULT)-base.dbd
+STREAM_DBD_FILES = stream-base.dbd
 
-ifdef CALC
+ifneq ($(words $(CALC) $(SYNAPPS)), 0)
 # create stream-scalcout.dbd for scalcout record
-$(COMMON_DIR)/$(LIBRARY_DEFAULT)-scalcout.dbd: ../CONFIG_STREAM
+$(COMMON_DIR)/stream-scalcout.dbd: ../CONFIG_STREAM
 	$(PERL) ../makedbd.pl --rec-only scalcout > $@
 
-$(LIBRARY_DEFAULT)-scalcout.dbd$(DEP): ../CONFIG_STREAM
+stream-scalcout.dbd$(DEP): ../CONFIG_STREAM
-	echo $(LIBRARY_DEFAULT)-scalcout.dbd: $< > $@
+        echo stream-scalcout.dbd: $< > $@
 
-STREAM_DBD_FILES += $(LIBRARY_DEFAULT)-scalcout.dbd
+STREAM_DBD_FILES += stream-scalcout.dbd
 endif
 
 # create stream.dbd for all record types
-$(COMMON_DIR)/$(LIBRARY_DEFAULT).dbd: ../CONFIG_STREAM
+$(COMMON_DIR)/stream.dbd: ../CONFIG_STREAM
 	$(PERL) ../makedbd.pl $(if $(ASYN),--with-asyn) $(if $(BASE_3_14),,-3.13) $(RECORDTYPES) > $@
 
-$(LIBRARY_DEFAULT).dbd$(DEP): ../CONFIG_STREAM
+stream.dbd$(DEP): ../CONFIG_STREAM
-	echo $(LIBRARY_DEFAULT).dbd: $< > $@
+        echo stream.dbd: $< > $@

src/MantissaExponentConverter.cc

@@ -22,9 +22,10 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
+#include <math.h>
+
 #include "StreamFormatConverter.h"
 #include "StreamError.h"
-#include <math.h>
 
 // Exponential Converter %m
 // Eric Berryman requested a double format that reads

src/RegexpConverter.cc

@@ -20,13 +20,15 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
-#include "StreamFormatConverter.h"
-#include "StreamError.h"
-#include "pcre.h"
 #include <string.h>
 #include <limits.h>
 #include <ctype.h>
 
+#include "pcre.h"
+
+#include "StreamFormatConverter.h"
+#include "StreamError.h"
+
 #define Z PRINTF_SIZE_T_PREFIX
 
 // Perl regular expressions (PCRE) %/regexp/ and  %#/regexp/subst/

src/StreamBuffer.cc

@@ -25,9 +25,6 @@
 #define _BSD_SOURCE
 #endif
 
-#include "StreamBuffer.h"
-#include "StreamError.h"
-
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
@@ -40,6 +37,7 @@
 
 #include <vxWorks.h>
 #include <fioLib.h>
+#include <string.h>
 
 struct outStr_s {
     char *str;
@@ -74,6 +72,9 @@ int vsnprintf(char *str, size_t size, const char *format, va_list ap) {
 #endif // ! _WRS_VXWORKS_MAJOR
 #endif // vxWorks
 
+#include "StreamBuffer.h"
+#include "StreamError.h"
+
 #define P PRINTF_SIZE_T_PREFIX
 
 void StreamBuffer::
@@ -101,7 +102,7 @@ init(const void* s, ssize_t minsize)
 }
 
 // How the buffer looks like:
-// |----free-----|####used####|--------00--------|
+// |----junk-----|####used####|--------00--------|
 ///|<--- offs -->|<-- len --->|<- cap-offs-len ->|
 // 0            offs      offs+len              cap
 //               |<-------------- minsize --------------->
@@ -253,39 +254,71 @@ replace(ssize_t remstart, ssize_t remlen, const void* ins, ssize_t inslen)
     if (inslen < 0) inslen = 0;
     size_t remend = remstart+remlen;
     size_t newlen = len+inslen-remlen;
+
+// How the buffer looks like before and after:
+// |---junk---|##content_start##|/////////remove_this////////|##content_end##|0000|
+// |<- offs ->|<-- remstart --->|<--------- remlen --------->|               |    |
+// |          |<--------------------- len ---------------------------------->|    |
+// 0         offs           offs+remstart                offs+remend    offs+len cap
+//
+// If content size stays the same, no need to move old content:
+// |---junk---|##content_start##|+++++++inserted_text++++++++|##content_end##|0000|
+//                              |<----- inslen==remlen ----->|         newlen==len
+//
+// If content shrinks (need to clear end of buffer):          |< clear this >|
+// |---junk---|##content_start##|inserted_text|##content_end##|00000000000000|0000|
+// 0         offs               |<- inslen -->|               |< len-newlen >|
+//                                                        offs+newlen    offs+len
+//
+// If content grows but still fits (make sure to keep at least one 0 byte at end):
+// |---junk---|##content_start##|++++++++inserted_text++++++++++|##content_end##|0|
+// |<- offs ->|<--------------------- newlen ---------------------------------->| |
+// 0         offs                                                           offs+newlen<cap
+//
+// If content would overflow, moving to offs 0 may help:
+// May need to clear end if newlen < offs+len:                       |<clear>|
+// |##content_start##|++++++++inserted_text++++++++++|##content_end##|0000000|0000|
+// |<--------------------- newlen ---------------------------------->|       |
+//                                                                newlen  offs+len
+// 
+// Otherwise we need to copy to a new buffer.
+
+
     if (cap <= newlen)
     {
-        // buffer too short
+        // buffer too short, copy to new buffer
         size_t newcap;
         for (newcap = sizeof(local)*2; newcap <= newlen; newcap *= 2);
         char* newbuffer = new char[newcap];
-        memcpy(newbuffer, buffer+offs, remstart);
+        memcpy(newbuffer, buffer+offs, remstart);                           // copy content start
-        memcpy(newbuffer+remstart, ins, inslen);
+        memcpy(newbuffer+remstart, ins, inslen);                            // insert
-        memcpy(newbuffer+remstart+inslen, buffer+offs+remend, len-remend);
+        memcpy(newbuffer+remstart+inslen, buffer+offs+remend, len-remend);  // copy content end
-        memset(newbuffer+newlen, 0, newcap-newlen);
+        memset(newbuffer+newlen, 0, newcap-newlen);                         // clear buffer end
         if (buffer != local)
-        {
+            delete[] buffer;
-            delete [] buffer;
-        }
         buffer = newbuffer;
         cap = newcap;
         offs = 0;
     }
     else
     {
-        if (newlen+offs<=cap)
+        if (offs+newlen < cap)
         {
-            // move to start of buffer
+            // modified content still fits with current offs, just move content end
-            memmove(buffer+offs+remstart+inslen, buffer+offs+remend, len-remend);
+            if (newlen != len)
-            memcpy(buffer+offs+remstart, ins, inslen);
+                memmove(buffer+offs+remstart+inslen, buffer+offs+remend, len-remend); // move old content end if necessary
-            if (newlen<len) memset(buffer+offs+newlen, 0, len-newlen);
+            memcpy(buffer+offs+remstart, ins, inslen);                                // insert before
+            if (newlen < len)
+                memset(buffer+offs+newlen, 0, len-newlen);                            // clear buffer end if content shrunk
         }
         else
         {
-            memmove(buffer,buffer+offs,remstart);
+            // move content to start of buffer
-            memmove(buffer+remstart+inslen, buffer+offs+remend, len-remend);
+            memmove(buffer, buffer+offs, remstart);                                   // move content start to 0 offs
-            memcpy(buffer+remstart, ins, inslen);
+            memmove(buffer+remstart+inslen, buffer+offs+remend, len-remend);          // move content end
-            if (newlen<len) memset(buffer+newlen, 0, len-newlen);
+            memcpy(buffer+remstart, ins, inslen);                                     // insert in between
+            if (newlen < offs+len)
+                memset(buffer+newlen, 0, offs+len-newlen);                            // clear buffer end if necessary
             offs = 0;
         }
     }
@@ -341,7 +374,10 @@ StreamBuffer StreamBuffer::expand(ssize_t start, ssize_t length) const
     {
         c = buffer[i];
         if (c < 0x20 || c >= 0x7f)
-            result.print("\033[7m<%02x>\033[27m", c & 0xff);
+            result.print("%s<%02x>%s",
+                         ansiEscape(ANSI_REVERSE_VIDEO),
+                         c & 0xff,
+                         ansiEscape(ANSI_NOT_REVERSE_VIDEO));
         else
             result.append(c);
     }
@@ -354,18 +390,21 @@ dump() const
     StreamBuffer result;
     size_t i;
     result.print("%" P "d,%" P "d,%" P "d:", offs, len, cap);
-    if (offs) result.print("\033[47m");
+    if (offs) result.print("%s", ansiEscape(ANSI_BG_WHITE));
     char c;
     for (i = 0; i < cap; i++)
     {
         c = buffer[i];
-        if (offs && i == offs) result.append("\033[0m");
+        if (offs && i == offs) result.append(ansiEscape(ANSI_RESET));
         if (c < 0x20 || c >= 0x7f)
-            result.print("\033[7m<%02x>\033[27m", c & 0xff);
+            result.print("%s<%02x>%s",
+                         ansiEscape(ANSI_REVERSE_VIDEO),
+                         c & 0xff,
+                         ansiEscape(ANSI_NOT_REVERSE_VIDEO));
         else
             result.append(c);
-        if (i == offs+len-1) result.append("\033[47m");
+        if (i == offs+len-1) result.append(ansiEscape(ANSI_BG_WHITE));
     }
-    result.append("\033[0m");
+    result.append(ansiEscape(ANSI_RESET));
     return result;
 }

src/StreamBusInterface.cc

@@ -21,6 +21,7 @@
 *************************************************************************/
 
 #include <stdio.h>
+
 #include "StreamBusInterface.h"
 #include "StreamError.h"
 

src/StreamCore.cc

@@ -20,13 +20,16 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
-#include "StreamCore.h"
-#include "StreamError.h"
 #include <ctype.h>
 #include <stdlib.h>
 
+#include "StreamCore.h"
+#include "StreamError.h"
+
 #define Z PRINTF_SIZE_T_PREFIX
 
+int streamErrorDeadTime = 0;
+
 /// debug functions /////////////////////////////////////////////
 
 char* StreamCore::
@@ -72,9 +75,9 @@ printCommands(StreamBuffer& buffer, const char* c)
                 buffer.append("    disconnect;\n");
                 break;
             default:
-                buffer.append("\033[31;1mGARBAGE: ");
+                buffer.append(ansiEscape(ANSI_RED_BOLD)).append("GARBAGE: ");
                 c = StreamProtocolParser::printString(buffer, c-1);
-                buffer.append("\033[0m\n");
+                buffer.append(ansiEscape(ANSI_RESET)).append("\n");
         }
     }
 }
@@ -122,12 +125,11 @@ printProtocol(FILE* file)
 StreamCore* StreamCore::first = NULL;
 
 StreamCore::
-StreamCore() : activeCommand(end)
+StreamCore() : StreamBusInterface::Client(),
+    next(), streamname(), flags(None), inTerminatorDefined(), outTerminatorDefined(),
+    activeCommand(end), previousResult(Success), numberOfErrors(0), unparsedInput()
 {
     businterface = NULL;
-    flags = None;
-    next = NULL;
-    unparsedInput = false;
     // add myself to list of streams
     StreamCore** pstream;
     for (pstream = &first; *pstream; pstream = &(*pstream)->next);
@@ -489,6 +491,8 @@ finishProtocol(ProtocolResult status)
         switch (status)
         {
             case Success:
+                previousResult = Success;
+                numberOfErrors = 0;
                 handler = NULL;
                 break;
             case WriteTimeout:
@@ -599,6 +603,7 @@ evalOut()
     // flush all unread input
     unparsedInput = false;
     inputBuffer.clear();
+    inputLine.clear();
     if (!formatOutput())
     {
         finishProtocol(FormatError);
@@ -991,8 +996,10 @@ readCallback(StreamIoStatus status,
                 evalIn();
                 return 0;
             }
+            if (checkShouldPrint(ReplyTimeout)) {
                 error("%s: No reply within %ld ms to \"%s\"\n",
                     name(), replyTimeout, outputLine.expand()());
+            }
             inputBuffer.clear();
             finishProtocol(ReplyTimeout);
             return 0;
@@ -1005,6 +1012,7 @@ readCallback(StreamIoStatus status,
             finishProtocol(Fault);
             return 0;
     }
+    inputHook(input, size);
     inputBuffer.append(input, size);
     debug("StreamCore::readCallback(%s) inputBuffer=\"%s\", size %" Z "u\n",
         name(), inputBuffer.expand()(), inputBuffer.length());
@@ -1109,11 +1117,13 @@ readCallback(StreamIoStatus status,
         }
         else
         {
+            if (checkShouldPrint(ReadTimeout)) {
                 error("%s: Timeout after reading %" Z "d byte%s \"%s%s\"\n",
                     name(), end, end==1 ? "" : "s", end > 20 ? "..." : "",
                     inputBuffer.expand(-20)());
             }
         }
+    }
 
     inputLine.set(inputBuffer(), end);
     debug("StreamCore::readCallback(%s) input line: \"%s\"\n",
@@ -1122,7 +1132,7 @@ readCallback(StreamIoStatus status,
     inputBuffer.remove(end + termlen);
     if (inputBuffer)
     {
-        debug("StreamCore::readCallback(%s) unpared input left: \"%s\"\n",
+        debug("StreamCore::readCallback(%s) unparsed input left: \"%s\"\n",
             name(), inputBuffer.expand()());
         unparsedInput = true;
     }
@@ -1174,6 +1184,7 @@ matchInput()
     char command;
     const char* fieldName = NULL;
     StreamBuffer formatstring;
+    ssize_t delta = 0;
 
     consumedInput = 0;
 
@@ -1208,7 +1219,7 @@ normal_format:
                 debug("StreamCore::matchInput(%s): format = \"%%%s\"\n",
                     name(), formatstring());
 
-                if (fmt.flags & skip_flag || fmt.type == pseudo_format)
+                if (fmt.flags & skip_flag || fmt.type == pseudo_format || fmt.type == needs_original_format)
                 {
                     long ldummy;
                     double ddummy;
@@ -1230,9 +1241,20 @@ normal_format:
                                 scanString(fmt, inputLine(consumedInput), NULL, size);
                             break;
                         case pseudo_format:
-                            // pass complete input
+                            // pass complete input line for scan and/or re-write
+                            size = inputLine.length();
                             consumed = StreamFormatConverter::find(fmt.conv)->
                                 scanPseudo(fmt, inputLine, consumedInput);
+                            delta += inputLine.length() - size; // track length changes
+                            debug("after rewrite delta=%zi\n", delta);
+                            break;
+                        case needs_original_format:
+                            // pass original input with adjusted current position
+                            debug("before checksum delta=%zi\n", delta);
+                            consumedInput -= delta; // correct for length changes
+                            consumed = StreamFormatConverter::find(fmt.conv)->
+                                scanPseudo(fmt, inputBuffer, consumedInput);
+                            consumedInput += delta;
                             break;
                         default:
                             error("INTERNAL ERROR (%s): illegal format.type 0x%02x\n",
@@ -1823,4 +1845,37 @@ license(void)
         "along with StreamDevice. If not, see https://www.gnu.org/licenses/.\n";
 }
 
+/**
+ * \brief Checks whether an error message should be printed based on the new error type.
+ *
+ * Will check based on the error type and the time since last error of the same type
+ * whether to print the new error. Also has a number of side effects such as counting
+ * up errors of each type and resetting the time since last error.
+ *
+ * \param[in] newErrorType the type of the new error
+ * \return true if the error should be preinted, else false
+ */
+bool  StreamCore::checkShouldPrint(ProtocolResult newErrorType)
+{
+    if (previousResult != newErrorType) {
+        previousResult = newErrorType;
+        numberOfErrors = 0;
+        time(&lastErrorTime);
+        return true;
+    }
+    else if ((int)(time(NULL) - lastErrorTime) > streamErrorDeadTime) {
+        time(&lastErrorTime);
+        if (numberOfErrors != 0) {
+            error("%s: %i additional errors of the following type seen in the last %i seconds\n",
+                name(), numberOfErrors, streamErrorDeadTime);
+        }
+        numberOfErrors = 0;
+        return true;
+    }
+    else {
+        numberOfErrors++;
+        return false;
+    }
+}
+
 #include "streamReferences"

src/StreamCore.h

@@ -73,7 +73,7 @@ void acceptEvent(unsigned short mask, unsigned short timeout)
 ***************************************/
 
 #include "MacroMagic.h"
-
+#include "time.h"
 
 // Flags: 0x00FFFFFF reserved for StreamCore
 const unsigned long None             = 0x0000;
@@ -95,6 +95,9 @@ const unsigned long ClearOnStart     = InitRun|AsyncMode|GotValue|Aborted|
                                        BusOwner|Separator|ScanTried|
                                        AcceptInput|AcceptEvent|BusPending;
 
+// The amount of time to wait before printing duplicated messages
+extern int streamErrorDeadTime;
+
 struct StreamFormat;
 
 class StreamCore :
@@ -173,6 +176,11 @@ protected:
     ProtocolResult runningHandler;
     StreamBuffer fieldAddress;
 
+    // Keep track of errors to reduce logging frequencies
+    ProtocolResult previousResult;
+    time_t lastErrorTime;
+    int numberOfErrors;
+
     StreamIoStatus lastInputStatus;
     bool unparsedInput;
 
@@ -211,6 +219,7 @@ protected:
 
 // virtual methods
     virtual void protocolStartHook() {}
+    virtual void inputHook(const void* input, size_t size) {};
     virtual void protocolFinishHook(ProtocolResult) {}
     virtual void startTimer(unsigned long timeout) = 0;
     virtual bool formatValue(const StreamFormat&, const void* fieldaddress) = 0;
@@ -230,6 +239,7 @@ public:
 
 private:
     char* printCommands(StreamBuffer& buffer, const char* c);
+    bool  checkShouldPrint(ProtocolResult newErrorType);
 };
 
 #endif

src/StreamEpics.cc

@@ -21,8 +21,16 @@
 *************************************************************************/
 
 #include <errno.h>
-#include "StreamCore.h"
+#include <ctype.h>
-#include "StreamError.h"
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#if defined(vxWorks)
+#include <symLib.h>
+#include <sysSymTbl.h>
+#endif
 
 #include "epicsVersion.h"
 #ifdef BASE_VERSION
@@ -30,10 +38,11 @@
 #endif
 
 #ifdef EPICS_3_13
+#include <semLib.h>
+#include <wdLib.h>
+#include <taskLib.h>
+
 extern "C" {
-
-static char* epicsStrDup(const char *s) { char* c = (char*)malloc(strlen(s)+1); strcpy(c, s); return c; }
-
 #endif
 
 #define epicsAlarmGLOBAL
@@ -45,18 +54,11 @@ static char* epicsStrDup(const char *s) { char* c = (char*)malloc(strlen(s)+1);
 #include "recGbl.h"
 #include "devLib.h"
 #include "callback.h"
+#include "initHooks.h"
 
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdlib.h>
 #ifdef EPICS_3_13
-
+static char* epicsStrDup(const char *s) { char* c = (char*)malloc(strlen(s)+1); strcpy(c, s); return c; }
-#include <semLib.h>
-#include <wdLib.h>
-#include <taskLib.h>
-
 extern DBBASE *pdbbase;
-
 } // extern "C"
 
 #else // !EPICS_3_13
@@ -71,29 +73,25 @@ extern DBBASE *pdbbase;
 #include "iocsh.h"
 #include "epicsExport.h"
 
-#if defined(VERSION_INT) || EPICS_MODIFICATION >= 11
-#include "initHooks.h"
-#define WITH_IOC_RUN
-#endif
-
 #if !defined(VERSION_INT) && EPICS_MODIFICATION < 9
 // iocshCmd() is missing in iocsh.h (up to R3.14.8.2)
-// To build with win32-x86, you MUST fix iocsh.h.
+// To build for Windows, you MUST fix iocsh.h.
 // Move the declaration below to iocsh.h and rebuild base.
 extern "C" epicsShareFunc int epicsShareAPI iocshCmd(const char *command);
 #endif
 
 #endif // !EPICS_3_13
 
-#if defined(__vxworks) || defined(vxWorks)
+#include "StreamCore.h"
-#include <symLib.h>
+#include "StreamError.h"
-#include <sysSymTbl.h>
-#endif
-
 #include "devStream.h"
 
 #define Z PRINTF_SIZE_T_PREFIX
 
+#if defined(VERSION_INT) || EPICS_MODIFICATION >= 11
+#define WITH_IOC_RUN
+#endif
+
 // More flags: 0x00FFFFFF used by StreamCore
 const unsigned long InDestructor  = 0x0100000;
 const unsigned long ValueReceived = 0x0200000;
@@ -139,6 +137,7 @@ class Stream : protected StreamCore
 #endif
 
 // StreamCore methods
+    void inputHook(const void* input, size_t size);
     void protocolFinishHook(ProtocolResult);
     void startTimer(unsigned long timeout);
     bool getFieldAddress(const char* fieldname,
@@ -170,10 +169,7 @@ class Stream : protected StreamCore
     bool print(format_t *format, va_list ap);
     ssize_t scan(format_t *format, void* pvalue, size_t maxStringSize);
     bool process();
-
-#ifdef WITH_IOC_RUN
     static void initHook(initHookState);
-#endif
 
 // device support functions
     friend long streamInitRecord(dbCommon *record, const struct link *ioLink,
@@ -198,6 +194,9 @@ public:
 extern "C" { // needed for Windows
 epicsExportAddress(int, streamDebug);
 epicsExportAddress(int, streamError);
+epicsExportAddress(int, streamDebugColored);
+epicsExportAddress(int, streamErrorDeadTime);
+epicsExportAddress(int, streamMsgTimeStamped);
 }
 
 // for subroutine record
@@ -330,7 +329,6 @@ epicsExportAddress(drvet, stream);
 #ifdef EPICS_3_13
 void streamEpicsPrintTimestamp(char* buffer, size_t size)
 {
-    size_t tlen;
     char* c;
     TS_STAMP tm;
     tsLocalTime (&tm);
@@ -339,16 +337,17 @@ void streamEpicsPrintTimestamp(char* buffer, size_t size)
     if (c) {
         c[4] = 0;
     }
-    tlen = strlen(buffer);
+}
-    sprintf(buffer+tlen, " %.*s", (int)(size-tlen-2), taskName(0));
+
+static const char* epicsThreadGetNameSelf()
+{
+    return taskName(0);
 }
 #else // !EPICS_3_13
 void streamEpicsPrintTimestamp(char* buffer, size_t size)
 {
-    size_t tlen;
     epicsTime tm = epicsTime::getCurrent();
-    tlen = tm.strftime(buffer, size, "%Y/%m/%d %H:%M:%S.%06f");
+    tm.strftime(buffer, size, "%Y/%m/%d %H:%M:%S.%06f");
-    sprintf(buffer+tlen, " %.*s", (int)(size-tlen-2), epicsThreadGetNameSelf());
 }
 #endif // !EPICS_3_13
 
@@ -438,13 +437,21 @@ long streamReportRecord(const char* recordname)
     return OK;
 }
 
+#if defined(_WIN32) && !defined(_WIN64)
+static const char* epicsThreadGetNameSelfWrapper(void)
+{
+    return epicsThreadGetNameSelf();
+}
+#define epicsThreadGetNameSelf epicsThreadGetNameSelfWrapper
+#endif
+
 long Stream::
 drvInit()
 {
     char* path;
     debug("drvStreamInit()\n");
     path = getenv("STREAM_PROTOCOL_PATH");
-#if defined(__vxworks) || defined(vxWorks)
+#if defined(vxWorks)
     // for compatibility reasons look for global symbols
     if (!path)
     {
@@ -461,31 +468,28 @@ drvInit()
 #endif
     if (!path)
         fprintf(stderr,
-            "drvStreamInit: Warning! STREAM_PROTOCOL_PATH not set. "
+            "drvStreamInit: Warning! STREAM_PROTOCOL_PATH not set.\n");
-            "Defaults to \"%s\"\n", StreamProtocolParser::path);
     else
         StreamProtocolParser::path = path;
     debug("StreamProtocolParser::path = %s\n",
         StreamProtocolParser::path);
     StreamPrintTimestampFunction = streamEpicsPrintTimestamp;
-
+    StreamGetThreadNameFunction = epicsThreadGetNameSelf;
-#ifdef WITH_IOC_RUN
     initHookRegister(initHook);
-#endif
 
     return OK;
 }
 
-#ifdef WITH_IOC_RUN
 void Stream::
 initHook(initHookState state)
 {
     Stream* stream;
 
-    if (state == initHookAtIocRun)
+    switch (state) {
+#ifdef WITH_IOC_RUN
+        case initHookAtIocRun:
         {
-        debug("Stream::initHook(initHookAtIocRun) interruptAccept=%d\n", interruptAccept);
+            // re-run @init handlers after restart
-
             static int inIocInit = 1;
             if (inIocInit)
             {
@@ -498,17 +502,53 @@ initHook(initHookState state)
                 stream = static_cast<Stream*>(stream->next))
             {
                 if (!stream->onInit) continue;
-            debug("Stream::initHook(initHookAtIocRun) Re-inititializing %s\n", stream->name());
+                debug("%s: running @init handler\n", stream->name());
                 if (!stream->startProtocol(StartInit))
                 {
-                error("%s: Re-initialization failed.\n",
+                    error("%s: @init handler failed.\n",
                         stream->name());
                 }
                 stream->initDone.wait();
             }
+            break;
+        }
+        case initHookAtIocPause:
+        {
+            // stop polling I/O Intr
+            for (stream = static_cast<Stream*>(first); stream;
+                stream = static_cast<Stream*>(stream->next))
+            {
+                if (stream->record->scan == SCAN_IO_EVENT) {
+                    debug("%s: stopping \"I/O Intr\"\n", stream->name());
+                    stream->finishProtocol(Stream::Abort);
+                }
+            }
+            break;
+        }
+        case initHookAfterIocRunning:
+#else
+        case initHookAfterInterruptAccept:
+#endif
+        {
+            // start polling I/O Intr
+            for (stream = static_cast<Stream*>(first); stream;
+                stream = static_cast<Stream*>(stream->next))
+            {
+                if (stream->record->scan == SCAN_IO_EVENT) {
+                    debug("%s: starting \"I/O Intr\"\n", stream->name());
+                    if (!stream->startProtocol(StartAsync))
+                    {
+                        error("%s: Can't start \"I/O Intr\" protocol\n",
+                            stream->name());
+                    }
+                }
+            }
+            break;
+        }
+        default:
+            break;
     }
 }
-#endif
 
 // device support (C interface) //////////////////////////////////////////
 
@@ -622,7 +662,16 @@ long streamGetIointInfo(int cmd, dbCommon *record, IOSCANPVT *ppvt)
     *ppvt = stream->ioscanpvt;
     if (cmd == 0)
     {
-        debug("streamGetIointInfo: starting protocol\n");
+#ifdef WITH_IOC_RUN
+        if (!interruptAccept) {
+            // We will start polling later in initHook.
+            debug("streamGetIointInfo(%s): start later...\n",
+                record->name);
+            return OK;
+        }
+#endif
+        debug("streamGetIointInfo(%s): start protocol\n",
+            record->name);
         // SCAN has been set to "I/O Intr"
         if (!stream->startProtocol(Stream::StartAsync))
         {
@@ -633,6 +682,8 @@ long streamGetIointInfo(int cmd, dbCommon *record, IOSCANPVT *ppvt)
     else
     {
         // SCAN is no longer "I/O Intr"
+        debug("streamGetIointInfo(%s): abort protocol\n",
+            record->name);
         stream->finishProtocol(Stream::Abort);
     }
     return OK;
@@ -884,6 +935,10 @@ process()
     debug("Stream::process(%s) start\n", name());
     status = NO_ALARM;
     convert = OK;
+    if (record->tpro)
+    {
+        StreamDebugClass(record->name).print("start protocol '%s'\n", protocolname());
+    }
     if (!startProtocol(record->proc == 2 ? StreamCore::StartInit : StreamCore::StartNormal))
     {
         debug("Stream::process(%s): could not start %sprotocol, status=%s (%d)\n",
@@ -978,11 +1033,26 @@ expire(const epicsTime&)
 
 // StreamCore virtual methods ////////////////////////////////////////////
 
+void Stream::
+inputHook(const void* input, size_t size)
+{
+    if (record->tpro > 1)
+    {
+        StreamDebugClass(record->name).print("received \"%s\"\n",
+            StreamBuffer(input, size).expand()());
+    }
+}
+
 void Stream::
 protocolFinishHook(ProtocolResult result)
 {
     debug("Stream::protocolFinishHook(%s, %s)\n",
         name(), toStr(result));
+    if (record->tpro)
+    {
+        StreamDebugClass(record->name).print("%s. out=\"%s\", in=\"%s\"\n",
+            toStr(result), outputLine.expand()(), inputLine.expand()());
+    }
     switch (result)
     {
         case Success:

src/StreamError.cc

@@ -20,18 +20,26 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
-#include "StreamError.h"
-#ifdef _WIN32
-#include <windows.h>
-#endif
 #include <string.h>
 #include <time.h>
 #include <stdio.h>
 
+#ifdef _WIN32
+#include <windows.h>
+#include <io.h>
+#else
+#include <unistd.h>
+#endif /* _WIN32 */
+
+#include "StreamError.h"
+
 int streamDebug = 0;
 int streamError = 1;
 FILE *StreamDebugFile = NULL;
 
+/*0: disable timestamps on stream messages (both debug and error)*/
+int streamMsgTimeStamped = 1;
+
 #ifndef va_copy
 #ifdef __va_copy
 #define va_copy __va_copy
@@ -46,18 +54,36 @@ FILE *StreamDebugFile = NULL;
 #define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
 #endif
 
-/* Enable ANSI colors in Windows console */
+/* Enable ANSI color support in Windows console */
-static int win_console_init() {
+static bool win_console_init() {
+    HANDLE hCons[] = { GetStdHandle(STD_ERROR_HANDLE),
+                       GetStdHandle(STD_OUTPUT_HANDLE) };
+    for(int i=0; i < sizeof(hCons) / sizeof(HANDLE); ++i)
+    {
         DWORD dwMode = 0;
-    HANDLE hCons = GetStdHandle(STD_ERROR_HANDLE);
+        if (hCons[i] == NULL ||
-    GetConsoleMode(hCons, &dwMode);
+            hCons[i] == INVALID_HANDLE_VALUE ||
+            !GetConsoleMode(hCons[i], &dwMode))
+        {
+            return false;
+        }
         dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-    SetConsoleMode(hCons, dwMode);
+        if (!SetConsoleMode(hCons[i], dwMode))
-    return 0;
+        {
+            return false;
+        }
+    }
+    return true;
 }
-static int s = win_console_init();
 
-#endif
+/* do isatty() call second as always want to run win_console_init() */
+int streamDebugColored = win_console_init() && _isatty(_fileno(stderr));
+
+#else
+
+int streamDebugColored = isatty(fileno(stderr));
+
+#endif /* _WIN32 */
 
 /* You can globally change the printTimestamp function
    by setting the StreamPrintTimestampFunction variable
@@ -73,6 +99,7 @@ static void printTimestamp(char* buffer, size_t size)
 }
 
 void (*StreamPrintTimestampFunction)(char* buffer, size_t size) = printTimestamp;
+const char* (*StreamGetThreadNameFunction)(void) = NULL;
 
 void StreamError(const char* fmt, ...)
 {
@@ -92,44 +119,88 @@ void StreamError(int line, const char* file, const char* fmt, ...)
 
 void StreamVError(int line, const char* file, const char* fmt, va_list args)
 {
-    char timestamp[40];
     if (!(streamError || streamDebug)) return; // Error logging disabled
-    StreamPrintTimestampFunction(timestamp, 40);
+    char timestamp[40];
+    const char *threadname = NULL;
+    int timeStamped = streamMsgTimeStamped;
+    if (timeStamped)
+    {
+        StreamPrintTimestampFunction(timestamp, sizeof(timestamp));
+    }
+    if (StreamGetThreadNameFunction)
+    {
+        threadname = StreamGetThreadNameFunction();
+    }
 #ifdef va_copy
     if (StreamDebugFile)
     {
         va_list args2;
         va_copy(args2, args);
+        if (timeStamped)
+        {
             fprintf(StreamDebugFile, "%s ", timestamp);
+        }
+        if (threadname)
+        {
+            fprintf(StreamDebugFile, "%s ", threadname);
+        }
         vfprintf(StreamDebugFile, fmt, args2);
         fflush(StreamDebugFile);
         va_end(args2);
     }
 #endif
-    fprintf(stderr, "\033[31;1m");
+    fprintf(stderr, "%s", ansiEscape(ANSI_RED_BOLD));
+    if (timeStamped)
+    {
         fprintf(stderr, "%s ", timestamp);
+    }
+    if (threadname)
+    {
+        fprintf(stderr, "%s ", threadname);
+    }
     if (file)
     {
         fprintf(stderr, "%s line %d: ", file, line);
     }
     vfprintf(stderr, fmt, args);
-    fprintf(stderr, "\033[0m");
+    fprintf(stderr, "%s", ansiEscape(ANSI_RESET));
 }
 
 int StreamDebugClass::
 print(const char* fmt, ...)
 {
     va_list args;
-    char timestamp[40];
-    StreamPrintTimestampFunction(timestamp, 40);
     va_start(args, fmt);
+    FILE* fp = StreamDebugFile ? StreamDebugFile : stderr;
+    if (streamMsgTimeStamped)
+    {
+        char timestamp[40];
+        StreamPrintTimestampFunction(timestamp, sizeof(timestamp));
+        fprintf(fp, "%s ", timestamp);
+    }
+    if (StreamGetThreadNameFunction)
+    {
+        fprintf(fp, "%s ", StreamGetThreadNameFunction());
+    }
+    if (file) {
         const char* f = strrchr(file, '/');
         if (f) f++; else f = file;
-    FILE* fp = StreamDebugFile ? StreamDebugFile : stderr;
+        fprintf(fp, "%s:", f);
-    fprintf(fp, "%s ", timestamp);
+        if (line) fprintf(fp, "%d:", line);
-    fprintf(fp, "%s:%d: ", f, line);
+        fprintf(fp, " ");
+    }
     vfprintf(fp, fmt, args);
     fflush(fp);
     va_end(args);
     return 1;
 }
+
+/**
+ * Return an ANSI escape code if coloured debug output is enabled
+ */
+const char* ansiEscape(AnsiMode mode)
+{
+    static const char* AnsiEscapes[] = { "\033[7m", "\033[27m", "\033[47m",
+                                         "\033[0m", "\033[31;1m" };
+    return streamDebugColored ? AnsiEscapes[mode] : "";
+}

src/StreamError.h

@@ -32,7 +32,10 @@
 
 extern int streamDebug;
 extern int streamError;
+extern int streamDebugColored;
+extern int streamMsgTimeStamped;
 extern void (*StreamPrintTimestampFunction)(char* buffer, size_t size);
+extern const char* (*StreamGetThreadNameFunction)(void);
 
 void StreamError(int line, const char* file, const char* fmt, ...)
 __attribute__((__format__(__printf__,3,4)));
@@ -53,17 +56,21 @@ class StreamDebugClass
     const char* file;
     int line;
 public:
-    StreamDebugClass(const char* file, int line) :
+    StreamDebugClass(const char* file = NULL, int line = 0) :
         file(file), line(line) {}
     int print(const char* fmt, ...)
         __attribute__((__format__(__printf__,2,3)));
 };
 
-inline StreamDebugClass
-StreamDebugObject(const char* file, int line)
-{ return StreamDebugClass(file, line); }
-
 #define error StreamError
-#define debug (!streamDebug)?0:StreamDebugObject(__FILE__,__LINE__).print
+#define debug (!streamDebug)?0:StreamDebugClass(__FILE__,__LINE__).print
+#define debug2 (streamDebug<2)?0:StreamDebugClass(__FILE__,__LINE__).print
+
+/*
+ * ANSI escape sequences for terminal output
+ */
+enum AnsiMode { ANSI_REVERSE_VIDEO, ANSI_NOT_REVERSE_VIDEO, ANSI_BG_WHITE,
+                ANSI_RESET, ANSI_RED_BOLD };
+extern const char* ansiEscape(AnsiMode mode);
 
 #endif

src/StreamFormat.h

@@ -42,7 +42,8 @@ typedef enum {
     enum_format,
     double_format,
     string_format,
-    pseudo_format
+    pseudo_format,
+    needs_original_format
 } StreamFormatType;
 
 extern const char* StreamFormatTypeStr[];

src/StreamFormatConverter.cc

@@ -24,6 +24,7 @@
 #include <stdlib.h>
 #include <ctype.h>
 #include <limits.h>
+
 #include "StreamFormatConverter.h"
 #include "StreamError.h"
 
@@ -148,8 +149,6 @@ parseFormat(const char*& source, FormatType formatType, StreamFormat& streamForm
         error("Missing converter character\n");
         return false;
     }
-    debug("StreamFormatConverter::parseFormat: converter='%c'\n",
-        streamFormat.conv);
     StreamFormatConverter* converter;
     converter = StreamFormatConverter::find(streamFormat.conv);
     if (!converter)

src/StreamProtocol.cc

@@ -23,6 +23,7 @@
 #include <ctype.h>
 #include <stdlib.h>
 #include <stdarg.h>
+
 #include "StreamProtocol.h"
 #include "StreamFormatConverter.h"
 #include "StreamError.h"
@@ -52,7 +53,7 @@ class StreamProtocolParser::Protocol::Variable
 // StreamProtocolParser
 
 StreamProtocolParser* StreamProtocolParser::parsers = NULL;
-const char* StreamProtocolParser::path = ".";
+const char* StreamProtocolParser::path = NULL;
 static const char* specialChars = " ,;{}=()$'\"+-*/";
 
 // Client destructor
@@ -156,52 +157,70 @@ this after protocol arguments have been replaced.
 StreamProtocolParser* StreamProtocolParser::
 readFile(const char* filename)
 {
-    FILE* file;
+    FILE* file = NULL;
-#ifdef _WIN32
-    const char pathseparator = ';';
-    const char dirseparator = '\\';
-#else
-    const char pathseparator = ':';
-    const char dirseparator = '/';
-#endif
     StreamProtocolParser* parser;
     const char *p;
-    const char *s;
     size_t n;
     StreamBuffer dir;
 
+    // no path or absolute file name
+    if (!path || filename[0] == '/'
+#ifdef _WIN32
+        || filename[0] == '\\' || (isalpha(filename[0]) && filename[1] == ':')
+#endif
+        ) {
+        // absolute file name
+        file = fopen(filename, "r");
+        if (file) {
+            debug("StreamProtocolParser::readFile: found '%s'\n", filename);
+        } else {
+            error("Can't find readable file '%s'\n", filename);
+            return NULL;
+        }
+    } else {
         // look for filename in every dir in search path
         for (p = path; *p; p += n)
         {
             dir.clear();
-        // get next dir from search path (avoiding strtok, strsep, strcspn)
+            // allow ':' or ';' for OS independence
-        s = strchr(p, pathseparator);
+            // we need to be careful with drive letters though
-        if (s) n = s - p;
+            n = strcspn(p, ":;");
-        else n = strlen(p);
+#ifdef _WIN32
+            if (n == 1 && p[1] == ':' && isalpha(p[0]))
+            {
+                // driver letter
+                n = 2 + strcspn(p+2, ":;");
+            }
+#endif
             dir.append(p, n);
-        if (n && p[n-1] != dirseparator) dir.append(dirseparator);
+            // append / after everything except empty path [or drive letter]
-        if (s) p++;
+            // Windows is fine with / as well
-        // append filename
+            if (n) {
+#ifdef _WIN32
+                if (n != 2 || p[1] != ':' || !isalpha(p[0]))
+#endif
+                dir.append('/');
+            }
+            if (p[n]) n++; // skip the path separator
             dir.append(filename);
             // try to read the file
             debug("StreamProtocolParser::readFile: try '%s'\n", dir());
             file = fopen(dir(), "r");
-        if (file)
+            if (file) {
-        {
+                debug("StreamProtocolParser::readFile: found '%s'\n", dir());
+                break;
+            }
+        }
+        if (!file) {
+            error("Can't find readable file '%s' in '%s'\n", filename, path);
+            return NULL;
+        }
+    }
     // file found; create a parser to read it
     parser = new StreamProtocolParser(file, filename);
     fclose(file);
     if (!parser->valid) return NULL;
-//             printf(
-// "/---------------------------------------------------------------------\\\n");
-//             parser->report();
-//             printf(
-// "\\---------------------------------------------------------------------/\n");
     return parser;
-        }
-    }
-    error("Can't find readable file '%s' in '%s'\n", filename, path);
-    return NULL;
 }
 
 /*
@@ -262,7 +281,7 @@ parseProtocol(Protocol& protocol, StreamBuffer* commands)
         startline = line;
         if (!readToken(token, " ,;{}=()$'\"", isGlobalContext(commands)))
             return false;
-        debug("StreamProtocolParser::parseProtocol:"
+        debug2("StreamProtocolParser::parseProtocol:"
             " token='%s'\n", token.expand()());
 
         if (token[0] == 0)
@@ -413,7 +432,7 @@ parseProtocol(Protocol& protocol, StreamBuffer* commands)
             error(line, filename(), "after command '%s'\n", token());
             return false;
         }
-        debug("parseProtocol: command '%s'\n", (*commands).expand()());
+        debug2("parseProtocol: command '%s'\n", (*commands).expand()());
         commands->append('\0'); // terminate value with null byte
     }
 }
@@ -468,7 +487,7 @@ Each time newline is read, line is incremented.
     if (c == '$')
     {
         // a variable
-        debug("StreamProtocolParser::readToken: Variable\n");
+        debug2("StreamProtocolParser::readToken: Variable\n");
         buffer.append(c);
         if (quote) buffer.append('"'); // mark as quoted variable
         c = getc(file);
@@ -485,7 +504,7 @@ Each time newline is read, line is incremented.
             quote = false;
             // variable like ${xyz}
             if (!readToken(buffer, "{}=;")) return false;
-            debug("StreamProtocolParser::readToken: Variable '%s' in {}\n",
+            debug2("StreamProtocolParser::readToken: Variable '%s' in {}\n",
                 buffer(token));
             c = getc(file);
             if (c != '}')
@@ -511,7 +530,7 @@ Each time newline is read, line is incremented.
     }
     else if (quote || c == '\'' || c == '"')
     {
-        debug("StreamProtocolParser::readToken: Quoted string\n");
+        debug2("StreamProtocolParser::readToken: Quoted string\n");
         // quoted string
         if (!quote)
         {
@@ -570,13 +589,13 @@ Each time newline is read, line is incremented.
     }
     else if (strchr (specialchars, c))
     {
-        debug("StreamProtocolParser::readToken: Special '%c'\n", c);
+        debug2("StreamProtocolParser::readToken: Special '%c'\n", c);
         // a single character
         buffer.append(c);
         return true;
     }
     // a word or (variable name)
-    debug("StreamProtocolParser::readToken: word\n");
+    debug2("StreamProtocolParser::readToken: word\n");
     while (1)
     {
         buffer.append(tolower(c));
@@ -587,7 +606,7 @@ Each time newline is read, line is incremented.
             break;
         }
     }
-    debug("StreamProtocolParser::readToken: word='%s' c='%c'\n",
+    debug2("StreamProtocolParser::readToken: word='%s' c='%c'\n",
         buffer(token), c);
     buffer.append('\0').append(&l, sizeof(l)); // append line number
     return true;
@@ -615,7 +634,7 @@ parseValue(StreamBuffer& buffer, bool lazy)
     {
         token = buffer.length(); // start of next token
         if (!readToken(buffer)) return false;
-        debug("StreamProtocolParser::parseValue:%d: %s\n",
+        debug2("StreamProtocolParser::parseValue:%d: %s\n",
             line, buffer.expand(token)());
         c = buffer[token];
         if (c == '$') // a variable
@@ -775,7 +794,7 @@ Protocol(const Protocol& p, StreamBuffer& name, int _line)
     parameter[0] = protocolname();
     for (i = 0; i < 9; i++)
     {
-        debug("StreamProtocolParser::Protocol::Protocol $%d=\"%s\"\n",
+        if (i) debug("StreamProtocolParser::Protocol::Protocol $%d=\"%s\"\n",
             i, parameter[i]);
         nextparameter = parameter[i] + strlen(parameter[i]) + 1;
         if (nextparameter > name.length() + parameter[0]) break;
@@ -928,7 +947,7 @@ getCommands(const char* handlername, StreamBuffer& code, Client* client)
     if (!pvar) return true;
     if (!pvar->value) return true;
     const char* source = pvar->value();
-    debug("StreamProtocolParser::Protocol::getCommands"
+    debug2("StreamProtocolParser::Protocol::getCommands"
         "(handlername=\"%s\", client=\"%s\"): source=%s\n",
             handlername, client->name(), pvar->value.expand()());
     if (!compileCommands(code, source, client))
@@ -945,15 +964,15 @@ getCommands(const char* handlername, StreamBuffer& code, Client* client)
             "in protocol '%s'\n", protocolname());
         return false;
     }
-    debug("commands %s: %s\n", handlername, pvar->value.expand()());
+    debug2("commands %s: %s\n", handlername, pvar->value.expand()());
-    debug("compiled to: %s\n", code.expand()());
+    debug2("compiled to: %s\n", code.expand()());
     return true;
 }
 
 bool StreamProtocolParser::Protocol::
 replaceVariable(StreamBuffer& buffer, const char* varname)
 {
-    debug("StreamProtocolParser::Protocol::replaceVariable %s\n", varname);
+    debug2("StreamProtocolParser::Protocol::replaceVariable %s\n", varname);
     bool quoted = false;
     if (*++varname == '"')
     {
@@ -1033,16 +1052,16 @@ compileNumber(unsigned long& number, const char*& source, unsigned long max)
     unsigned long n;
     StreamBuffer buffer;
 
-    debug("StreamProtocolParser::Protocol::compileNumber source=\"%s\"\n",
+    debug2("StreamProtocolParser::Protocol::compileNumber source=\"%s\"\n",
         source);
     while (*source == '$' || (*source >= '0' && *source <= '9'))
     {
-        debug("StreamProtocolParser::Protocol::compileNumber *source=%u source=\"%s\"\n",
+        debug2("StreamProtocolParser::Protocol::compileNumber *source=%u source=\"%s\"\n",
             *source, source);
         if (*source == '$')
         {
             if (!replaceVariable(buffer, source)) return false;
-            debug("buffer=%s\n", buffer.expand()());
+            debug2("buffer=%s\n", buffer.expand()());
             buffer.truncate(-1-(int)sizeof(int));
         }
         else
@@ -1077,7 +1096,7 @@ compileNumber(unsigned long& number, const char*& source, unsigned long max)
         return false;
     }
     number = n;
-    debug("StreamProtocolParser::Protocol::compileNumber %s = %ld\n",
+    debug2("StreamProtocolParser::Protocol::compileNumber %s = %ld\n",
         buffer(), n);
     return true;
 }
@@ -1095,7 +1114,7 @@ compileString(StreamBuffer& buffer, const char*& source,
     size_t formatpos = buffer.length();
     line = getLineNumber(source);
 
-    debug("StreamProtocolParser::Protocol::compileString "
+    debug2("StreamProtocolParser::Protocol::compileString "
         "line %d source=\"%s\" formatType=%s quoted=%i recursionDepth=%d\n",
         line, source, ::toStr(formatType), quoted, recursionDepth);
 
@@ -1110,7 +1129,7 @@ compileString(StreamBuffer& buffer, const char*& source,
         // this is step 2: replacing the formats
         if (!*source || (newline = getLineNumber(source)) != line)
         {
-            debug("StreamProtocolParser::Protocol::compileString line %i: %s\n", line, buffer.expand()());
+            debug2("StreamProtocolParser::Protocol::compileString line %i: %s\n", line, buffer.expand()());
             // compile all formats in this line
             // We do this here after all variables in this line
             // have been replaced and after string has been coded.
@@ -1133,7 +1152,7 @@ compileString(StreamBuffer& buffer, const char*& source,
                             formatpos+=2;
                             continue;
                         }
-                        debug("StreamProtocolParser::Protocol::compileString "
+                        debug2("StreamProtocolParser::Protocol::compileString "
                             "format=\"%s\"\n", buffer.expand(formatpos)());
                         nformats++;
                         formatbuffer.clear();
@@ -1150,14 +1169,14 @@ compileString(StreamBuffer& buffer, const char*& source,
                         }
                         size_t formatlen = p - buffer(formatpos);
                         buffer.replace(formatpos, formatlen, formatbuffer);
-                        debug("StreamProtocolParser::Protocol::compileString "
+                        debug2("StreamProtocolParser::Protocol::compileString "
                             "replaced by: \"%s\"\n", buffer.expand(formatpos)());
                         formatpos += formatbuffer.length();
                         continue;
                     }
                     formatpos ++;
                 }
-                debug("StreamProtocolParser::Protocol::compileString "
+                debug2("StreamProtocolParser::Protocol::compileString "
                     "%d formats found in line %d\n", nformats, line);
             }
             if (!*source) break;
@@ -1400,7 +1419,7 @@ compileString(StreamBuffer& buffer, const char*& source,
             "Unexpected '%s' in string\n", source);
         return false;
     }
-    debug("StreamProtocolParser::Protocol::compileString buffer=%s\n", buffer.expand()());
+    debug2("StreamProtocolParser::Protocol::compileString buffer=%s\n", buffer.expand()());
     return true;
 }
 
@@ -1446,7 +1465,7 @@ compileFormat(StreamBuffer& buffer, const char*& formatstr,
         // add fieldname for debug purpose
         fieldname=buffer.length();
         buffer.append(source, fieldnameEnd - source).append(eos);
-        debug("StreamProtocolParser::Protocol::compileFormat: fieldname='%s'\n",
+        debug2("StreamProtocolParser::Protocol::compileFormat: fieldname='%s'\n",
             buffer(fieldname));
         StreamBuffer fieldAddress;
         if (!client->getFieldAddress(buffer(fieldname), fieldAddress))
@@ -1507,14 +1526,14 @@ compileFormat(StreamBuffer& buffer, const char*& formatstr,
     // add formatstr for debug purpose
     buffer.append(formatstart, source-formatstart).append(eos);
 
-    debug("StreamProtocolParser::Protocol::compileFormat: formatstring=\"%s\"\n",
+    debug2("StreamProtocolParser::Protocol::compileFormat: formatstring=\"%s\"\n",
         StreamBuffer(formatstart, source-formatstart).expand()());
 
     // add streamFormat structure and info
     buffer.append(&streamFormat, sizeof(streamFormat));
     buffer.append(infoString);
 
-    debug("StreamProtocolParser::Protocol::compileFormat: format.type=%s, "
+    debug2("StreamProtocolParser::Protocol::compileFormat: format.type=%s, "
         "infolen=%ld infostring=\"%s\"\n",
         StreamFormatTypeStr[streamFormat.type],
         streamFormat.infolen, infoString.expand()());

src/TimestampConverter.cc

@@ -20,14 +20,14 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
-#include "StreamFormatConverter.h"
-#include "StreamError.h"
-
 #include <time.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <errno.h>
 
+#include "StreamFormatConverter.h"
+#include "StreamError.h"
+
 /* timezone in UNIX contains the seconds between UTC and local time,
 but not in Free-BSD! Here timezone() is a function delivering
 the time zone abbreviation (e.g. CET). Alternatively, the timezone

src/devaaiStream.c

@@ -171,10 +171,10 @@ static long writeData(dbCommon *record, format_t *format)
                         break;
 #ifdef DBR_INT64
                     case DBF_INT64:
-                        dval = ((epicsInt64 *)aai->bptr)[nowd];
+                        dval = (double)((epicsInt64 *)aai->bptr)[nowd];
                         break;
                     case DBF_UINT64:
-                        dval = ((epicsUInt64 *)aai->bptr)[nowd];
+                        dval = (double)((epicsUInt64 *)aai->bptr)[nowd];
                         break;
 #endif
                     case DBF_LONG:
@@ -214,10 +214,10 @@ static long writeData(dbCommon *record, format_t *format)
                 {
 #ifdef DBR_INT64
                     case DBF_INT64:
-                        lval = ((epicsInt64 *)aai->bptr)[nowd];
+                        lval = (long)((epicsInt64 *)aai->bptr)[nowd];
                         break;
                     case DBF_UINT64:
-                        lval = ((epicsUInt64 *)aai->bptr)[nowd];
+                        lval = (long)((epicsUInt64 *)aai->bptr)[nowd];
                         break;
 #endif
                     case DBF_LONG:

src/devaaoStream.c

@@ -20,7 +20,6 @@
 * along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 *************************************************************************/
 
-#include <stdio.h>
 #include "epicsString.h"
 #include "aaoRecord.h"
 #include "devStream.h"
@@ -200,10 +199,10 @@ static long writeData(dbCommon *record, format_t *format)
                         break;
 #ifdef DBR_INT64
                     case DBF_INT64:
-                        dval = ((epicsInt64 *)aao->bptr)[nowd];
+                        dval = (double)((epicsInt64 *)aao->bptr)[nowd];
                         break;
                     case DBF_UINT64:
-                        dval = ((epicsUInt64 *)aao->bptr)[nowd];
+                        dval = (double)((epicsUInt64 *)aao->bptr)[nowd];
                         break;
 #endif
                     case DBF_LONG:
@@ -243,10 +242,10 @@ static long writeData(dbCommon *record, format_t *format)
                 {
 #ifdef DBR_INT64
                     case DBF_INT64:
-                        lval = ((epicsInt64 *)aao->bptr)[nowd];
+                        lval = (long)((epicsInt64 *)aao->bptr)[nowd];
                         break;
                     case DBF_UINT64:
-                        lval = ((epicsUInt64 *)aao->bptr)[nowd];
+                        lval = (long)((epicsUInt64 *)aao->bptr)[nowd];
                         break;
 #endif
                     case DBF_LONG:

src/devaoStream.c

@@ -73,7 +73,7 @@ static long readData(dbCommon *record, format_t *format)
     if (record->pact) return DO_NOT_CONVERT;
     /* In @init handler, no processing, enforce monitor updates. */
     ao->omod = ao->oval != val;
-    ao->orbv = ao->oval = val;
+    ao->orbv = (epicsInt32)(ao->oval = val);
     monitor_mask = recGblResetAlarms(record);
     if (!(fabs(ao->mlst - val) <= ao->mdel))
     {

src/devlsiStream.c

@@ -37,7 +37,7 @@ static long readData(dbCommon *record, format_t *format)
     {
         lsi->val[length] = 0;
     }
-    lsi->len = length;
+    lsi->len = (epicsUInt32)length;
     return OK;
 }
 

src/devlsoStream.c

@@ -39,7 +39,7 @@ static long readData(dbCommon *record, format_t *format)
     {
         lso->val[length] = 0;
     }
-    lso->len = length;
+    lso->len = (epicsUInt32)length;
     if (record->pact) return OK;
     /* In @init handler, no processing, enforce monitor updates. */
     monitor_mask = recGblResetAlarms(record);

src/devstringoutStream.c

@@ -43,7 +43,7 @@ static long readData(dbCommon *record, format_t *format)
         strncmp(so->oval, so->val, sizeof(so->val)))
     {
         monitor_mask |= DBE_VALUE | DBE_LOG;
-        strncpy(so->oval, so->val, sizeof(so->val));
+        strncpy(so->oval, so->val, sizeof(so->oval));
     }
     if (monitor_mask)
         db_post_events(record, so->val, monitor_mask);

src/devwaveformStream.c

@@ -172,10 +172,10 @@ static long writeData(dbCommon *record, format_t *format)
                         break;
 #ifdef DBR_INT64
                     case DBF_INT64:
-                        dval = ((epicsInt64 *)wf->bptr)[nowd];
+                        dval = (double)((epicsInt64 *)wf->bptr)[nowd];
                         break;
                     case DBF_UINT64:
-                        dval = ((epicsUInt64 *)wf->bptr)[nowd];
+                        dval = (double)((epicsUInt64 *)wf->bptr)[nowd];
                         break;
 #endif
                     case DBF_LONG:
@@ -215,10 +215,10 @@ static long writeData(dbCommon *record, format_t *format)
                 {
 #ifdef DBR_INT64
                     case DBF_INT64:
-                        lval = ((epicsInt64 *)wf->bptr)[nowd];
+                        lval = (long)((epicsInt64 *)wf->bptr)[nowd];
                         break;
                     case DBF_UINT64:
-                        lval = ((epicsUInt64 *)wf->bptr)[nowd];
+                        lval = (long)((epicsUInt64 *)wf->bptr)[nowd];
                         break;
 #endif
                     case DBF_LONG:

src/makedbd.pl

@@ -32,6 +32,9 @@ if (@ARGV[0] eq "-3.13") {
 } else {
     print "variable(streamDebug, int)\n";
     print "variable(streamError, int)\n";
+    print "variable(streamDebugColored, int)\n";
+    print "variable(streamErrorDeadTime, int)\n";
+    print "variable(streamMsgTimeStamped, int)\n";
     print "registrar(streamRegistrar)\n";
     if ($asyn) { print "registrar(AsynDriverInterfaceRegistrar)\n"; }
 }

streamApp/Makefile

@@ -42,10 +42,12 @@ PROD_SRCS_vxWorks = -nil-
 PROD_LIBS = stream
 
 ifdef ASYN
-# edit asynRegistrars.dbd if necessary
+streamApp_DBD += asyn.dbd
-streamApp_DBD += asynRegistrars.dbd
+streamApp_DBD += drvAsynIPPort.dbd
-# add asynRecord.dbd if you like
+streamApp_DBD += drvAsynSerialPort.dbd
-streamApp_DBD += asynRecord.dbd
+# vxi11 support is optional in recent asyn versions
+#streamApp_DBD += drvVxi11.dbd
+
 PROD_LIBS += asyn
 # cygwin needs separate RPC library for asyn
 PROD_SYS_LIBS_cygwin32 += $(CYGWIN_RPC_LIB)
@@ -78,6 +80,13 @@ endif
 
 PROD_LIBS += $(EPICS_BASE_IOC_LIBS)
 
+# Some linux systems moved RPC related symbols to libtirpc
+# Define TIRPC in configure/CONFIG_SITE in this case
+ifeq ($(TIRPC),YES)
+  USR_INCLUDES_Linux += -I/usr/include/tirpc
+  PROD_SYS_LIBS_DEFAULT += tirpc
+endif
+
 # switch off annoying rset warnings in 3.16+
 CPPFLAGS += -DUSE_TYPED_RSET
 

streamApp/asynRegistrars.dbd

@@ -1,9 +0,0 @@
-registrar(asynRegister)
-registrar(asynInterposeFlushRegister)
-registrar(asynInterposeEosRegister)
-
-# asynDriver up to version 4-16 does not support serial port for Windows!
-registrar(drvAsynSerialPortRegisterCommands)
-registrar(drvAsynIPPortRegisterCommands)
-registrar(drvAsynIPServerPortRegisterCommands)
-registrar(vxi11RegisterCommands)

streamApp/checksums.proto

@@ -54,4 +54,6 @@ write {
     out "%s  hexsum8   %0.12<hexsum8>";
     out "%s  cpi       %0.12<cpi>";
     out "%s  leybold   %0.12<leybold>";
+    out "%s  lrc       %0.12<lrc>";
+    out "%s  hexlrc    %0.12<hexlrc>";
 }

streamApp/simple.proto

@@ -19,7 +19,7 @@
 # along with StreamDevice. If not, see https://www.gnu.org/licenses/.
 #########################################################################/
 
-terminator = CR LF;
+terminator = LF;
 
 cmd {
     out "%s";

streamApp/tests/testChecksum

@@ -52,6 +52,10 @@ set protocol {
         out "jamcrc   %s %9.1<jamcrc>";      in "jamcrc   %=s %9.1<jamcrc>";
         out "adler32  %s %9.1<adler32>";     in "adler32  %=s %9.1<adler32>";
         out "hexsum8  %s %9.1<hexsum8>";     in "hexsum8  %=s %9.1<hexsum8>";
+        out "bitsum   %s %9.1<bitsum>";      in "bitsum   %=s %9.1<bitsum>";
+        out "bitsum8  %s %9.1<bitsum8>";     in "bitsum8  %=s %9.1<bitsum8>";
+        out "bitsum16 %s %9.1<bitsum16>";    in "bitsum16 %=s %9.1<bitsum16>";
+        out "bitsum32 %s %9.1<bitsum32>";    in "bitsum32 %=s %9.1<bitsum32>";
 
         out "sum      %s %09.1<sum>";        in "sum      %=s %09.1<sum>";
         out "sum8     %s %09.1<sum8>";       in "sum8     %=s %09.1<sum8>";
@@ -88,6 +92,10 @@ set protocol {
         out "jamcrc   %s %09.1<jamcrc>";     in "jamcrc   %=s %09.1<jamcrc>";
         out "adler32  %s %09.1<adler32>";    in "adler32  %=s %09.1<adler32>";
         out "hexsum8  %s %09.1<hexsum8>";    in "hexsum8  %=s %09.1<hexsum8>";
+        out "bitsum   %s %09.1<bitsum>";     in "bitsum   %=s %09.1<bitsum>";
+        out "bitsum8  %s %09.1<bitsum8>";    in "bitsum8  %=s %09.1<bitsum8>";
+        out "bitsum16 %s %09.1<bitsum16>";   in "bitsum16 %=s %09.1<bitsum16>";
+        out "bitsum32 %s %09.1<bitsum32>";   in "bitsum32 %=s %09.1<bitsum32>";
 
         out "sum      %s %-9.1<sum>";        in "sum      %=s %-9.1<sum>";
         out "sum8     %s %-9.1<sum8>";       in "sum8     %=s %-9.1<sum8>";
@@ -124,6 +132,10 @@ set protocol {
         out "jamcrc   %s %-9.1<jamcrc>";     in "jamcrc   %=s %-9.1<jamcrc>";
         out "adler32  %s %-9.1<adler32>";    in "adler32  %=s %-9.1<adler32>";
         out "hexsum8  %s %-9.1<hexsum8>";    in "hexsum8  %=s %-9.1<hexsum8>";
+        out "bitsum   %s %-9.1<bitsum>";     in "bitsum   %=s %-9.1<bitsum>";
+        out "bitsum8  %s %-9.1<bitsum8>";    in "bitsum8  %=s %-9.1<bitsum8>";
+        out "bitsum16 %s %-9.1<bitsum16>";   in "bitsum16 %=s %-9.1<bitsum16>";
+        out "bitsum32 %s %-9.1<bitsum32>";   in "bitsum32 %=s %-9.1<bitsum32>";
 
         out "sum      %s %#9.1<sum>";        in "sum      %=s %#9.1<sum>";
         out "sum8     %s %#9.1<sum8>";       in "sum8     %=s %#9.1<sum8>";
@@ -160,6 +172,10 @@ set protocol {
         out "jamcrc   %s %#9.1<jamcrc>";     in "jamcrc   %=s %#9.1<jamcrc>";
         out "adler32  %s %#9.1<adler32>";    in "adler32  %=s %#9.1<adler32>";
         out "hexsum8  %s %#9.1<hexsum8>";    in "hexsum8  %=s %#9.1<hexsum8>";
+        out "bitsum   %s %#9.1<bitsum>";     in "bitsum   %=s %#9.1<bitsum>";
+        out "bitsum8  %s %#9.1<bitsum8>";    in "bitsum8  %=s %#9.1<bitsum8>";
+        out "bitsum16 %s %#9.1<bitsum16>";   in "bitsum16 %=s %#9.1<bitsum16>";
+        out "bitsum32 %s %#9.1<bitsum32>";   in "bitsum32 %=s %#9.1<bitsum32>";
 
         out "sum      %s %#09.1<sum>";       in "sum      %=s %#09.1<sum>";
         out "sum8     %s %#09.1<sum8>";      in "sum8     %=s %#09.1<sum8>";
@@ -196,6 +212,10 @@ set protocol {
         out "jamcrc   %s %#09.1<jamcrc>";    in "jamcrc   %=s %#09.1<jamcrc>";
         out "adler32  %s %#09.1<adler32>";   in "adler32  %=s %#09.1<adler32>";
         out "hexsum8  %s %#09.1<hexsum8>";   in "hexsum8  %=s %#09.1<hexsum8>";
+        out "bitsum   %s %#09.1<bitsum>";    in "bitsum   %=s %#09.1<bitsum>";
+        out "bitsum8  %s %#09.1<bitsum8>";   in "bitsum8  %=s %#09.1<bitsum8>";
+        out "bitsum16 %s %#09.1<bitsum16>";  in "bitsum16 %=s %#09.1<bitsum16>";
+        out "bitsum32 %s %#09.1<bitsum32>";  in "bitsum32 %=s %#09.1<bitsum32>";
 
         out "sum      %s %#-9.1<sum>";       in "sum      %=s %#-9.1<sum>";
         out "sum8     %s %#-9.1<sum8>";      in "sum8     %=s %#-9.1<sum8>";
@@ -232,6 +252,13 @@ set protocol {
         out "jamcrc   %s %#-9.1<jamcrc>";    in "jamcrc   %=s %#-9.1<jamcrc>";
         out "adler32  %s %#-9.1<adler32>";   in "adler32  %=s %#-9.1<adler32>";
         out "hexsum8  %s %#-9.1<hexsum8>";   in "hexsum8  %=s %#-9.1<hexsum8>";
+        out "bitsum   %s %#-9.1<bitsum>";    in "bitsum   %=s %#-9.1<bitsum>";
+        out "bitsum8  %s %#-9.1<bitsum8>";   in "bitsum8  %=s %#-9.1<bitsum8>";
+        out "bitsum16 %s %#-9.1<bitsum16>";  in "bitsum16 %=s %#-9.1<bitsum16>";
+        out "bitsum32 %s %#-9.1<bitsum32>";  in "bitsum32 %=s %#-9.1<bitsum32>";
+
+# Check combination of regsub and checksum. Always check what the device sees.
+        out "crc8     %s%#/[0-9]{2}/&:/ %9.1<crc8>";        in "crc8     %#/[0-9]{2}/&:/%s %9.1<crc8>"; out "%s";
         out "DONE";
     }
 }
@@ -313,6 +340,14 @@ assure "adler32  123456789 \x09\x1E\x01\xDE\n"
 send   "adler32  123456789 \x09\x1E\x01\xDE\n"
 assure "hexsum8  123456789 \x2D\n"
 send   "hexsum8  123456789 \x2D\n"
+assure "bitsum   123456789 \x21\n"
+send   "bitsum   123456789 \x21\n"
+assure "bitsum8  123456789 \x21\n"
+send   "bitsum8  123456789 \x21\n"
+assure "bitsum16 123456789 \x00\x21\n"
+send   "bitsum16 123456789 \x00\x21\n"
+assure "bitsum32 123456789 \x00\x00\x00\x21\n"
+send   "bitsum32 123456789 \x00\x00\x00\x21\n"
 
 assure "sum      123456789 DD\n"
 send   "sum      123456789 DD\n"
@@ -384,6 +419,14 @@ assure "adler32  123456789 091E01DE\n"
 send   "adler32  123456789 091E01DE\n"
 assure "hexsum8  123456789 2D\n"
 send   "hexsum8  123456789 2D\n"
+assure "bitsum   123456789 21\n"
+send   "bitsum   123456789 21\n"
+assure "bitsum8  123456789 21\n"
+send   "bitsum8  123456789 21\n"
+assure "bitsum16 123456789 0021\n"
+send   "bitsum16 123456789 0021\n"
+assure "bitsum32 123456789 00000021\n"
+send   "bitsum32 123456789 00000021\n"
 
 assure "sum      123456789 \x3D\x3D\n"
 send   "sum      123456789 \x3D\x3D\n"
@@ -455,6 +498,14 @@ assure "adler32  123456789 \x30\x39\x31\x3E\x30\x31\x3D\x3E\n"
 send   "adler32  123456789 \x30\x39\x31\x3E\x30\x31\x3D\x3E\n"
 assure "hexsum8  123456789 \x32\x3D\n"
 send   "hexsum8  123456789 \x32\x3D\n"
+assure "bitsum   123456789 \x32\x31\n"
+send   "bitsum   123456789 \x32\x31\n"
+assure "bitsum8  123456789 \x32\x31\n"
+send   "bitsum8  123456789 \x32\x31\n"
+assure "bitsum16 123456789 \x30\x30\x32\x31\n"
+send   "bitsum16 123456789 \x30\x30\x32\x31\n"
+assure "bitsum32 123456789 \x30\x30\x30\x30\x30\x30\x32\x31\n"
+send   "bitsum32 123456789 \x30\x30\x30\x30\x30\x30\x32\x31\n"
 
 assure "sum      123456789 \xDD\n"
 send   "sum      123456789 \xDD\n"
@@ -526,6 +577,14 @@ assure "adler32  123456789 \xDE\x01\x1E\x09\n"
 send   "adler32  123456789 \xDE\x01\x1E\x09\n"
 assure "hexsum8  123456789 \x2D\n"
 send   "hexsum8  123456789 \x2D\n"
+assure "bitsum   123456789 \x21\n"
+send   "bitsum   123456789 \x21\n"
+assure "bitsum8  123456789 \x21\n"
+send   "bitsum8  123456789 \x21\n"
+assure "bitsum16 123456789 \x21\x00\n"
+send   "bitsum16 123456789 \x21\x00\n"
+assure "bitsum32 123456789 \x21\x00\x00\x00\n"
+send   "bitsum32 123456789 \x21\x00\x00\x00\n"
 
 assure "sum      123456789 DD\n"
 send   "sum      123456789 DD\n"
@@ -597,6 +656,14 @@ assure "adler32  123456789 DE011E09\n"
 send   "adler32  123456789 DE011E09\n"
 assure "hexsum8  123456789 2D\n"
 send   "hexsum8  123456789 2D\n"
+assure "bitsum   123456789 21\n"
+send   "bitsum   123456789 21\n"
+assure "bitsum8  123456789 21\n"
+send   "bitsum8  123456789 21\n"
+assure "bitsum16 123456789 2100\n"
+send   "bitsum16 123456789 2100\n"
+assure "bitsum32 123456789 21000000\n"
+send   "bitsum32 123456789 21000000\n"
 
 assure "sum      123456789 \x3D\x3D\n"
 send   "sum      123456789 \x3D\x3D\n"
@@ -668,6 +735,20 @@ assure "adler32  123456789 \x3D\x3E\x30\x31\x31\x3E\x30\x39\n"
 send   "adler32  123456789 \x3D\x3E\x30\x31\x31\x3E\x30\x39\n"
 assure "hexsum8  123456789 \x32\x3D\n"
 send   "hexsum8  123456789 \x32\x3D\n"
+assure "bitsum   123456789 \x32\x31\n"
+send   "bitsum   123456789 \x32\x31\n"
+assure "bitsum8  123456789 \x32\x31\n"
+send   "bitsum8  123456789 \x32\x31\n"
+assure "bitsum16 123456789 \x32\x31\x30\x30\n"
+send   "bitsum16 123456789 \x32\x31\x30\x30\n"
+assure "bitsum32 123456789 \x32\x31\x30\x30\x30\x30\x30\x30\n"
+send   "bitsum32 123456789 \x32\x31\x30\x30\x30\x30\x30\x30\n"
+
+# check regsub and checksums
+assure "crc8     12:34:56:78:9 \x07\n" ;# modified output string and checksum
+send   "crc8     123456789 \xF4\n"     ;# original input string and checksum
+assure "12:34:56:78:9\n"               ;# modified input string
+
 assure "DONE\n"
                 
 finish

streamApp/tests/testStreamBuffer

@@ -1,6 +1,7 @@
 rm -f test.*
 
 cat > test.cc << EOF
+#include <StreamError.h>
 #include <StreamBuffer.h>
 #include <assert.h>
 #include <stdio.h>
@@ -55,14 +56,14 @@ EOF
 
 if [ "$1" = "-sls" ]
 then
-    O=../../O.*_$EPICS_HOST_ARCH/StreamBuffer.o
+    O=../../O.*_$EPICS_HOST_ARCH
 else
-    O=../../src/O.$EPICS_HOST_ARCH/StreamBuffer.o
+    O=../../src/O.$EPICS_HOST_ARCH
 fi
 
 for o in $O
 do
-    g++ -I ../../src $o test.cc -o test.exe
+    g++ -I ../../src $o/StreamBuffer.o $o/StreamError.o test.cc -o test.exe
     ./test.exe
     if [ $? != 0 ]
     then