diff --git a/src/nt_leb128.cpp b/src/nt_leb128.cpp
index d1b8056f93..b2cf67f3a3 100644
--- a/src/nt_leb128.cpp
+++ b/src/nt_leb128.cpp
@@ -42,7 +42,7 @@ size_uleb128(unsigned long val)
  * the number of bytes written.
  */
 std::size_t
-write_uleb128(char *addr, unsigned long val)
+write_uleb128(char* addr, unsigned long val)
 {
     std::size_t count = 0;
 
@@ -72,7 +72,7 @@ write_uleb128(char *addr, unsigned long val)
  * the number of bytes read.
  */
 std::size_t
-read_uleb128(char *addr, unsigned long *ret)
+read_uleb128(char* addr, unsigned long* ret)
 {
     unsigned long result = 0;
     int shift = 0;
@@ -107,7 +107,7 @@ read_uleb128(char *addr, unsigned long *ret)
  * false on stream error, true on success.
  */
 bool
-read_uleb128(raw_istream &is, unsigned long *ret)
+read_uleb128(raw_istream& is, unsigned long* ret)
 {
     unsigned long result = 0;
     int shift = 0;
diff --git a/src/nt_leb128.h b/src/nt_leb128.h
index cf255994fd..a81d81fe0f 100644
--- a/src/nt_leb128.h
+++ b/src/nt_leb128.h
@@ -15,9 +15,9 @@ namespace NtImpl {
 class raw_istream;
 
 std::size_t size_uleb128(unsigned long val);
-std::size_t write_uleb128(char *addr, unsigned long val);
-std::size_t read_uleb128(char *addr, unsigned long *ret);
-bool read_uleb128(raw_istream &is, unsigned long *ret);
+std::size_t write_uleb128(char* addr, unsigned long val);
+std::size_t read_uleb128(char* addr, unsigned long* ret);
+bool read_uleb128(raw_istream& is, unsigned long* ret);
 
 } // namespace NtImpl
 
diff --git a/src/nt_messagereader.cpp b/src/nt_messagereader.cpp
index f6957cef19..38414f1cdf 100644
--- a/src/nt_messagereader.cpp
+++ b/src/nt_messagereader.cpp
@@ -21,7 +21,7 @@ MessageHandler::anchor()
 {
 }
 
-MessageReader::MessageReader(MessageHandler &handler,
+MessageReader::MessageReader(MessageHandler& handler,
                              raw_istream& is,
                              unsigned int proto_rev)
     : WireDecoder(is, proto_rev)
diff --git a/src/nt_messagereader.h b/src/nt_messagereader.h
index 6d87653fdc..f4a03595e1 100644
--- a/src/nt_messagereader.h
+++ b/src/nt_messagereader.h
@@ -25,30 +25,30 @@ public:
     virtual ~MessageHandler() {}
     virtual void GotKeepAlive() = 0;
     virtual void GotClientHello(unsigned int proto_rev,
-                                NT_String &self_id) = 0;
+                                NT_String& self_id) = 0;
     virtual void GotProtoUnsup(unsigned int proto_rev) = 0;
     virtual void GotServerHelloDone() = 0;
     virtual void GotServerHello(unsigned int flags,
-                                NT_String &self_id) = 0;
+                                NT_String& self_id) = 0;
     virtual void GotClientHelloDone() = 0;
-    virtual void GotEntryAssign(NT_String &name,
+    virtual void GotEntryAssign(NT_String& name,
                                 unsigned int id,
                                 unsigned int seq_num,
-                                NT_Value &value,
+                                NT_Value& value,
                                 unsigned int flags) = 0;
     virtual void GotEntryUpdate(unsigned int id,
                                 unsigned int seq_num,
-                                NT_Value &value) = 0;
+                                NT_Value& value) = 0;
     virtual void GotFlagsUpdate(unsigned int id, unsigned int flags) = 0;
     virtual void GotEntryDelete(unsigned int id) = 0;
     virtual void GotClearEntries() = 0;
     virtual void GotExecuteRpc(unsigned int id,
                                unsigned int uid,
-                               const char *params,
+                               const char* params,
                                std::size_t params_len) = 0;
     virtual void GotRpcResponse(unsigned int id,
                                 unsigned int uid,
-                                const char *results,
+                                const char* results,
                                 std::size_t results_len) = 0;
 
 private:
@@ -76,7 +76,7 @@ public:
         WireDecoder::Reset();
     }
 
-    const char *GetError() const
+    const char* GetError() const
     {
         return WireDecoder::GetError();
     }
@@ -85,8 +85,7 @@ private:
     MessageReader(const MessageReader&);
     MessageReader& operator= (const MessageReader&);
 
-    MessageHandler &m_handler;
-    NT_Type m_rpc_types[256];
+    MessageHandler& m_handler;
 };
 
 } // namespace NtImpl
diff --git a/src/nt_messagewriter.cpp b/src/nt_messagewriter.cpp
index 17155dc419..9be90b467f 100644
--- a/src/nt_messagewriter.cpp
+++ b/src/nt_messagewriter.cpp
@@ -22,7 +22,7 @@ MessageWriter::WriteKeepAlive()
 }
 
 void
-MessageWriter::WriteClientHello(const NT_String &self_id)
+MessageWriter::WriteClientHello(const NT_String& self_id)
 {
     Write8(NT_MSG_CLIENT_HELLO);
     Write16(m_proto_rev);
@@ -45,7 +45,7 @@ MessageWriter::WriteServerHelloDone()
 }
 
 void
-MessageWriter::WriteServerHello(unsigned int flags, const NT_String &self_id)
+MessageWriter::WriteServerHello(unsigned int flags, const NT_String& self_id)
 {
     if (m_proto_rev < 0x0300u)
         return; // new message in version 3.0
@@ -63,10 +63,10 @@ MessageWriter::WriteClientHelloDone()
 }
 
 void
-MessageWriter::WriteEntryAssign(const NT_String &name,
+MessageWriter::WriteEntryAssign(const NT_String& name,
                                 unsigned int id,
                                 unsigned int seq_num,
-                                const NT_Value &value,
+                                const NT_Value& value,
                                 unsigned int flags)
 {
     Write8(NT_MSG_ENTRY_ASSIGN);
@@ -82,7 +82,7 @@ MessageWriter::WriteEntryAssign(const NT_String &name,
 void
 MessageWriter::WriteEntryUpdate(unsigned int id,
                                 unsigned int seq_num,
-                                const NT_Value &value)
+                                const NT_Value& value)
 {
     Write8(NT_MSG_ENTRY_UPDATE);
     Write16(id);
@@ -124,8 +124,8 @@ MessageWriter::WriteClearEntries()
 void
 MessageWriter::WriteExecuteRpc(unsigned int id,
                                unsigned int uid,
-                               const NT_Value *params_start,
-                               const NT_Value *params_end)
+                               const NT_Value* params_start,
+                               const NT_Value* params_end)
 {
     WriteRpc(NT_MSG_EXECUTE_RPC, id, uid, params_start, params_end);
 }
@@ -133,8 +133,8 @@ MessageWriter::WriteExecuteRpc(unsigned int id,
 void
 MessageWriter::WriteRpcResponse(unsigned int id,
                                 unsigned int uid,
-                                const NT_Value *results_start,
-                                const NT_Value *results_end)
+                                const NT_Value* results_start,
+                                const NT_Value* results_end)
 {
     WriteRpc(NT_MSG_RPC_RESPONSE, id, uid, results_start, results_end);
 }
@@ -143,8 +143,8 @@ void
 MessageWriter::WriteRpc(unsigned int msg_type,
                         unsigned int id,
                         unsigned int uid,
-                        const NT_Value *values_start,
-                        const NT_Value *values_end)
+                        const NT_Value* values_start,
+                        const NT_Value* values_end)
 {
     if (m_proto_rev < 0x0300u)
         return; // new message in version 3.0
@@ -154,10 +154,10 @@ MessageWriter::WriteRpc(unsigned int msg_type,
     Write16(uid);
 
     unsigned long len = 0;
-    for (const NT_Value *value = values_start; value != values_end; ++value)
+    for (const NT_Value* value = values_start; value != values_end; ++value)
         len += GetValueSize(*value);
     WriteULEB128(len);
 
-    for (const NT_Value *value = values_start; value != values_end; ++value)
+    for (const NT_Value* value = values_start; value != values_end; ++value)
         WriteValue(*value);
 }
diff --git a/src/nt_messagewriter.h b/src/nt_messagewriter.h
index 79a9bec7d4..abf9ee445f 100644
--- a/src/nt_messagewriter.h
+++ b/src/nt_messagewriter.h
@@ -28,12 +28,12 @@ public:
         WireEncoder::Reset();
     }
 
-    const char *GetError() const
+    const char* GetError() const
     {
         return WireEncoder::GetError();
     }
 
-    const char *GetData() const
+    const char* GetData() const
     {
         return WireEncoder::GetData();
     }
@@ -44,30 +44,30 @@ public:
     }
 
     void WriteKeepAlive();
-    void WriteClientHello(const NT_String &self_id);
+    void WriteClientHello(const NT_String& self_id);
     void WriteProtoUnsup();
     void WriteServerHelloDone();
-    void WriteServerHello(unsigned int flags, const NT_String &self_id);
+    void WriteServerHello(unsigned int flags, const NT_String& self_id);
     void WriteClientHelloDone();
-    void WriteEntryAssign(const NT_String &name,
+    void WriteEntryAssign(const NT_String& name,
                           unsigned int id,
                           unsigned int seq_num,
-                          const NT_Value &value,
+                          const NT_Value& value,
                           unsigned int flags);
     void WriteEntryUpdate(unsigned int id,
                           unsigned int seq_num,
-                          const NT_Value &value);
+                          const NT_Value& value);
     void WriteFlagsUpdate(unsigned int id, unsigned int flags);
     void WriteEntryDelete(unsigned int id);
     void WriteClearEntries();
     void WriteExecuteRpc(unsigned int id,
                          unsigned int uid,
-                         const NT_Value *params_start,
-                         const NT_Value *params_end);
+                         const NT_Value* params_start,
+                         const NT_Value* params_end);
     void WriteRpcResponse(unsigned int id,
                           unsigned int uid,
-                          const NT_Value *results_start,
-                          const NT_Value *results_end);
+                          const NT_Value* results_start,
+                          const NT_Value* results_end);
 
 private:
     MessageWriter(const MessageWriter&);
@@ -76,8 +76,8 @@ private:
     void WriteRpc(unsigned int msg_type,
                   unsigned int id,
                   unsigned int uid,
-                  const NT_Value *values_start,
-                  const NT_Value *values_end);
+                  const NT_Value* values_start,
+                  const NT_Value* values_end);
 };
 
 } // namespace NtImpl
diff --git a/src/nt_persistent.cpp b/src/nt_persistent.cpp
index 18b3d2e94c..46015e5cdc 100644
--- a/src/nt_persistent.cpp
+++ b/src/nt_persistent.cpp
@@ -16,7 +16,7 @@
 using namespace NtImpl;
 
 static void
-write_string(FILE *f, llvm::StringRef str)
+write_string(FILE* f, llvm::StringRef str)
 {
     fputc('"', f);
     for (unsigned int i = 0, e = str.size(); i != e; ++i)
@@ -45,26 +45,26 @@ write_string(FILE *f, llvm::StringRef str)
     fputc('"', f);
 }
 
-const char *
-NT_SavePersistent(const char *filename)
+const char*
+NT_SavePersistent(const char* filename)
 {
-    FILE *f = fopen(filename, "wt");
+    FILE* f = fopen(filename, "wt");
     if (!f)
         return "could not open file";
 
     fputs("[NetworkTables Storage 3.0]\n", f);
 
-    Storage &storage = Storage::GetInstance();
+    Storage& storage = Storage::GetInstance();
     for (Storage::EntriesMap::const_iterator i = storage.entries.begin(),
          end = storage.entries.end(); i != end; ++i)
     {
-        const StorageEntry &entry = i->getValue();
+        const StorageEntry& entry = i->getValue();
         // only write persistent-flagged values
         if ((entry.flags & NT_PERSISTENT) == 0)
             continue;
 
         // type
-        const NT_Value &v = entry.value;
+        const NT_Value& v = entry.value;
         switch (v.type)
         {
         case NT_BOOLEAN:        fputs("boolean ", f); break;
@@ -98,7 +98,7 @@ NT_SavePersistent(const char *filename)
             break;
         case NT_RAW:
         {
-            char *buf = new char[base64encode_len(v.data.v_raw.len)];
+            char* buf = new char[base64encode_len(v.data.v_raw.len)];
             base64encode(buf,
                     reinterpret_cast<const unsigned char*>(v.data.v_raw.str),
                     v.data.v_raw.len);
@@ -142,10 +142,10 @@ NT_SavePersistent(const char *filename)
     return 0;
 }
 
-const char *
-NT_LoadPersistent(const char *filename)
+const char*
+NT_LoadPersistent(const char* filename)
 {
-    FILE *f = fopen(filename, "rt");
+    FILE* f = fopen(filename, "rt");
     if (!f)
         return "could not open file";
 
diff --git a/src/nt_raw_istream.cpp b/src/nt_raw_istream.cpp
index 6ac0839a79..dcb1df4af6 100644
--- a/src/nt_raw_istream.cpp
+++ b/src/nt_raw_istream.cpp
@@ -17,7 +17,7 @@ raw_istream::anchor()
 }
 
 bool
-raw_mem_istream::read(void *data, std::size_t len)
+raw_mem_istream::read(void* data, std::size_t len)
 {
     if (len > m_left)
         return false;
diff --git a/src/nt_raw_istream.h b/src/nt_raw_istream.h
index 58be85db07..0ba4141bef 100644
--- a/src/nt_raw_istream.h
+++ b/src/nt_raw_istream.h
@@ -18,7 +18,7 @@ class raw_istream
 public:
     raw_istream() {}
     virtual ~raw_istream() {}
-    virtual bool read(void *data, std::size_t len) = 0;
+    virtual bool read(void* data, std::size_t len) = 0;
     virtual void close() = 0;
 private:
     raw_istream(const raw_istream&);
@@ -28,14 +28,14 @@ private:
 class raw_mem_istream : public raw_istream
 {
 public:
-    raw_mem_istream(const char *mem, std::size_t len)
+    raw_mem_istream(const char* mem, std::size_t len)
         : m_cur(mem), m_left(len)
     {}
     virtual ~raw_mem_istream() {}
-    virtual bool read(void *data, std::size_t len);
+    virtual bool read(void* data, std::size_t len);
     virtual void close() {}
 private:
-    const char *m_cur;
+    const char* m_cur;
     std::size_t m_left;
 };
 
diff --git a/src/nt_seqnum.cpp b/src/nt_seqnum.cpp
index 098d133079..e156664f89 100644
--- a/src/nt_seqnum.cpp
+++ b/src/nt_seqnum.cpp
@@ -9,7 +9,7 @@
 
 namespace NtImpl {
 
-bool operator< (const SequenceNumber &lhs, const SequenceNumber &rhs)
+bool operator< (const SequenceNumber& lhs, const SequenceNumber& rhs)
 {
     if (lhs.m_val < rhs.m_val)
         return (rhs.m_val - lhs.m_val) < (1u<<15);
@@ -19,7 +19,7 @@ bool operator< (const SequenceNumber &lhs, const SequenceNumber &rhs)
         return false;
 }
 
-bool operator> (const SequenceNumber &lhs, const SequenceNumber &rhs)
+bool operator> (const SequenceNumber& lhs, const SequenceNumber& rhs)
 {
     if (lhs.m_val < rhs.m_val)
         return (rhs.m_val - lhs.m_val) > (1u<<15);
diff --git a/src/nt_seqnum.h b/src/nt_seqnum.h
index 3e2357be03..917dc0e126 100644
--- a/src/nt_seqnum.h
+++ b/src/nt_seqnum.h
@@ -30,41 +30,41 @@ public:
         return tmp;
     }
 
-    friend bool operator< (const SequenceNumber &lhs,
-                           const SequenceNumber &rhs);
-    friend bool operator> (const SequenceNumber &lhs,
-                           const SequenceNumber &rhs);
-    friend bool operator<= (const SequenceNumber &lhs,
-                            const SequenceNumber &rhs);
-    friend bool operator>= (const SequenceNumber &lhs,
-                            const SequenceNumber &rhs);
-    friend bool operator== (const SequenceNumber &lhs,
-                            const SequenceNumber &rhs);
-    friend bool operator!= (const SequenceNumber &lhs,
-                            const SequenceNumber &rhs);
+    friend bool operator< (const SequenceNumber& lhs,
+                           const SequenceNumber& rhs);
+    friend bool operator> (const SequenceNumber& lhs,
+                           const SequenceNumber& rhs);
+    friend bool operator<= (const SequenceNumber& lhs,
+                            const SequenceNumber& rhs);
+    friend bool operator>= (const SequenceNumber& lhs,
+                            const SequenceNumber& rhs);
+    friend bool operator== (const SequenceNumber& lhs,
+                            const SequenceNumber& rhs);
+    friend bool operator!= (const SequenceNumber& lhs,
+                            const SequenceNumber& rhs);
 private:
     unsigned int m_val;
 };
 
-bool operator< (const SequenceNumber &lhs, const SequenceNumber &rhs);
-bool operator> (const SequenceNumber &lhs, const SequenceNumber &rhs);
+bool operator< (const SequenceNumber& lhs, const SequenceNumber& rhs);
+bool operator> (const SequenceNumber& lhs, const SequenceNumber& rhs);
 
-inline bool operator<= (const SequenceNumber &lhs, const SequenceNumber &rhs)
+inline bool operator<= (const SequenceNumber& lhs, const SequenceNumber& rhs)
 {
     return lhs == rhs || lhs < rhs;
 }
 
-inline bool operator>= (const SequenceNumber &lhs, const SequenceNumber &rhs)
+inline bool operator>= (const SequenceNumber& lhs, const SequenceNumber& rhs)
 {
     return lhs == rhs || lhs > rhs;
 }
 
-inline bool operator== (const SequenceNumber &lhs, const SequenceNumber &rhs)
+inline bool operator== (const SequenceNumber& lhs, const SequenceNumber& rhs)
 {
     return lhs.m_val == rhs.m_val;
 }
 
-inline bool operator!= (const SequenceNumber &lhs, const SequenceNumber &rhs)
+inline bool operator!= (const SequenceNumber& lhs, const SequenceNumber& rhs)
 {
     return lhs.m_val != rhs.m_val;
 }
diff --git a/src/nt_storage.cpp b/src/nt_storage.cpp
index 418623d008..5d521cd335 100644
--- a/src/nt_storage.cpp
+++ b/src/nt_storage.cpp
@@ -9,7 +9,7 @@
 
 using namespace NtImpl;
 
-Storage *Storage::m_instance = 0;
+Storage* Storage::m_instance = 0;
 
 Storage::Storage()
 {
diff --git a/src/nt_storage.h b/src/nt_storage.h
index 8d64f55c2e..e125edc13f 100644
--- a/src/nt_storage.h
+++ b/src/nt_storage.h
@@ -43,7 +43,7 @@ private:
 class Storage
 {
 public:
-    static Storage &GetInstance()
+    static Storage& GetInstance()
     {
         if (!m_instance)
             m_instance = new Storage;
@@ -59,7 +59,7 @@ private:
     Storage(const Storage&);
     Storage& operator= (const Storage&);
 
-    static Storage *m_instance;
+    static Storage* m_instance;
 };
 
 } // namespace NtImpl
diff --git a/src/nt_value.cpp b/src/nt_value.cpp
index 1539a0be8f..63cbd1115b 100644
--- a/src/nt_value.cpp
+++ b/src/nt_value.cpp
@@ -13,7 +13,7 @@
 #include "ntcore.h"
 
 bool
-operator== (const NT_Value &lhs, const NT_Value &rhs)
+operator== (const NT_Value& lhs, const NT_Value& rhs)
 {
     if (lhs.type != rhs.type)
         return 0;
diff --git a/src/nt_value.h b/src/nt_value.h
index 2cc9ab8eed..899bdbb1b2 100644
--- a/src/nt_value.h
+++ b/src/nt_value.h
@@ -14,6 +14,6 @@ namespace NtImpl {
 
 } // namespace NtImpl
 
-bool operator== (const NT_Value &lhs, const NT_Value &rhs);
+bool operator== (const NT_Value& lhs, const NT_Value& rhs);
 
 #endif /* NT_VALUE_H_ */
diff --git a/src/nt_wiredecoder.cpp b/src/nt_wiredecoder.cpp
index 11c6a7d66c..af357cc120 100644
--- a/src/nt_wiredecoder.cpp
+++ b/src/nt_wiredecoder.cpp
@@ -18,7 +18,7 @@
 using namespace NtImpl;
 
 static double
-read_double(char* &buf)
+read_double(char*& buf)
 {
     std::uint64_t val = (*((unsigned char *)buf)) & 0xff;
     ++buf; val <<= 8; val |= (*((unsigned char *)buf)) & 0xff;
@@ -36,7 +36,7 @@ WireDecoder::WireDecoder(raw_istream& is, unsigned int proto_rev)
     : m_is(is)
 {
     m_allocated = 1024;
-    m_buf = (char *)std::malloc(m_allocated);
+    m_buf = (char*)std::malloc(m_allocated);
     m_proto_rev = proto_rev;
     m_error = 0;
 }
@@ -47,7 +47,7 @@ WireDecoder::~WireDecoder()
 }
 
 bool
-WireDecoder::ReadDouble(double *val)
+WireDecoder::ReadDouble(double* val)
 {
     char *buf;
     if (!Read(&buf, 8)) return false;
@@ -68,7 +68,7 @@ WireDecoder::Realloc(std::size_t len)
 }
 
 bool
-WireDecoder::ReadType(NT_Type *type)
+WireDecoder::ReadType(NT_Type* type)
 {
     unsigned int itype;
     if (!Read8(&itype)) return false;
@@ -90,7 +90,7 @@ WireDecoder::ReadType(NT_Type *type)
 }
 
 bool
-WireDecoder::ReadValue(NT_Type type, NT_Value *value)
+WireDecoder::ReadValue(NT_Type type, NT_Value* value)
 {
     value->type = type;
     value->last_change = 0;
@@ -128,9 +128,9 @@ WireDecoder::ReadValue(NT_Type type, NT_Value *value)
         value->data.arr_boolean.size = size;
 
         // array values
-        char *buf;
+        char* buf;
         if (!Read(&buf, size)) return false;
-        value->data.arr_boolean.arr = (int *)std::malloc(size * sizeof(int));
+        value->data.arr_boolean.arr = (int*)std::malloc(size * sizeof(int));
         for (unsigned int i=0; i<size; ++i)
             value->data.arr_boolean.arr[i] = buf[i] ? 1 : 0;
         break;
@@ -143,10 +143,10 @@ WireDecoder::ReadValue(NT_Type type, NT_Value *value)
         value->data.arr_double.size = size;
 
         // array values
-        char *buf;
+        char* buf;
         if (!Read(&buf, size*8)) return false;
         value->data.arr_double.arr =
-                (double *)std::malloc(size * sizeof(double));
+                (double*)std::malloc(size * sizeof(double));
         for (unsigned int i=0; i<size; ++i)
             value->data.arr_double.arr[i] = read_double(buf);
         break;
@@ -160,7 +160,7 @@ WireDecoder::ReadValue(NT_Type type, NT_Value *value)
 
         // array values
         value->data.arr_string.arr =
-                (NT_String *)std::malloc(size * sizeof(NT_String));
+                (NT_String*)std::malloc(size * sizeof(NT_String));
         for (unsigned int i=0; i<size; ++i)
         {
             if (!ReadString(&value->data.arr_string.arr[i]))
@@ -184,7 +184,7 @@ WireDecoder::ReadValue(NT_Type type, NT_Value *value)
 }
 
 bool
-WireDecoder::ReadString(NT_String *str)
+WireDecoder::ReadString(NT_String* str)
 {
     if (m_proto_rev < 0x0300u)
     {
@@ -198,7 +198,7 @@ WireDecoder::ReadString(NT_String *str)
         if (!ReadULEB128(&v)) return false;
         str->len = v;
     }
-    str->str = (char *)std::malloc(str->len + 1);
+    str->str = (char*)std::malloc(str->len + 1);
     if (!m_is.read(str->str, str->len))
     {
         std::free(str->str);
diff --git a/src/nt_wiredecoder.h b/src/nt_wiredecoder.h
index d5b0012030..20ad12db09 100644
--- a/src/nt_wiredecoder.h
+++ b/src/nt_wiredecoder.h
@@ -32,12 +32,12 @@ public:
         m_error = 0;
     }
 
-    const char *GetError() const
+    const char* GetError() const
     {
         return m_error;
     }
 
-    bool Read(char **buf, std::size_t len)
+    bool Read(char** buf, std::size_t len)
     {
         if (len > m_allocated)
             Realloc(len);
@@ -45,17 +45,17 @@ public:
         return m_is.read(m_buf, len);
     }
 
-    bool Read8(unsigned int *val)
+    bool Read8(unsigned int* val)
     {
-        char *buf;
+        char* buf;
         if (!Read(&buf, 1)) return false;
         *val = (*((unsigned char *)buf)) & 0xff;
         return true;
     }
 
-    bool Read16(unsigned int *val)
+    bool Read16(unsigned int* val)
     {
-        char *buf;
+        char* buf;
         if (!Read(&buf, 2)) return false;
         unsigned int v = (*((unsigned char *)buf)) & 0xff;
         ++buf; v <<= 8; v |= (*((unsigned char *)buf)) & 0xff;
@@ -65,7 +65,7 @@ public:
 
     bool Read32(unsigned long *val)
     {
-        char *buf;
+        char* buf;
         if (!Read(&buf, 4)) return false;
         unsigned int v = (*((unsigned char *)buf)) & 0xff;
         ++buf; v <<= 8; v |= (*((unsigned char *)buf)) & 0xff;
@@ -75,20 +75,20 @@ public:
         return true;
     }
 
-    bool ReadDouble(double *val);
+    bool ReadDouble(double* val);
 
-    bool ReadULEB128(unsigned long *val)
+    bool ReadULEB128(unsigned long* val)
     {
         return read_uleb128(m_is, val);
     }
 
-    bool ReadType(NT_Type *type);
-    bool ReadValue(NT_Type type, NT_Value *value);
-    bool ReadString(NT_String *str);
+    bool ReadType(NT_Type* type);
+    bool ReadValue(NT_Type type, NT_Value* value);
+    bool ReadString(NT_String* str);
 
 protected:
     unsigned int m_proto_rev;
-    const char *m_error;
+    const char* m_error;
 
 private:
     WireDecoder(const WireDecoder&);
@@ -96,9 +96,9 @@ private:
 
     void Realloc(std::size_t len);
 
-    raw_istream &m_is;
+    raw_istream& m_is;
 
-    char *m_buf;
+    char* m_buf;
     std::size_t m_allocated;
 };
 
diff --git a/src/nt_wireencoder.cpp b/src/nt_wireencoder.cpp
index 8b5501f673..0a3b6b1bbc 100644
--- a/src/nt_wireencoder.cpp
+++ b/src/nt_wireencoder.cpp
@@ -103,7 +103,7 @@ WireEncoder::WriteType(NT_Type type)
 }
 
 std::size_t
-WireEncoder::GetValueSize(const NT_Value &value)
+WireEncoder::GetValueSize(const NT_Value& value)
 {
     switch (value.type)
     {
@@ -135,7 +135,7 @@ WireEncoder::GetValueSize(const NT_Value &value)
 }
 
 void
-WireEncoder::WriteValue(const NT_Value &value)
+WireEncoder::WriteValue(const NT_Value& value)
 {
     switch (value.type)
     {
@@ -199,7 +199,7 @@ WireEncoder::WriteValue(const NT_Value &value)
 }
 
 std::size_t
-WireEncoder::GetStringSize(const NT_String &str)
+WireEncoder::GetStringSize(const NT_String& str)
 {
     if (m_proto_rev < 0x0300u)
         return 2 + str.len;
@@ -207,7 +207,7 @@ WireEncoder::GetStringSize(const NT_String &str)
 }
 
 void
-WireEncoder::WriteString(const NT_String &str)
+WireEncoder::WriteString(const NT_String& str)
 {
     // length
     std::size_t len = str.len;
diff --git a/src/nt_wireencoder.h b/src/nt_wireencoder.h
index 4f03e0352b..eb8e764ae1 100644
--- a/src/nt_wireencoder.h
+++ b/src/nt_wireencoder.h
@@ -32,12 +32,12 @@ public:
         m_error = 0;
     }
 
-    const char *GetError() const
+    const char* GetError() const
     {
         return m_error;
     }
 
-    const char *GetData() const
+    const char* GetData() const
     {
         return m_start;
     }
@@ -80,15 +80,15 @@ public:
 
     void WriteULEB128(unsigned long val);
     void WriteType(NT_Type type);
-    void WriteValue(const NT_Value &value);
-    void WriteString(const NT_String &str);
+    void WriteValue(const NT_Value& value);
+    void WriteString(const NT_String& str);
 
-    std::size_t GetValueSize(const NT_Value &value);
-    std::size_t GetStringSize(const NT_String &str);
+    std::size_t GetValueSize(const NT_Value& value);
+    std::size_t GetStringSize(const NT_String& str);
 
 protected:
     unsigned int m_proto_rev;
-    const char *m_error;
+    const char* m_error;
 
 private:
     WireEncoder(const WireEncoder&);
@@ -96,9 +96,9 @@ private:
 
     void ReserveSlow(std::size_t len);
 
-    char *m_start;
-    char *m_cur;
-    char *m_end;
+    char* m_start;
+    char* m_cur;
+    char* m_end;
 };
 
 } // namespace NtImpl