diff --git a/example/ticker.cpp b/example/ticker.cpp
index c9d9195..0eb8e2c 100644
--- a/example/ticker.cpp
+++ b/example/ticker.cpp
@@ -8,9 +8,12 @@
  */
 
 #include <iostream>
+#include <stdexcept>
+#include <string>
+
+#include <cstring>
 
 #include <epicsTime.h>
-#include <epicsStdlib.h>
 #include <epicsEvent.h>
 
 #include <pvxs/sharedpv.h>
@@ -31,14 +34,16 @@ int main(int argc, char* argv[])
     }
 
     if(argc>=3) {
-        double rate = 0.0;
-
-        if(epicsParseDouble(argv[2], &rate, nullptr) || rate<=0.0) {
-            std::cerr<<"Rate must be a positive number, not "<<argv[2]<<"\n";
+        try {
+            size_t idx=0;
+            delay = 1.0/std::stod(argv[2], &idx);
+            if(idx<std::strlen(argv[2]))
+                throw std::invalid_argument("Extraneous charactors");
+        }catch(std::exception& e){
+            std::cerr<<"Error parsing rate: "<<e.what()<<"\n";
             return 1;
-        }
 
-        delay = 1.0/rate;
+        }
     }
 
     // Read $PVXS_LOG from process environment and update
diff --git a/src/clientmon.cpp b/src/clientmon.cpp
index 4ebc216..94f2c51 100644
--- a/src/clientmon.cpp
+++ b/src/clientmon.cpp
@@ -7,7 +7,6 @@
 #include <epicsAssert.h>
 #include <epicsMutex.h>
 #include <epicsGuard.h>
-#include <epicsStdlib.h>
 
 #include <deque>
 
@@ -530,11 +529,15 @@ std::shared_ptr<Subscription> MonitorBuilder::exec()
         if(ackAny.type()==TypeCode::String) {
             auto sval = ackAny.as<std::string>();
             if(sval.size()>1 && sval.back()=='%') {
-                double percent=50.0;
-                char *units = nullptr;
-                if(epicsParseDouble(sval.c_str(), &percent, &units)==0 && units && units[0]=='%') {
-                    if(percent>0.0 && percent<=100.0)
+                try {
+                    auto percent = parseTo<double>(sval);
+                    if(percent>0.0 && percent<=100.0) {
                         op->ackAt = uint32_t(percent * op->queueSize);
+                    } else {
+                        throw std::invalid_argument("not in range (0%, 100%]");
+                    }
+                }catch(std::exception&){
+                    log_warn_printf(monevt, "Error parsing as percent ackAny: \"%s\"\n", sval.c_str());
                 }
             }
 
diff --git a/src/config.cpp b/src/config.cpp
index 3aaa4bd..5c171cc 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -134,7 +134,7 @@ Config Config::from_env()
 
     if(const char *env = pickenv(&name, {"EPICS_PVAS_SERVER_PORT", "EPICS_PVA_SERVER_PORT"})) {
         try {
-            ret.tcp_port = lexical_cast<unsigned short>(env);
+            ret.tcp_port = parseTo<uint64_t>(env);
         }catch(std::exception& e) {
             log_err_printf(serversetup, "%s invalid integer : %s", name, e.what());
         }
@@ -142,7 +142,7 @@ Config Config::from_env()
 
     if(const char *env = pickenv(&name, {"EPICS_PVAS_BROADCAST_PORT", "EPICS_PVA_BROADCAST_PORT"})) {
         try {
-            ret.udp_port = lexical_cast<unsigned short>(env);
+            ret.udp_port = parseTo<uint64_t>(env);
         }catch(std::exception& e) {
             log_err_printf(serversetup, "%s invalid integer : %s", name, e.what());
         }
@@ -246,7 +246,7 @@ Config Config::from_env()
 
     if(const char *env = pickenv(&name, {"EPICS_PVA_BROADCAST_PORT"})) {
         try {
-            ret.udp_port = lexical_cast<unsigned short>(env);
+            ret.udp_port = parseTo<uint64_t>(env);
         }catch(std::exception& e) {
             log_err_printf(serversetup, "%s invalid integer : %s", name, e.what());
         }
diff --git a/src/data.cpp b/src/data.cpp
index e1de3e4..bbf94e8 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -7,8 +7,6 @@
 #include <cstring>
 #include <epicsAssert.h>
 
-#include <epicsStdlib.h>
-
 #include "dataimpl.h"
 #include "utilpvt.h"
 
@@ -353,25 +351,16 @@ void Value::copyOut(void *ptr, StoreType type) const
         switch(type) {
         case StoreType::String: *reinterpret_cast<std::string*>(ptr) = src; return;
         case StoreType::Integer: {
-            epicsInt64 temp;
-            if(epicsParseInt64(src.c_str(), &temp, 0, nullptr)==0) {
-                *reinterpret_cast<int64_t*>(ptr) = temp;
-                return;
-            }
+            *reinterpret_cast<int64_t*>(ptr) = parseTo<int64_t>(src);
+            return;
         }
         case StoreType::UInteger: {
-            epicsUInt64 temp;
-            if(epicsParseUInt64(src.c_str(), &temp, 0, nullptr)==0) {
-                *reinterpret_cast<uint64_t*>(ptr) = temp;
-                return;
-            }
+            *reinterpret_cast<uint64_t*>(ptr) = parseTo<uint64_t>(src);
+            return;
         }
         case StoreType::Real: {
-            double temp;
-            if(epicsParseDouble(src.c_str(), &temp, nullptr)==0) {
-                *reinterpret_cast<double*>(ptr) = temp;
-                return;
-            }
+            *reinterpret_cast<double*>(ptr) = parseTo<double>(src);
+            return;
         }
         case StoreType::Bool: {
             if(src=="true") { *reinterpret_cast<bool*>(ptr) = true; return; }
@@ -432,31 +421,6 @@ bool Value::tryCopyOut(void *ptr, StoreType type) const
 
 namespace {
 
-bool parseScalar(double& dest, const std::string& inp)
-{
-    return 0==epicsParseDouble(inp.c_str(), &dest, nullptr);
-}
-
-bool parseScalar(int64_t& dest, const std::string& inp)
-{
-    epicsInt64 t;
-    if(epicsParseInt64(inp.c_str(), &t, 0, nullptr)==0) {
-        dest = t;
-        return true;
-    }
-    return false;
-}
-
-bool parseScalar(uint64_t& dest, const std::string& inp)
-{
-    epicsUInt64 t;
-    if(epicsParseUInt64(inp.c_str(), &t, 0, nullptr)==0) {
-        dest = t;
-        return true;
-    }
-    return false;
-}
-
 // C-style cast between scalar storage types, and print to string (base 10)
 template<typename Dest>
 bool copyInScalar(Dest& dest, const void *ptr, StoreType type)
@@ -466,7 +430,7 @@ bool copyInScalar(Dest& dest, const void *ptr, StoreType type)
     case StoreType::Integer:  dest = Dest(*reinterpret_cast<const int64_t*>(ptr)); return true;
     case StoreType::UInteger: dest = Dest(*reinterpret_cast<const uint64_t*>(ptr)); return true;
     case StoreType::Bool:     dest = Dest(*reinterpret_cast<const bool*>(ptr)); return true;
-    case StoreType::String:   return parseScalar(dest, *reinterpret_cast<const std::string*>(ptr));
+    case StoreType::String:   dest = parseTo<Dest>(*reinterpret_cast<const std::string*>(ptr)); return true;
     case StoreType::Null:
     case StoreType::Compound:
     case StoreType::Array:
@@ -728,12 +692,11 @@ void Value::traverse(const std::string &expr, bool modify)
             maybedot = false;
 
             size_t sep = expr.find_first_of(']', pos);
-            unsigned long long index=0;
 
             if(expr[pos]=='['
-                    && sep!=std::string::npos && sep-pos>=2
-                    && !epicsParseULLong(expr.substr(pos+1, sep-1-pos).c_str(), &index, 0, nullptr))
+                    && sep!=std::string::npos && sep-pos>=2)
             {
+                auto index = parseTo<uint64_t>(expr.substr(pos+1, sep-1-pos));
                 auto& varr = store->as<shared_array<const void>>();
                 shared_array<const Value> arr;
                 if((varr.original_type()==ArrayType::Value)
diff --git a/src/sharedarray.cpp b/src/sharedarray.cpp
index cc9b65b..7bc693b 100644
--- a/src/sharedarray.cpp
+++ b/src/sharedarray.cpp
@@ -6,7 +6,6 @@
 
 #include <string.h>
 
-#include <epicsStdlib.h>
 #include <epicsTypes.h>
 
 #include <pvxs/sharedArray.h>
@@ -164,37 +163,26 @@ void parseValue(bool& dest, const std::string& src)
         throw std::runtime_error(SB()<<"Expected \"true\" or \"false\", not \""<<escape(src)<<"\"");
 }
 
-#define CASE(ETYPE, TYPE) \
-void parseValue(TYPE& dest, const std::string& src) { \
-    epics ## ETYPE temp; \
-    if(epicsParse ## ETYPE(src.c_str(), &temp, 0, nullptr)) \
-        throw std::runtime_error(SB()<<"Expected " #TYPE ", not \""<<escape(src)<<"\""); \
-    dest = temp; \
+template<typename Dest>
+typename std::enable_if<std::is_integral<Dest>::value && std::is_signed<Dest>::value>::type
+parseValue(Dest& dest, const std::string& src)
+{
+    dest = Dest(parseTo<int64_t>(src));
 }
 
-CASE(Int8, int8_t)
-CASE(Int16, int16_t)
-CASE(Int32, int32_t)
-CASE(Int64, int64_t)
-CASE(UInt8, uint8_t)
-CASE(UInt16, uint16_t)
-CASE(UInt32, uint32_t)
-CASE(UInt64, uint64_t)
-
-#undef CASE
-
-#define CASE(ETYPE, TYPE) \
-void parseValue(TYPE& dest, const std::string& src) { \
-    epics ## ETYPE temp; \
-    if(epicsParse ## ETYPE(src.c_str(), &temp, nullptr)) \
-        throw std::runtime_error(SB()<<"Expected " #TYPE ", not \""<<escape(src)<<"\""); \
-    dest = temp; \
+template<typename Dest>
+typename std::enable_if<std::is_integral<Dest>::value && !std::is_signed<Dest>::value && !std::is_same<Dest, bool>::value>::type
+parseValue(Dest& dest, const std::string& src)
+{
+    dest = Dest(parseTo<uint64_t>(src));
 }
 
-CASE(Float32, float)
-CASE(Float64, double)
-
-#undef CASE
+template<typename Dest>
+typename std::enable_if<std::is_floating_point<Dest>::value>::type
+parseValue(Dest& dest, const std::string& src)
+{
+    dest = Dest(parseTo<double>(src));
+}
 
 template<typename Dest>
 void convertFromStr(const void *sbase, void *dbase, size_t count)
diff --git a/src/type.cpp b/src/type.cpp
index 7534fef..00f19f5 100644
--- a/src/type.cpp
+++ b/src/type.cpp
@@ -7,8 +7,6 @@
 #include <cstring>
 #include <epicsAssert.h>
 
-#include <epicsStdlib.h>
-
 #include "dataimpl.h"
 #include "utilpvt.h"
 
diff --git a/src/util.cpp b/src/util.cpp
index 4db2503..3784419 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -15,8 +15,6 @@
 
 #include <ctype.h>
 
-#include <epicsStdlib.h>
-
 #include <pvxs/util.h>
 #include <pvxs/sharedArray.h>
 #include <pvxs/data.h>
@@ -386,18 +384,35 @@ std::ostream& operator<<(std::ostream& strm, const SockAddr& addr)
 } // namespace pvxs
 
 namespace pvxs {namespace impl {
-namespace idetail {
 
 template<>
-unsigned short as_str<unsigned short>::op(const char *s)
-{
-    epicsUInt16 ret;
-    if(int err = epicsParseUInt16(s, &ret, 0, nullptr)) {
-        (void)err;
-        throw std::runtime_error(SB()<<"Unable to parse as uint16 : "<<s);
-    }
+double parseTo<double>(const std::string& s) {
+    size_t idx=0, L=s.size();
+    double ret = std::stod(s, &idx);
+    for(; idx<L && isspace(s[idx]); idx++) {}
+    if(idx<L)
+        throw std::invalid_argument(SB()<<"Extraneous charactors after double: \""<<escape(s)<<"\"");
     return ret;
 }
+
+template<>
+uint64_t parseTo<uint64_t>(const std::string& s) {
+    size_t idx=0, L=s.size();
+    unsigned long long ret = std::stoull(s, &idx, 0);
+    for(; idx<L && isspace(s[idx]); idx++) {}
+    if(idx<L)
+        throw std::invalid_argument(SB()<<"Extraneous charactors after integer: \""<<escape(s)<<"\"");
+    return ret;
+}
+
+template<>
+int64_t parseTo<int64_t>(const std::string& s) {
+    size_t idx=0, L=s.size();
+    long long ret = std::stoll(s, &idx, 0);
+    for(; idx<L && isspace(s[idx]); idx++) {}
+    if(idx<L)
+        throw std::invalid_argument(SB()<<"Extraneous charactors after unsigned: \""<<escape(s)<<"\"");
+    return ret;
 }
 
 void indent(std::ostream& strm, unsigned level) {
diff --git a/src/utilpvt.h b/src/utilpvt.h
index da1740a..2a0d38e 100644
--- a/src/utilpvt.h
+++ b/src/utilpvt.h
@@ -47,24 +47,6 @@ struct SB {
     SB& operator<<(const T& i) { strm<<i; return *this; }
 };
 
-namespace idetail {
-// specific specializations in util.cpp
-template <typename T>
-struct as_str {PVXS_API static T op(const char *s);};
-} // namespace idetail
-
-template <typename T>
-inline T lexical_cast(const char *s)
-{
-    return idetail::as_str<T>::op(s);
-}
-
-template <typename T>
-inline T lexical_cast(const std::string& s)
-{
-    return idetail::as_str<T>::op(s.c_str());
-}
-
 void indent(std::ostream& strm, unsigned level);
 
 namespace idetail {
@@ -100,6 +82,19 @@ constexpr idetail::Range<I> range(I end) { return idetail::Range<I>{I(0), end};
 template<typename I>
 constexpr idetail::Range<I> range(I begin, I end) { return idetail::Range<I>{begin, end}; }
 
+template<typename T>
+T parseTo(const std::string& s); // not implemented
+
+template<>
+PVXS_API
+double parseTo<double>(const std::string& s);
+template<>
+PVXS_API
+uint64_t parseTo<uint64_t>(const std::string& s);
+template<>
+PVXS_API
+int64_t parseTo<int64_t>(const std::string& s);
+
 #ifdef _WIN32
 #  define RWLOCK_TYPE SRWLOCK
 #  define RWLOCK_INIT(PLOCK)    InitializeSRWLock(PLOCK)
diff --git a/tools/call.cpp b/tools/call.cpp
index 0fe905f..bc643f7 100644
--- a/tools/call.cpp
+++ b/tools/call.cpp
@@ -10,7 +10,6 @@
 #include <atomic>
 
 #include <epicsVersion.h>
-#include <epicsStdlib.h>
 #include <epicsGetopt.h>
 #include <epicsThread.h>
 
@@ -27,12 +26,12 @@ namespace {
 void usage(const char* argv0)
 {
     std::cerr<<"Usage: "<<argv0<<" <opts> <pvname> <fld>=<value> ...\n"
-               "\n"
-               "  -h        Show this message.\n"
-               "  -V        Print version and exit.\n"
-               "  -v        Make more noise.\n"
-               "  -d        Shorthand for $PVXS_LOG=\"pvxs.*=DEBUG\".  Make a lot of noise.\n"
-               "  -w <sec>  Operation timeout in seconds.  default 5 sec.\n"
+                                 "\n"
+                                 "  -h        Show this message.\n"
+                                 "  -V        Print version and exit.\n"
+                                 "  -v        Make more noise.\n"
+                                 "  -d        Shorthand for $PVXS_LOG=\"pvxs.*=DEBUG\".  Make a lot of noise.\n"
+                                 "  -w <sec>  Operation timeout in seconds.  default 5 sec.\n"
                ;
 }
 
@@ -40,122 +39,124 @@ void usage(const char* argv0)
 
 int main(int argc, char *argv[])
 {
-    logger_config_env(); // from $PVXS_LOG
-    double timeout = 5.0;
-    bool verbose = false;
+    try {
+        logger_config_env(); // from $PVXS_LOG
+        double timeout = 5.0;
+        bool verbose = false;
 
-    {
-        int opt;
-        while ((opt = getopt(argc, argv, "hVvdw:")) != -1) {
-            switch(opt) {
-            case 'h':
-                usage(argv[0]);
-                return 0;
-            case 'V':
-                std::cout<<version_str()<<"\n";
-                std::cout<<EPICS_VERSION_STRING<<"\n";
-                std::cout<<"libevent "<<event_get_version()<<"\n";
-                return 0;
-            case 'v':
-                verbose = true;
-                break;
-            case 'd':
-                logger_level_set("pvxs.*", Level::Debug);
-                break;
-            case 'w':
-                if(epicsParseDouble(optarg, &timeout, nullptr)) {
-                    std::cerr<<"Invalid timeout value: "<<optarg<<"\n";
+        {
+            int opt;
+            while ((opt = getopt(argc, argv, "hVvdw:")) != -1) {
+                switch(opt) {
+                case 'h':
+                    usage(argv[0]);
+                    return 0;
+                case 'V':
+                    std::cout<<version_str()<<"\n";
+                    std::cout<<EPICS_VERSION_STRING<<"\n";
+                    std::cout<<"libevent "<<event_get_version()<<"\n";
+                    return 0;
+                case 'v':
+                    verbose = true;
+                    break;
+                case 'd':
+                    logger_level_set("pvxs.*", Level::Debug);
+                    break;
+                case 'w':
+                    timeout = parseTo<double>(optarg);
+                    break;
+                default:
+                    usage(argv[0]);
+                    std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
                     return 1;
                 }
-                break;
-            default:
-                usage(argv[0]);
-                std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
-                return 1;
             }
         }
-    }
 
-    if(optind==argc) {
-        usage(argv[0]);
-        std::cerr<<"\nExpected PV name\n";
-        return 1;
-    }
-
-    std::string pvname(argv[optind++]);
-    std::list<std::string> keys;
-    std::map<std::string, std::string> values;
-
-    for(auto n : range(optind, argc)) {
-        std::string fv(argv[n]);
-        auto sep = fv.find_first_of('=');
-
-        if(sep==std::string::npos) {
-            std::cerr<<"Error: expected <fld>=<value> not \""<<escape(fv)<<"\"\n";
+        if(optind==argc) {
+            usage(argv[0]);
+            std::cerr<<"\nExpected PV name\n";
             return 1;
         }
 
-        auto key(fv.substr(0, sep));
+        std::string pvname(argv[optind++]);
+        std::list<std::string> keys;
+        std::map<std::string, std::string> values;
 
-        if(values.find(key)!=values.end()) {
-            std::cerr<<"Error: duplicate argument name "<<key<<"\n";
-            return 1;
+        for(auto n : range(optind, argc)) {
+            std::string fv(argv[n]);
+            auto sep = fv.find_first_of('=');
+
+            if(sep==std::string::npos) {
+                std::cerr<<"Error: expected <fld>=<value> not \""<<escape(fv)<<"\"\n";
+                return 1;
+            }
+
+            auto key(fv.substr(0, sep));
+
+            if(values.find(key)!=values.end()) {
+                std::cerr<<"Error: duplicate argument name "<<key<<"\n";
+                return 1;
+            }
+
+            values[key] = fv.substr(sep+1);
+            keys.push_back(key);
         }
 
-        values[key] = fv.substr(sep+1);
-        keys.push_back(key);
-    }
+        auto uri = nt::NTURI({}).build();
 
-    auto uri = nt::NTURI({}).build();
+        for(auto& key : keys) {
+            using namespace pvxs::members;
 
-    for(auto& key : keys) {
-        using namespace pvxs::members;
+            uri += {Struct("query", {String(key)})};
+        }
 
-        uri += {Struct("query", {String(key)})};
-    }
+        auto arg = uri.create();
+        arg["path"] = pvname;
+        auto query = arg["query"];
 
-    auto arg = uri.create();
-    arg["path"] = pvname;
-    auto query = arg["query"];
+        for(auto& pair : values) {
+            query[pair.first] = pair.second;
+        }
 
-    for(auto& pair : values) {
-        query[pair.first] = pair.second;
-    }
+        auto ctxt = client::Config::from_env().build();
 
-    auto ctxt = client::Config::from_env().build();
+        if(verbose)
+            std::cout<<"Effective config\n"<<ctxt.config();
 
-    if(verbose)
-        std::cout<<"Effective config\n"<<ctxt.config();
+        epicsEvent done;
+        int ret=2;
 
-    epicsEvent done;
-    int ret=2;
+        auto op =ctxt.rpc(pvname, std::move(arg))
+                     .result([&ret, &done](client::Result&& result) {
+            try {
+                auto val = result();
+                if(val)
+                    std::cout<<val;
+                ret=0;
+            }catch(std::exception& e){
+                std::cerr<<"Error "<<typeid(e).name()<<" : "<<e.what()<<"\n";
+                ret=1;
+            }
+            done.trigger();
+        })
+                .exec();
 
-    auto op =ctxt.rpc(pvname, std::move(arg))
-            .result([&ret, &done](client::Result&& result) {
-                try {
-                    auto val = result();
-                    if(val)
-                        std::cout<<val;
-                    ret=0;
-                }catch(std::exception& e){
-                    std::cerr<<"Error "<<typeid(e).name()<<" : "<<e.what()<<"\n";
-                    ret=1;
-                }
-                done.trigger();
-            })
-            .exec();
+        // expedite search after starting all requests
+        ctxt.hurryUp();
 
-    // expedite search after starting all requests
-    ctxt.hurryUp();
+        SigInt sig([&done]() {
+            done.signal();
+        });
 
-    SigInt sig([&done]() {
-        done.signal();
-    });
-
-    if(!done.wait(timeout)) {
-        std::cerr<<"Timeout\n";
+        if(!done.wait(timeout)) {
+            std::cerr<<"Timeout\n";
+            return 1;
+        } else {
+            return ret;
+        }
+    }catch(std::exception& e){
+        std::cerr<<"Error: "<<e.what()<<"\n";
         return 1;
-    } else {
-        return ret;
     }
 }
diff --git a/tools/get.cpp b/tools/get.cpp
index 60f0566..d22ac6f 100644
--- a/tools/get.cpp
+++ b/tools/get.cpp
@@ -11,7 +11,6 @@
 #include <cstring>
 
 #include <epicsVersion.h>
-#include <epicsStdlib.h>
 #include <epicsGetopt.h>
 #include <epicsThread.h>
 
@@ -45,104 +44,103 @@ void usage(const char* argv0)
 
 int main(int argc, char *argv[])
 {
-    logger_config_env(); // from $PVXS_LOG
-    double timeout = 5.0;
-    bool verbose = false;
-    std::string request;
-    Value::Fmt::format_t format = Value::Fmt::Delta;
-    auto arrLimit = epicsUInt64(-1);
+    try {
+        logger_config_env(); // from $PVXS_LOG
+        double timeout = 5.0;
+        bool verbose = false;
+        std::string request;
+        Value::Fmt::format_t format = Value::Fmt::Delta;
+        auto arrLimit = uint64_t(-1);
 
-    {
-        int opt;
-        while ((opt = getopt(argc, argv, "hVvdw:r:#:F:")) != -1) {
-            switch(opt) {
-            case 'h':
-                usage(argv[0]);
-                return 0;
-            case 'V':
-                std::cout<<version_str()<<"\n";
-                std::cout<<EPICS_VERSION_STRING<<"\n";
-                std::cout<<"libevent "<<event_get_version()<<"\n";
-                return 0;
-            case 'v':
-                verbose = true;
-                break;
-            case 'd':
-                logger_level_set("pvxs.*", Level::Debug);
-                break;
-            case 'w':
-                if(epicsParseDouble(optarg, &timeout, nullptr)) {
-                    std::cerr<<"Invalid timeout value: "<<optarg<<"\n";
+        {
+            int opt;
+            while ((opt = getopt(argc, argv, "hVvdw:r:#:F:")) != -1) {
+                switch(opt) {
+                case 'h':
+                    usage(argv[0]);
+                    return 0;
+                case 'V':
+                    std::cout<<version_str()<<"\n";
+                    std::cout<<EPICS_VERSION_STRING<<"\n";
+                    std::cout<<"libevent "<<event_get_version()<<"\n";
+                    return 0;
+                case 'v':
+                    verbose = true;
+                    break;
+                case 'd':
+                    logger_level_set("pvxs.*", Level::Debug);
+                    break;
+                case 'w':
+                    timeout = parseTo<double>(optarg);
+                    break;
+                case 'r':
+                    request = optarg;
+                    break;
+                case '#':
+                    arrLimit = parseTo<uint64_t>(optarg);
+                    break;
+                case 'F':
+                    if(std::strcmp(optarg, "tree")==0) {
+                        format = Value::Fmt::Tree;
+                    } else if(std::strcmp(optarg, "delta")==0) {
+                        format = Value::Fmt::Delta;
+                    } else {
+                        std::cerr<<"Warning: ignoring unknown format '"<<optarg<<"'\n";
+                    }
+                    break;
+                default:
+                    usage(argv[0]);
+                    std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
                     return 1;
                 }
-                break;
-            case 'r':
-                request = optarg;
-                break;
-            case '#':
-                if(epicsParseUInt64(optarg, &arrLimit, 0, nullptr)) {
-                    std::cerr<<"Invalid array limit: "<<optarg<<"\n";
-                    return 1;
-                }
-                break;
-            case 'F':
-                if(std::strcmp(optarg, "tree")==0) {
-                    format = Value::Fmt::Tree;
-                } else if(std::strcmp(optarg, "delta")==0) {
-                    format = Value::Fmt::Delta;
-                } else {
-                    std::cerr<<"Warning: ignoring unknown format '"<<optarg<<"'\n";
-                }
-                break;
-            default:
-                usage(argv[0]);
-                std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
-                return 1;
             }
         }
-    }
 
-    auto ctxt = client::Config::from_env().build();
+        auto ctxt = client::Config::from_env().build();
 
-    if(verbose)
-        std::cout<<"Effective config\n"<<ctxt.config();
-
-    std::list<std::shared_ptr<client::Operation>> ops;
-
-    std::atomic<int> remaining{argc-optind};
-    epicsEvent done;
-
-    for(auto n : range(optind, argc)) {
-
-        ops.push_back(ctxt.get(argv[n])
-                      .pvRequest(request)
-                      .result([&argv, n, &remaining, &done, format, arrLimit](client::Result&& result) {
-                          std::cout<<argv[n]<<"\n"<<result()
-                                     .format()
-                                     .format(format)
-                                     .arrayLimit(arrLimit);
-
-                          if(remaining.fetch_sub(1)==1)
-                              done.trigger();
-                      })
-                      .exec());
-    }
-
-    // expedite search after starting all requests
-    ctxt.hurryUp();
-
-    SigInt sig([&done]() {
-        done.signal();
-    });
-
-    if(!done.wait(timeout)) {
-        std::cerr<<"Timeout\n";
-        return 1;
-    } else if(remaining.load()==0u) {
-        return 0;
-    } else {
         if(verbose)
-            std::cerr<<"Interrupted\n";
-        return 2;
+            std::cout<<"Effective config\n"<<ctxt.config();
+
+        std::list<std::shared_ptr<client::Operation>> ops;
+
+        std::atomic<int> remaining{argc-optind};
+        epicsEvent done;
+
+        for(auto n : range(optind, argc)) {
+
+            ops.push_back(ctxt.get(argv[n])
+                          .pvRequest(request)
+                          .result([&argv, n, &remaining, &done, format, arrLimit](client::Result&& result) {
+                              std::cout<<argv[n]<<"\n"<<result()
+                                         .format()
+                                         .format(format)
+                                         .arrayLimit(arrLimit);
+
+                              if(remaining.fetch_sub(1)==1)
+                                  done.trigger();
+                          })
+                          .exec());
+        }
+
+        // expedite search after starting all requests
+        ctxt.hurryUp();
+
+        SigInt sig([&done]() {
+            done.signal();
+        });
+
+        if(!done.wait(timeout)) {
+            std::cerr<<"Timeout\n";
+            return 1;
+        } else if(remaining.load()==0u) {
+            return 0;
+        } else {
+            if(verbose)
+                std::cerr<<"Interrupted\n";
+            return 2;
+        }
+    }catch(std::exception& e){
+        std::cerr<<"Error: "<<e.what()<<"\n";
+        return 1;
     }
 }
diff --git a/tools/info.cpp b/tools/info.cpp
index 12d6c2e..65cdf21 100644
--- a/tools/info.cpp
+++ b/tools/info.cpp
@@ -9,7 +9,6 @@
 #include <atomic>
 
 #include <epicsVersion.h>
-#include <epicsStdlib.h>
 #include <epicsGetopt.h>
 #include <epicsThread.h>
 
@@ -38,86 +37,88 @@ void usage(const char* argv0)
 
 int main(int argc, char *argv[])
 {
-    logger_config_env(); // from $PVXS_LOG
-    double timeout = 5.0;
-    bool verbose = false;
+    try {
+        logger_config_env(); // from $PVXS_LOG
+        double timeout = 5.0;
+        bool verbose = false;
 
-    {
-        int opt;
-        while ((opt = getopt(argc, argv, "hVvdw:")) != -1) {
-            switch(opt) {
-            case 'h':
-                usage(argv[0]);
-                return 0;
-            case 'V':
-                std::cout<<version_str()<<"\n";
-                std::cout<<EPICS_VERSION_STRING<<"\n";
-                std::cout<<"libevent "<<event_get_version()<<"\n";
-                return 0;
-            case 'v':
-                verbose = true;
-                break;
-            case 'd':
-                logger_level_set("pvxs.*", Level::Debug);
-                break;
-            case 'w':
-                if(epicsParseDouble(optarg, &timeout, nullptr)) {
-                    std::cerr<<"Invalid timeout value: "<<optarg<<"\n";
+        {
+            int opt;
+            while ((opt = getopt(argc, argv, "hVvdw:")) != -1) {
+                switch(opt) {
+                case 'h':
+                    usage(argv[0]);
+                    return 0;
+                case 'V':
+                    std::cout<<version_str()<<"\n";
+                    std::cout<<EPICS_VERSION_STRING<<"\n";
+                    std::cout<<"libevent "<<event_get_version()<<"\n";
+                    return 0;
+                case 'v':
+                    verbose = true;
+                    break;
+                case 'd':
+                    logger_level_set("pvxs.*", Level::Debug);
+                    break;
+                case 'w':
+                    timeout = parseTo<double>(optarg);
+                    break;
+                default:
+                    usage(argv[0]);
+                    std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
                     return 1;
                 }
-                break;
-            default:
-                usage(argv[0]);
-                std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
-                return 1;
             }
         }
-    }
 
-    auto ctxt = client::Config::from_env().build();
+        auto ctxt = client::Config::from_env().build();
 
-    if(verbose)
-        std::cout<<"Effective config\n"<<ctxt.config();
-
-    std::list<std::shared_ptr<client::Operation>> ops;
-
-    std::atomic<int> remaining{argc-optind};
-    epicsEvent done;
-
-    for(auto n : range(optind, argc)) {
-
-        ops.push_back(ctxt.info(argv[n])
-                      .result([&argv, n, &remaining, &done](client::Result&& result) {
-                          std::cout<<argv[n];
-                          try {
-                              std::cout<<" from "<<result.peerName()<<"\n"<<result()
-                                         .format()
-                                         .showValue(false);
-                          }catch(std::exception& e){
-                              std::cout<<" Error: "<<e.what()<<"\n";
-                          }
-
-                          if(remaining.fetch_sub(1)==1)
-                              done.trigger();
-                      })
-                      .exec());
-    }
-
-    // expedite search after starting all requests
-    ctxt.hurryUp();
-
-    SigInt sig([&done]() {
-        done.signal();
-    });
-
-    if(!done.wait(timeout)) {
-        std::cerr<<"Timeout\n";
-        return 1;
-    } else if(remaining.load()==0u) {
-        return 0;
-    } else {
         if(verbose)
-            std::cerr<<"Interrupted\n";
-        return 2;
+            std::cout<<"Effective config\n"<<ctxt.config();
+
+        std::list<std::shared_ptr<client::Operation>> ops;
+
+        std::atomic<int> remaining{argc-optind};
+        epicsEvent done;
+
+        for(auto n : range(optind, argc)) {
+
+            ops.push_back(ctxt.info(argv[n])
+                          .result([&argv, n, &remaining, &done](client::Result&& result) {
+                              std::cout<<argv[n];
+                              try {
+                                  std::cout<<" from "<<result.peerName()<<"\n"<<result()
+                                             .format()
+                                             .showValue(false);
+                              }catch(std::exception& e){
+                                  std::cout<<" Error: "<<e.what()<<"\n";
+                              }
+
+                              if(remaining.fetch_sub(1)==1)
+                                  done.trigger();
+                          })
+                          .exec());
+        }
+
+        // expedite search after starting all requests
+        ctxt.hurryUp();
+
+        SigInt sig([&done]() {
+            done.signal();
+        });
+
+        if(!done.wait(timeout)) {
+            std::cerr<<"Timeout\n";
+            return 1;
+        } else if(remaining.load()==0u) {
+            return 0;
+        } else {
+            if(verbose)
+                std::cerr<<"Interrupted\n";
+            return 2;
+        }
+    }catch(std::exception& e){
+        std::cerr<<"Error: "<<e.what()<<"\n";
+        return 1;
     }
 }
diff --git a/tools/monitor.cpp b/tools/monitor.cpp
index b8c2cf0..bb0329c 100644
--- a/tools/monitor.cpp
+++ b/tools/monitor.cpp
@@ -11,7 +11,6 @@
 #include <cstring>
 
 #include <epicsVersion.h>
-#include <epicsStdlib.h>
 #include <epicsGetopt.h>
 #include <epicsThread.h>
 
@@ -46,118 +45,120 @@ void usage(const char* argv0)
 
 int main(int argc, char *argv[])
 {
-    logger_config_env(); // from $PVXS_LOG
-    bool verbose = false;
-    std::string request;
-    Value::Fmt::format_t format = Value::Fmt::Delta;
-    auto arrLimit = epicsUInt64(-1);
+    try {
+        logger_config_env(); // from $PVXS_LOG
+        bool verbose = false;
+        std::string request;
+        Value::Fmt::format_t format = Value::Fmt::Delta;
+        auto arrLimit = uint64_t(-1);
 
-    {
-        int opt;
-        while ((opt = getopt(argc, argv, "hVvdr:#:F:")) != -1) {
-            switch(opt) {
-            case 'h':
-                usage(argv[0]);
-                return 0;
-            case 'V':
-                std::cout<<version_str()<<"\n";
-                std::cout<<EPICS_VERSION_STRING<<"\n";
-                std::cout<<"libevent "<<event_get_version()<<"\n";
-                return 0;
-            case 'v':
-                verbose = true;
-                logger_level_set("app", Level::Debug);
-                break;
-            case 'd':
-                logger_level_set("pvxs.*", Level::Debug);
-                break;
-            case 'r':
-                request = optarg;
-                break;
-            case '#':
-                if(epicsParseUInt64(optarg, &arrLimit, 0, nullptr)) {
-                    std::cerr<<"Invalid array limit: "<<optarg<<"\n";
+        {
+            int opt;
+            while ((opt = getopt(argc, argv, "hVvdr:#:F:")) != -1) {
+                switch(opt) {
+                case 'h':
+                    usage(argv[0]);
+                    return 0;
+                case 'V':
+                    std::cout<<version_str()<<"\n";
+                    std::cout<<EPICS_VERSION_STRING<<"\n";
+                    std::cout<<"libevent "<<event_get_version()<<"\n";
+                    return 0;
+                case 'v':
+                    verbose = true;
+                    logger_level_set("app", Level::Debug);
+                    break;
+                case 'd':
+                    logger_level_set("pvxs.*", Level::Debug);
+                    break;
+                case 'r':
+                    request = optarg;
+                    break;
+                case '#':
+                    arrLimit = parseTo<uint64_t>(optarg);
+                    break;
+                case 'F':
+                    if(std::strcmp(optarg, "tree")==0) {
+                        format = Value::Fmt::Tree;
+                    } else if(std::strcmp(optarg, "delta")==0) {
+                        format = Value::Fmt::Delta;
+                    } else {
+                        std::cerr<<"Warning: ignoring unknown format '"<<optarg<<"'\n";
+                    }
+                    break;
+                default:
+                    usage(argv[0]);
+                    std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
                     return 1;
                 }
-                break;
-            case 'F':
-                if(std::strcmp(optarg, "tree")==0) {
-                    format = Value::Fmt::Tree;
-                } else if(std::strcmp(optarg, "delta")==0) {
-                    format = Value::Fmt::Delta;
-                } else {
-                    std::cerr<<"Warning: ignoring unknown format '"<<optarg<<"'\n";
-                }
-                break;
-            default:
-                usage(argv[0]);
-                std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
-                return 1;
             }
         }
-    }
 
-    auto ctxt = client::Config::from_env().build();
+        auto ctxt = client::Config::from_env().build();
 
-    if(verbose)
-        std::cout<<"Effective config\n"<<ctxt.config();
-
-    std::list<std::shared_ptr<client::Subscription>> ops;
-
-    std::atomic<int> remaining{argc-optind};
-    epicsEvent done;
-
-    for(auto n : range(optind, argc)) {
-
-        ops.push_back(ctxt.monitor(argv[n])
-                      .pvRequest(request)
-                      .event([&argv, n, verbose, &remaining, &done, format, arrLimit](client::Subscription& mon)
-        {
-
-            try {
-                while(auto update = mon.pop()) {
-                    log_info_printf(app, "%s POP data\n", argv[n]);
-                    std::cout<<argv[n]<<"\n"<<update.format()
-                               .format(format)
-                               .arrayLimit(arrLimit);
-                }
-                log_info_printf(app, "%s POP empty\n", argv[n]);
-
-            }catch(client::Finished& conn) {
-                log_info_printf(app, "%s POP Finished\n", argv[n]);
-                if(verbose)
-                    std::cerr<<argv[n]<<" Finished\n";
-                if(remaining.fetch_sub(1)==1)
-                    done.trigger();
-
-            }catch(client::Connected& conn) {
-                std::cerr<<argv[n]<<" Connected to "<<conn.peerName<<"\n";
-
-            }catch(client::Disconnect& conn) {
-                std::cerr<<argv[n]<<" Disconnected\n";
-
-            }catch(std::exception& err) {
-                std::cerr<<argv[n]<<" Error "<<typeid (err).name()<<" : "<<err.what()<<"\n";
-            }
-
-        }).exec());
-    }
-
-    // expedite search after starting all requests
-    ctxt.hurryUp();
-
-    SigInt sig([&done]() {
-        done.signal();
-    });
-
-    done.wait();
-
-    if(remaining.load()==0u) {
-        return 0;
-
-    } else {
         if(verbose)
-            std::cerr<<"Interrupted\n";
-        return 2;
+            std::cout<<"Effective config\n"<<ctxt.config();
+
+        std::list<std::shared_ptr<client::Subscription>> ops;
+
+        std::atomic<int> remaining{argc-optind};
+        epicsEvent done;
+
+        for(auto n : range(optind, argc)) {
+
+            ops.push_back(ctxt.monitor(argv[n])
+                          .pvRequest(request)
+                          .event([&argv, n, verbose, &remaining, &done, format, arrLimit](client::Subscription& mon)
+            {
+
+                try {
+                    while(auto update = mon.pop()) {
+                        log_info_printf(app, "%s POP data\n", argv[n]);
+                        std::cout<<argv[n]<<"\n"<<update.format()
+                                   .format(format)
+                                   .arrayLimit(arrLimit);
+                    }
+                    log_info_printf(app, "%s POP empty\n", argv[n]);
+
+                }catch(client::Finished& conn) {
+                    log_info_printf(app, "%s POP Finished\n", argv[n]);
+                    if(verbose)
+                        std::cerr<<argv[n]<<" Finished\n";
+                    if(remaining.fetch_sub(1)==1)
+                        done.trigger();
+
+                }catch(client::Connected& conn) {
+                    std::cerr<<argv[n]<<" Connected to "<<conn.peerName<<"\n";
+
+                }catch(client::Disconnect& conn) {
+                    std::cerr<<argv[n]<<" Disconnected\n";
+
+                }catch(std::exception& err) {
+                    std::cerr<<argv[n]<<" Error "<<typeid (err).name()<<" : "<<err.what()<<"\n";
+                }
+
+            }).exec());
+        }
+
+        // expedite search after starting all requests
+        ctxt.hurryUp();
+
+        SigInt sig([&done]() {
+            done.signal();
+        });
+
+        done.wait();
+
+        if(remaining.load()==0u) {
+            return 0;
+
+        } else {
+            if(verbose)
+                std::cerr<<"Interrupted\n";
+            return 2;
+        }
+    }catch(std::exception& e){
+        std::cerr<<"Error: "<<e.what()<<"\n";
+        return 1;
     }
 }
diff --git a/tools/put.cpp b/tools/put.cpp
index 552b5f2..4bded31 100644
--- a/tools/put.cpp
+++ b/tools/put.cpp
@@ -9,7 +9,6 @@
 #include <atomic>
 
 #include <epicsVersion.h>
-#include <epicsStdlib.h>
 #include <epicsGetopt.h>
 #include <epicsThread.h>
 
@@ -39,119 +38,121 @@ void usage(const char* argv0)
 
 int main(int argc, char *argv[])
 {
-    logger_config_env(); // from $PVXS_LOG
-    double timeout = 5.0;
-    bool verbose = false;
-    std::string request;
+    try {
+        logger_config_env(); // from $PVXS_LOG
+        double timeout = 5.0;
+        bool verbose = false;
+        std::string request;
 
-    {
-        int opt;
-        while ((opt = getopt(argc, argv, "hvVdw:r:")) != -1) {
-            switch(opt) {
-            case 'h':
-                usage(argv[0]);
-                return 0;
-            case 'V':
-                std::cout<<version_str()<<"\n";
-                std::cout<<EPICS_VERSION_STRING<<"\n";
-                std::cout<<"libevent "<<event_get_version()<<"\n";
-                return 0;
-            case 'v':
-                verbose = true;
-                break;
-            case 'd':
-                logger_level_set("pvxs.*", Level::Debug);
-                break;
-            case 'w':
-                if(epicsParseDouble(optarg, &timeout, nullptr)) {
-                    std::cerr<<"Invalid timeout value: "<<optarg<<"\n";
+        {
+            int opt;
+            while ((opt = getopt(argc, argv, "hvVdw:r:")) != -1) {
+                switch(opt) {
+                case 'h':
+                    usage(argv[0]);
+                    return 0;
+                case 'V':
+                    std::cout<<version_str()<<"\n";
+                    std::cout<<EPICS_VERSION_STRING<<"\n";
+                    std::cout<<"libevent "<<event_get_version()<<"\n";
+                    return 0;
+                case 'v':
+                    verbose = true;
+                    break;
+                case 'd':
+                    logger_level_set("pvxs.*", Level::Debug);
+                    break;
+                case 'w':
+                    timeout = parseTo<double>(optarg);
+                    break;
+                case 'r':
+                    request = optarg;
+                    break;
+                default:
+                    usage(argv[0]);
+                    std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
                     return 1;
                 }
-                break;
-            case 'r':
-                request = optarg;
-                break;
-            default:
-                usage(argv[0]);
-                std::cerr<<"\nUnknown argument: "<<char(opt)<<std::endl;
-                return 1;
             }
         }
-    }
 
-    if(optind==argc) {
-        usage(argv[0]);
-        std::cerr<<"\nExpected PV name\n";
-        return 1;
-    }
-
-    std::string pvname(argv[optind++]);
-    std::map<std::string, std::string> values;
-
-    if(argc-optind==1 && std::string(argv[optind]).find_first_of('=')==std::string::npos) {
-        // only one field assignment, and field name omitted.
-        // implies .value
-
-        values["value"] = argv[optind];
-
-    } else {
-        for(auto n : range(optind, argc)) {
-            std::string fv(argv[n]);
-            auto sep = fv.find_first_of('=');
-
-            if(sep==std::string::npos) {
-                std::cerr<<"Error: expected <fld>=<value> not \""<<escape(fv)<<"\"\n";
-                return 1;
-            }
-
-            values[fv.substr(0, sep)] = fv.substr(sep+1);
+        if(optind==argc) {
+            usage(argv[0]);
+            std::cerr<<"\nExpected PV name\n";
+            return 1;
+        }
+
+        std::string pvname(argv[optind++]);
+        std::map<std::string, std::string> values;
+
+        if(argc-optind==1 && std::string(argv[optind]).find_first_of('=')==std::string::npos) {
+            // only one field assignment, and field name omitted.
+            // implies .value
+
+            values["value"] = argv[optind];
+
+        } else {
+            for(auto n : range(optind, argc)) {
+                std::string fv(argv[n]);
+                auto sep = fv.find_first_of('=');
+
+                if(sep==std::string::npos) {
+                    std::cerr<<"Error: expected <fld>=<value> not \""<<escape(fv)<<"\"\n";
+                    return 1;
+                }
+
+                values[fv.substr(0, sep)] = fv.substr(sep+1);
+            }
         }
-    }
 
 
-    auto ctxt = client::Config::from_env().build();
+        auto ctxt = client::Config::from_env().build();
 
-    if(verbose)
-        std::cout<<"Effective config\n"<<ctxt.config();
+        if(verbose)
+            std::cout<<"Effective config\n"<<ctxt.config();
 
-    epicsEvent done;
-    int ret=0;
+        epicsEvent done;
+        int ret=0;
 
-    auto op =ctxt.put(pvname)
-            .pvRequest(request)
-            .build([&values](Value&& prototype) -> Value {
-                auto val = std::move(prototype);
-                for(auto& pair : values) {
-                    try{
-                        val[pair.first] = pair.second;
-                    }catch(NoConvert& e){
-                        throw std::runtime_error(SB()<<"Unable to assign "<<pair.first<<" from \""<<escape(pair.second)<<"\"");
+        auto op =ctxt.put(pvname)
+                .pvRequest(request)
+                .build([&values](Value&& prototype) -> Value {
+                    auto val = std::move(prototype);
+                    for(auto& pair : values) {
+                        try{
+                            val[pair.first] = pair.second;
+                        }catch(NoConvert& e){
+                            throw std::runtime_error(SB()<<"Unable to assign "<<pair.first<<" from \""<<escape(pair.second)<<"\"");
+                        }
                     }
-                }
-                return val;
-            })
-            .result([&ret, &done](client::Result&& result) {
-                try {
-                    result();
-                }catch(std::exception& e){
-                    std::cerr<<"Error "<<typeid(e).name()<<" : "<<e.what()<<"\n";
-                    ret=1;
-                }
-                done.trigger();
-            })
-            .exec();
+                    return val;
+                })
+                .result([&ret, &done](client::Result&& result) {
+                    try {
+                        result();
+                    }catch(std::exception& e){
+                        std::cerr<<"Error "<<typeid(e).name()<<" : "<<e.what()<<"\n";
+                        ret=1;
+                    }
+                    done.trigger();
+                })
+                .exec();
 
-    // expedite search after starting all requests
-    ctxt.hurryUp();
+        // expedite search after starting all requests
+        ctxt.hurryUp();
 
-    SigInt sig([&done]() {
-        done.signal();
-    });
+        SigInt sig([&done]() {
+            done.signal();
+        });
 
-    if(!done.wait(timeout)) {
-        std::cerr<<"Timeout\n";
+        if(!done.wait(timeout)) {
+            std::cerr<<"Timeout\n";
+            return 1;
+        } else {
+            return ret;
+        }
+    }catch(std::exception& e){
+        std::cerr<<"Error: "<<e.what()<<"\n";
         return 1;
-    } else {
-        return ret;
     }
 }