16 files changed, 2699 insertions, 579 deletions
diff --git a/docs/doxygen/CMakeLists.txt b/docs/doxygen/CMakeLists.txt
index 8c8bd4b248..952579f589 100644
--- a/docs/doxygen/CMakeLists.txt
+++ b/docs/doxygen/CMakeLists.txt
@@ -41,10 +41,6 @@ configure_file(
 
 set(BUILT_DIRS ${CMAKE_CURRENT_BINARY_DIR}/xml ${CMAKE_CURRENT_BINARY_DIR}/html)
 
-if(ENABLE_GNURADIO_RUNTIME)
-  list(APPEND GENERATED_DEPS pmt_generated)
-endif(ENABLE_GNURADIO_RUNTIME)
-
 ########################################################################
 # Make and install doxygen docs
 ########################################################################
diff --git a/gnuradio-runtime/include/pmt/CMakeLists.txt b/gnuradio-runtime/include/pmt/CMakeLists.txt
index f4a541e0dd..2b33ea0105 100644
--- a/gnuradio-runtime/include/pmt/CMakeLists.txt
+++ b/gnuradio-runtime/include/pmt/CMakeLists.txt
@@ -25,5 +25,6 @@ install(FILES
   pmt.h
   pmt_pool.h
   pmt_sugar.h
+  pmt_serial_tags.h
   DESTINATION ${GR_INCLUDE_DIR}/pmt
 )
diff --git a/gnuradio-runtime/lib/pmt/gen-serial-tags.py b/gnuradio-runtime/include/pmt/pmt_serial_tags.h
index 2ff2240a47..ea89693a49 100644
--- a/gnuradio-runtime/lib/pmt/gen-serial-tags.py
+++ b/gnuradio-runtime/include/pmt/pmt_serial_tags.h
@@ -1,4 +1,4 @@
-"""
+
 //
 // Copyright 2011 Free Software Foundation, Inc.
 //
@@ -19,38 +19,44 @@
 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 //
-// THIS FILE IS MACHINE GENERATED FROM %s. DO NOT EDIT BY HAND.
-// See %s for additional commentary.
+// THIS FILE IS MACHINE GENERATED FROM gen-serial-tags.py. DO NOT EDIT BY HAND.
+// See pmt-serial-tags.scm for additional commentary.
 //
 
 #ifndef INCLUDED_PMT_SERIAL_TAGS_H
 #define INCLUDED_PMT_SERIAL_TAGS_H
 
 enum pst_tags {
-%s
+    PST_TRUE = 0x00,
+    PST_FALSE = 0x01,
+    PST_SYMBOL = 0x02,
+    PST_INT32 = 0x03,
+    PST_DOUBLE = 0x04,
+    PST_COMPLEX = 0x05,
+    PST_NULL = 0x06,
+    PST_PAIR = 0x07,
+    PST_VECTOR = 0x08,
+    PST_DICT = 0x09,
+    PST_UNIFORM_VECTOR = 0x0a,
+    PST_UINT64 = 0x0b,
+    PST_TUPLE = 0x0c,
+    UVI_ENDIAN_MASK = 0x80,
+    UVI_SUBTYPE_MASK = 0x7f,
+    UVI_LITTLE_ENDIAN = 0x00,
+    UVI_BIG_ENDIAN = 0x80,
+    UVI_U8 = 0x00,
+    UVI_S8 = 0x01,
+    UVI_U16 = 0x02,
+    UVI_S16 = 0x03,
+    UVI_U32 = 0x04,
+    UVI_S32 = 0x05,
+    UVI_U64 = 0x06,
+    UVI_S64 = 0x07,
+    UVI_F32 = 0x08,
+    UVI_F64 = 0x09,
+    UVI_C32 = 0x0a,
+    UVI_C64 = 0x0b,
+    PST_COMMENT = 0x3b,
+    PST_COMMENT_END = 0x0a
 };
 #endif /* INCLUDED_PMT_SERIAL_TAGS_H */
-"""
-
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import sys, os, re
-
-if __name__ == '__main__':
-    if len(sys.argv) != 3:
-        print("Usage %s <input_scm_file> <output_hdr_file>"%__file__)
-        exit()
-    input_scm_file, output_hdr_file = sys.argv[1:]
-    enums = list()
-    for line in open(input_scm_file).readlines():
-        match = re.match('^\s*\(define\s+([\w|-]+)\s+#x([0-9a-fA-F]+)\)', line)
-        if not match: continue
-        name, value = match.groups()
-        name = name.upper().replace('-', '_')
-        enums.append('    %s = 0x%s'%(name, value))
-    open(output_hdr_file, 'w').write(__doc__%(
-        os.path.basename(__file__),
-        os.path.basename(input_scm_file),
-        ',\n'.join(enums),
-    ))
diff --git a/gnuradio-runtime/lib/CMakeLists.txt b/gnuradio-runtime/lib/CMakeLists.txt
index 4fd5a610f6..cd4a850c79 100644
--- a/gnuradio-runtime/lib/CMakeLists.txt
+++ b/gnuradio-runtime/lib/CMakeLists.txt
@@ -198,11 +198,6 @@ add_library(gnuradio-runtime SHARED ${gnuradio_runtime_sources})
 target_link_libraries(gnuradio-runtime ${gnuradio_runtime_libs})
 GR_LIBRARY_FOO(gnuradio-runtime)
 
-add_dependencies(gnuradio-runtime
-  pmt_generated runtime_generated_includes
-)
-
-
 #######################################################
 # STATIC LIB BUILD
 #######################################################
diff --git a/gnuradio-runtime/lib/pmt/CMakeLists.txt b/gnuradio-runtime/lib/pmt/CMakeLists.txt
index 85b2a4d6e0..c840b8b930 100644
--- a/gnuradio-runtime/lib/pmt/CMakeLists.txt
+++ b/gnuradio-runtime/lib/pmt/CMakeLists.txt
@@ -23,57 +23,8 @@
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
 
-########################################################################
-# Generate serial tags header file
-########################################################################
-
-get_filename_component(PMT_SERIAL_TAGS_H
-    ${CMAKE_CURRENT_BINARY_DIR}/../../include/pmt/pmt_serial_tags.h ABSOLUTE
-)
-
-add_custom_command(
-    OUTPUT ${PMT_SERIAL_TAGS_H}
-    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/gen-serial-tags.py
-    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/pmt-serial-tags.scm
-    COMMAND ${PYTHON_EXECUTABLE}
-        ${CMAKE_CURRENT_SOURCE_DIR}/gen-serial-tags.py
-        ${CMAKE_CURRENT_SOURCE_DIR}/pmt-serial-tags.scm
-        ${PMT_SERIAL_TAGS_H}
-)
-
-install(
-    FILES ${PMT_SERIAL_TAGS_H}
-    DESTINATION ${GR_INCLUDE_DIR}/pmt
-)
-
-include(AddFileDependencies)
-ADD_FILE_DEPENDENCIES(
-    ${CMAKE_CURRENT_SOURCE_DIR}/pmt_serialize.cc
-    ${PMT_SERIAL_TAGS_H}
-)
-
-########################################################################
-# Generate other pmt stuff
-########################################################################
-add_custom_command(
-    OUTPUT
-        ${CMAKE_CURRENT_BINARY_DIR}/pmt_unv_int.h
-        ${CMAKE_CURRENT_BINARY_DIR}/qa_pmt_unv.h
-        ${CMAKE_CURRENT_BINARY_DIR}/pmt_unv.cc
-        ${CMAKE_CURRENT_BINARY_DIR}/qa_pmt_unv.cc
-    DEPENDS
-        ${CMAKE_CURRENT_SOURCE_DIR}/generate_unv.py
-        ${CMAKE_CURRENT_SOURCE_DIR}/unv_template.h.t
-        ${CMAKE_CURRENT_SOURCE_DIR}/unv_template.cc.t
-        ${CMAKE_CURRENT_SOURCE_DIR}/unv_qa_template.cc.t
-    COMMAND ${PYTHON_EXECUTABLE} -B -c
-    "import os, sys; srcdir='${CMAKE_CURRENT_SOURCE_DIR}'; sys.path.append(srcdir); os.environ['srcdir']=srcdir; from generate_unv import main; main()"
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    VERBATIM
-)
-
 set(pmt_sources
-  ${CMAKE_CURRENT_BINARY_DIR}/pmt_unv.cc
+  ${CMAKE_CURRENT_SOURCE_DIR}/pmt_unv.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/pmt.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/pmt_io.cc
   ${CMAKE_CURRENT_SOURCE_DIR}/pmt_pool.cc
@@ -85,10 +36,6 @@ list(APPEND gnuradio_pmt_libs
     ${LOG4CPP_LIBRARIES}
 )
 
-add_custom_target(pmt_generated
-  DEPENDS ${PMT_SERIAL_TAGS_H} ${CMAKE_CURRENT_BINARY_DIR}/pmt_unv_int.h)
-
-
 #Add Windows DLL resource file if using MSVC
 if(MSVC)
     include(${CMAKE_SOURCE_DIR}/cmake/Modules/GrVersion.cmake)
@@ -109,14 +56,10 @@ target_link_libraries(gnuradio-pmt ${gnuradio_pmt_libs})
 
 GR_LIBRARY_FOO(gnuradio-pmt)
 
-add_dependencies(gnuradio-pmt
-  pmt_generated
-)
-
 if(ENABLE_STATIC_LIBS)
   add_library(gnuradio-pmt_static STATIC ${pmt_sources})
 
-  add_dependencies(gnuradio-pmt_static pmt_generated)
+  add_dependencies(gnuradio-pmt_static)
 
   if(NOT WIN32)
     set_target_properties(gnuradio-pmt_static
@@ -140,7 +83,7 @@ include(GrTest)
 list(APPEND test_gnuradio_pmt_sources
   qa_pmt.cc
   qa_pmt_prims.cc
-  ${CMAKE_CURRENT_BINARY_DIR}/qa_pmt_unv.cc
+  qa_pmt_unv.cc
 )
 
 include_directories(${CPPUNIT_INCLUDE_DIRS})
diff --git a/gnuradio-runtime/lib/pmt/generate_unv.py b/gnuradio-runtime/lib/pmt/generate_unv.py
deleted file mode 100644
index 45c57a3fb8..0000000000
--- a/gnuradio-runtime/lib/pmt/generate_unv.py
+++ /dev/null
@@ -1,192 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2006,2009 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-#
-
-"""
-Generate code for uniform numeric vectors
-"""
-from __future__ import unicode_literals
-
-import re, os, os.path
-
-
-unv_types = (
-    ('u8', 'uint8_t'),
-    ('s8', 'int8_t'),
-    ('u16', 'uint16_t'),
-    ('s16', 'int16_t'),
-    ('u32', 'uint32_t'),
-    ('s32', 'int32_t'),
-    ('u64', 'uint64_t'),
-    ('s64', 'int64_t'),
-    ('f32', 'float'),
-    ('f64', 'double'),
-    ('c32', 'std::complex<float>'),
-    ('c64', 'std::complex<double>')
-    )
-
-header = """\
-/* -*- c++ -*- */
-/*
- * Copyright 2006,2009 Free Software Foundation, Inc.
- *
- * This file is part of GNU Radio
- *
- * GNU Radio is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU Radio is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNU Radio; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-"""
-
-guard_tail = """
-#endif
-"""
-
-includes = """
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <vector>
-#include <pmt/pmt.h>
-#include <boost/lexical_cast.hpp>
-#include "pmt_int.h"
-"""
-
-qa_includes = """
-#include <qa_pmt_unv.h>
-#include <cppunit/TestAssert.h>
-#include <pmt/pmt.h>
-#include <stdio.h>
-
-using namespace pmt;
-"""
-
-
-# set srcdir to the directory that contains Makefile.am
-try:
-    srcdir = os.environ['srcdir']
-except KeyError as e:
-    srcdir = "."
-srcdir = srcdir + '/'
-
-
-def open_src (name, mode):
-    global srcdir
-    return open(os.path.join (srcdir, name), mode)
-
-
-def guard_name(filename):
-    return 'INCLUDED_' + re.sub('\.', '_', filename.upper())
-
-def guard_head(filename):
-    guard = guard_name(filename)
-    return """
-#ifndef %s
-#define %s
-""" % (guard, guard)
-
-
-def do_substitution (d, input, out_file):
-    def repl (match_obj):
-        key = match_obj.group (1)
-        # print key
-        return d[key]
-
-    out = re.sub (r"@([a-zA-Z0-9_]+)@", repl, input)
-    out_file.write (out)
-
-
-def generate_h():
-    template = open_src('unv_template.h.t', 'r').read()
-    output_filename = 'pmt_unv_int.h'
-    output = open(output_filename, 'w')
-    output.write(header)
-    output.write(guard_head(output_filename))
-    for tag, typ in unv_types:
-        d = { 'TAG' : tag, 'TYPE' : typ }
-        do_substitution(d, template, output)
-    output.write(guard_tail)
-
-def generate_cc():
-    template = open_src('unv_template.cc.t', 'r').read()
-    output = open('pmt_unv.cc', 'w')
-    output.write(header)
-    output.write(includes)
-    for tag, typ in unv_types:
-        d = { 'TAG' : tag, 'TYPE' : typ }
-        do_substitution(d, template, output)
-
-
-def generate_qa_h():
-    output_filename = 'qa_pmt_unv.h'
-    output = open(output_filename, 'w')
-    output.write(header)
-    output.write(guard_head(output_filename))
-
-    output.write('''
-#include <cppunit/extensions/HelperMacros.h>
-#include <cppunit/TestCase.h>
-
-class qa_pmt_unv : public CppUnit::TestCase {
-
-  CPPUNIT_TEST_SUITE(qa_pmt_unv);
-''')
-    for tag, typ in unv_types:
-        output.write('  CPPUNIT_TEST(test_%svector);\n' % (tag,))
-    output.write('''\
-  CPPUNIT_TEST_SUITE_END();
-
- private:
-''')
-    for tag, typ in unv_types:
-        output.write('  void test_%svector();\n' % (tag,))
-    output.write('};\n')
-    output.write(guard_tail)
-
-def generate_qa_cc():
-    template = open_src('unv_qa_template.cc.t', 'r').read()
-    output = open('qa_pmt_unv.cc', 'w')
-    output.write(header)
-    output.write(qa_includes)
-    for tag, typ in unv_types:
-        d = { 'TAG' : tag, 'TYPE' : typ }
-        do_substitution(d, template, output)
-
-
-def main():
-    generate_h()
-    generate_cc()
-    generate_qa_h()
-    generate_qa_cc()
-
-if __name__ == '__main__':
-    main()
diff --git a/gnuradio-runtime/lib/pmt/pmt-serial-tags.scm b/gnuradio-runtime/lib/pmt/pmt-serial-tags.scm
deleted file mode 100644
index 4f06bf75f8..0000000000
--- a/gnuradio-runtime/lib/pmt/pmt-serial-tags.scm
+++ /dev/null
@@ -1,77 +0,0 @@
-;;; -*-scheme-*-
-;;;
-;;; Copyright 2007 Free Software Foundation, Inc.
-;;;
-;;; This file is part of GNU Radio
-;;;
-;;; GNU Radio is free software; you can redistribute it and/or modify
-;;; it under the terms of the GNU General Public License as published by
-;;; the Free Software Foundation; either version 3, or (define at your option)
-;;; any later version.
-;;;
-;;; GNU Radio is distributed in the hope that it will be useful,
-;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;;; GNU General Public License for more details.
-;;;
-;;; You should have received a copy of the GNU General Public License along
-;;; with this program; if not, write to the Free Software Foundation, Inc.,
-;;; 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-;;;
-
-;;; definitions of tag values used for marshalling pmt data
-
-(define pst-true		#x00)
-(define pst-false		#x01)
-(define pst-symbol		#x02)   ; untagged-int16 n; followed by n bytes of symbol name
-(define pst-int32		#x03)
-(define pst-double		#x04)
-(define pst-complex		#x05)   ; complex<double>: real, imag
-(define pst-null		#x06)
-(define pst-pair		#x07)   ; followed by two objects
-(define pst-vector		#x08)   ; untagged-int32 n; followed by n objects
-(define pst-dict		#x09)   ; untagged-int32 n; followed by n key/value tuples
-
-(define pst-uniform-vector	#x0a)
-(define pst-uint64	#x0b)
-(define pst-tuple	#x0c)
-
-;; u8, s8, u16, s16, u32, s32, u64, s64, f32, f64, c32, c64
-;;
-;;   untagged-uint8  tag
-;;   untagged-uint8  uvi (define uniform vector info, see below)
-;;   untagged-int32  n-items
-;;   untagged-uint8  npad
-;;   npad bytes of zeros to align binary data
-;;   n-items binary numeric items
-;;
-;; uvi:
-;; +-+-+-+-+-+-+-+-+
-;; |B|   subtype   |
-;; +-+-+-+-+-+-+-+-+
-;;
-;; B == 0, numeric data is little-endian.
-;; B == 1, numeric data is big-endian.
-
-    (define uvi-endian-mask     #x80)
-    (define uvi-subtype-mask    #x7f)
-
-    (define uvi-little-endian   #x00)
-    (define uvi-big-endian      #x80)
-
-    (define uvi-u8		#x00)
-    (define uvi-s8		#x01)
-    (define uvi-u16		#x02)
-    (define uvi-s16		#x03)
-    (define uvi-u32		#x04)
-    (define uvi-s32		#x05)
-    (define uvi-u64		#x06)
-    (define uvi-s64		#x07)
-    (define uvi-f32		#x08)
-    (define uvi-f64		#x09)
-    (define uvi-c32		#x0a)
-    (define uvi-c64		#x0b)
-
-
-(define pst-comment		#x3b)	; ascii ';'
-(define pst-comment-end		#x0a)	; ascii '\n'
diff --git a/gnuradio-runtime/lib/pmt/pmt_int.h b/gnuradio-runtime/lib/pmt/pmt_int.h
index f06f507944..ead058598d 100644
--- a/gnuradio-runtime/lib/pmt/pmt_int.h
+++ b/gnuradio-runtime/lib/pmt/pmt_int.h
@@ -242,9 +242,6 @@ public:
   virtual size_t itemsize() const = 0;
   virtual const std::string string_ref(size_t k) const { return std::string("not implemented"); }
 };
-
-#include "pmt_unv_int.h"
-
 } /* namespace pmt */
 
 #endif /* INCLUDED_PMT_INT_H */
diff --git a/gnuradio-runtime/lib/pmt/pmt_unv.cc b/gnuradio-runtime/lib/pmt/pmt_unv.cc
new file mode 100644
index 0000000000..cda0c085cd
--- /dev/null
+++ b/gnuradio-runtime/lib/pmt/pmt_unv.cc
@@ -0,0 +1,1821 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2006,2009,2018 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+// This file is machine generated using the generate_unv.py tool
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "pmt_unv_int.h"
+#include "pmt_int.h"
+#include <pmt/pmt.h>
+#include <boost/lexical_cast.hpp>
+#include <vector>
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u8vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_u8vector *
+_u8vector(pmt_t x)
+{
+  return dynamic_cast<pmt_u8vector*>(x.get());
+}
+
+
+pmt_u8vector::pmt_u8vector(size_t k, uint8_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_u8vector::pmt_u8vector(size_t k, const uint8_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(uint8_t) );
+}
+
+uint8_t
+pmt_u8vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_u8vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_u8vector::set(size_t k, uint8_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_u8vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const uint8_t *
+pmt_u8vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+uint8_t *
+pmt_u8vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_u8vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(uint8_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_u8vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(uint8_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_u8vector(pmt_t obj)
+{
+  return obj->is_u8vector();
+}
+
+pmt_t
+make_u8vector(size_t k, uint8_t fill)
+{
+  return pmt_t(new pmt_u8vector(k, fill));
+}
+
+pmt_t
+init_u8vector(size_t k, const uint8_t *data)
+{
+  return pmt_t(new pmt_u8vector(k, data));
+}
+
+pmt_t
+init_u8vector(size_t k, const std::vector< uint8_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_u8vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_u8vector(k, static_cast< uint8_t >(0))); // fills an empty vector with 0
+}
+
+uint8_t
+u8vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_u8vector())
+    throw wrong_type("pmt_u8vector_ref", vector);
+  return _u8vector(vector)->ref(k);
+}
+
+void
+u8vector_set(pmt_t vector, size_t k, uint8_t obj)
+{
+  if (!vector->is_u8vector())
+    throw wrong_type("pmt_u8vector_set", vector);
+  _u8vector(vector)->set(k, obj);
+}
+
+const uint8_t *
+u8vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u8vector())
+    throw wrong_type("pmt_u8vector_elements", vector);
+  return _u8vector(vector)->elements(len);
+}
+
+const std::vector< uint8_t >
+u8vector_elements(pmt_t vector)
+{
+  if (!vector->is_u8vector())
+    throw wrong_type("pmt_u8vector_elements", vector);
+  size_t len;
+  const uint8_t *array = _u8vector(vector)->elements(len);
+  const std::vector< uint8_t > vec(array, array+len);
+  return vec;
+}
+
+
+uint8_t *
+u8vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u8vector())
+    throw wrong_type("pmt_u8vector_writable_elements", vector);
+  return _u8vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_u8vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, uint8_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s8vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_s8vector *
+_s8vector(pmt_t x)
+{
+  return dynamic_cast<pmt_s8vector*>(x.get());
+}
+
+
+pmt_s8vector::pmt_s8vector(size_t k, int8_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_s8vector::pmt_s8vector(size_t k, const int8_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(int8_t) );
+}
+
+int8_t
+pmt_s8vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_s8vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_s8vector::set(size_t k, int8_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_s8vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const int8_t *
+pmt_s8vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+int8_t *
+pmt_s8vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_s8vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(int8_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_s8vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(int8_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_s8vector(pmt_t obj)
+{
+  return obj->is_s8vector();
+}
+
+pmt_t
+make_s8vector(size_t k, int8_t fill)
+{
+  return pmt_t(new pmt_s8vector(k, fill));
+}
+
+pmt_t
+init_s8vector(size_t k, const int8_t *data)
+{
+  return pmt_t(new pmt_s8vector(k, data));
+}
+
+pmt_t
+init_s8vector(size_t k, const std::vector< int8_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_s8vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_s8vector(k, static_cast< int8_t >(0))); // fills an empty vector with 0
+}
+
+int8_t
+s8vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_s8vector())
+    throw wrong_type("pmt_s8vector_ref", vector);
+  return _s8vector(vector)->ref(k);
+}
+
+void
+s8vector_set(pmt_t vector, size_t k, int8_t obj)
+{
+  if (!vector->is_s8vector())
+    throw wrong_type("pmt_s8vector_set", vector);
+  _s8vector(vector)->set(k, obj);
+}
+
+const int8_t *
+s8vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s8vector())
+    throw wrong_type("pmt_s8vector_elements", vector);
+  return _s8vector(vector)->elements(len);
+}
+
+const std::vector< int8_t >
+s8vector_elements(pmt_t vector)
+{
+  if (!vector->is_s8vector())
+    throw wrong_type("pmt_s8vector_elements", vector);
+  size_t len;
+  const int8_t *array = _s8vector(vector)->elements(len);
+  const std::vector< int8_t > vec(array, array+len);
+  return vec;
+}
+
+
+int8_t *
+s8vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s8vector())
+    throw wrong_type("pmt_s8vector_writable_elements", vector);
+  return _s8vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_s8vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, int8_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u16vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_u16vector *
+_u16vector(pmt_t x)
+{
+  return dynamic_cast<pmt_u16vector*>(x.get());
+}
+
+
+pmt_u16vector::pmt_u16vector(size_t k, uint16_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_u16vector::pmt_u16vector(size_t k, const uint16_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(uint16_t) );
+}
+
+uint16_t
+pmt_u16vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_u16vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_u16vector::set(size_t k, uint16_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_u16vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const uint16_t *
+pmt_u16vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+uint16_t *
+pmt_u16vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_u16vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(uint16_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_u16vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(uint16_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_u16vector(pmt_t obj)
+{
+  return obj->is_u16vector();
+}
+
+pmt_t
+make_u16vector(size_t k, uint16_t fill)
+{
+  return pmt_t(new pmt_u16vector(k, fill));
+}
+
+pmt_t
+init_u16vector(size_t k, const uint16_t *data)
+{
+  return pmt_t(new pmt_u16vector(k, data));
+}
+
+pmt_t
+init_u16vector(size_t k, const std::vector< uint16_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_u16vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_u16vector(k, static_cast< uint16_t >(0))); // fills an empty vector with 0
+}
+
+uint16_t
+u16vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_u16vector())
+    throw wrong_type("pmt_u16vector_ref", vector);
+  return _u16vector(vector)->ref(k);
+}
+
+void
+u16vector_set(pmt_t vector, size_t k, uint16_t obj)
+{
+  if (!vector->is_u16vector())
+    throw wrong_type("pmt_u16vector_set", vector);
+  _u16vector(vector)->set(k, obj);
+}
+
+const uint16_t *
+u16vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u16vector())
+    throw wrong_type("pmt_u16vector_elements", vector);
+  return _u16vector(vector)->elements(len);
+}
+
+const std::vector< uint16_t >
+u16vector_elements(pmt_t vector)
+{
+  if (!vector->is_u16vector())
+    throw wrong_type("pmt_u16vector_elements", vector);
+  size_t len;
+  const uint16_t *array = _u16vector(vector)->elements(len);
+  const std::vector< uint16_t > vec(array, array+len);
+  return vec;
+}
+
+
+uint16_t *
+u16vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u16vector())
+    throw wrong_type("pmt_u16vector_writable_elements", vector);
+  return _u16vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_u16vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, uint16_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s16vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_s16vector *
+_s16vector(pmt_t x)
+{
+  return dynamic_cast<pmt_s16vector*>(x.get());
+}
+
+
+pmt_s16vector::pmt_s16vector(size_t k, int16_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_s16vector::pmt_s16vector(size_t k, const int16_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(int16_t) );
+}
+
+int16_t
+pmt_s16vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_s16vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_s16vector::set(size_t k, int16_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_s16vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const int16_t *
+pmt_s16vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+int16_t *
+pmt_s16vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_s16vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(int16_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_s16vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(int16_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_s16vector(pmt_t obj)
+{
+  return obj->is_s16vector();
+}
+
+pmt_t
+make_s16vector(size_t k, int16_t fill)
+{
+  return pmt_t(new pmt_s16vector(k, fill));
+}
+
+pmt_t
+init_s16vector(size_t k, const int16_t *data)
+{
+  return pmt_t(new pmt_s16vector(k, data));
+}
+
+pmt_t
+init_s16vector(size_t k, const std::vector< int16_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_s16vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_s16vector(k, static_cast< int16_t >(0))); // fills an empty vector with 0
+}
+
+int16_t
+s16vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_s16vector())
+    throw wrong_type("pmt_s16vector_ref", vector);
+  return _s16vector(vector)->ref(k);
+}
+
+void
+s16vector_set(pmt_t vector, size_t k, int16_t obj)
+{
+  if (!vector->is_s16vector())
+    throw wrong_type("pmt_s16vector_set", vector);
+  _s16vector(vector)->set(k, obj);
+}
+
+const int16_t *
+s16vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s16vector())
+    throw wrong_type("pmt_s16vector_elements", vector);
+  return _s16vector(vector)->elements(len);
+}
+
+const std::vector< int16_t >
+s16vector_elements(pmt_t vector)
+{
+  if (!vector->is_s16vector())
+    throw wrong_type("pmt_s16vector_elements", vector);
+  size_t len;
+  const int16_t *array = _s16vector(vector)->elements(len);
+  const std::vector< int16_t > vec(array, array+len);
+  return vec;
+}
+
+
+int16_t *
+s16vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s16vector())
+    throw wrong_type("pmt_s16vector_writable_elements", vector);
+  return _s16vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_s16vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, int16_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u32vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_u32vector *
+_u32vector(pmt_t x)
+{
+  return dynamic_cast<pmt_u32vector*>(x.get());
+}
+
+
+pmt_u32vector::pmt_u32vector(size_t k, uint32_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_u32vector::pmt_u32vector(size_t k, const uint32_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(uint32_t) );
+}
+
+uint32_t
+pmt_u32vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_u32vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_u32vector::set(size_t k, uint32_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_u32vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const uint32_t *
+pmt_u32vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+uint32_t *
+pmt_u32vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_u32vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(uint32_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_u32vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(uint32_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_u32vector(pmt_t obj)
+{
+  return obj->is_u32vector();
+}
+
+pmt_t
+make_u32vector(size_t k, uint32_t fill)
+{
+  return pmt_t(new pmt_u32vector(k, fill));
+}
+
+pmt_t
+init_u32vector(size_t k, const uint32_t *data)
+{
+  return pmt_t(new pmt_u32vector(k, data));
+}
+
+pmt_t
+init_u32vector(size_t k, const std::vector< uint32_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_u32vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_u32vector(k, static_cast< uint32_t >(0))); // fills an empty vector with 0
+}
+
+uint32_t
+u32vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_u32vector())
+    throw wrong_type("pmt_u32vector_ref", vector);
+  return _u32vector(vector)->ref(k);
+}
+
+void
+u32vector_set(pmt_t vector, size_t k, uint32_t obj)
+{
+  if (!vector->is_u32vector())
+    throw wrong_type("pmt_u32vector_set", vector);
+  _u32vector(vector)->set(k, obj);
+}
+
+const uint32_t *
+u32vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u32vector())
+    throw wrong_type("pmt_u32vector_elements", vector);
+  return _u32vector(vector)->elements(len);
+}
+
+const std::vector< uint32_t >
+u32vector_elements(pmt_t vector)
+{
+  if (!vector->is_u32vector())
+    throw wrong_type("pmt_u32vector_elements", vector);
+  size_t len;
+  const uint32_t *array = _u32vector(vector)->elements(len);
+  const std::vector< uint32_t > vec(array, array+len);
+  return vec;
+}
+
+
+uint32_t *
+u32vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u32vector())
+    throw wrong_type("pmt_u32vector_writable_elements", vector);
+  return _u32vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_u32vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, uint32_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s32vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_s32vector *
+_s32vector(pmt_t x)
+{
+  return dynamic_cast<pmt_s32vector*>(x.get());
+}
+
+
+pmt_s32vector::pmt_s32vector(size_t k, int32_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_s32vector::pmt_s32vector(size_t k, const int32_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(int32_t) );
+}
+
+int32_t
+pmt_s32vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_s32vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_s32vector::set(size_t k, int32_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_s32vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const int32_t *
+pmt_s32vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+int32_t *
+pmt_s32vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_s32vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(int32_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_s32vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(int32_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_s32vector(pmt_t obj)
+{
+  return obj->is_s32vector();
+}
+
+pmt_t
+make_s32vector(size_t k, int32_t fill)
+{
+  return pmt_t(new pmt_s32vector(k, fill));
+}
+
+pmt_t
+init_s32vector(size_t k, const int32_t *data)
+{
+  return pmt_t(new pmt_s32vector(k, data));
+}
+
+pmt_t
+init_s32vector(size_t k, const std::vector< int32_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_s32vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_s32vector(k, static_cast< int32_t >(0))); // fills an empty vector with 0
+}
+
+int32_t
+s32vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_s32vector())
+    throw wrong_type("pmt_s32vector_ref", vector);
+  return _s32vector(vector)->ref(k);
+}
+
+void
+s32vector_set(pmt_t vector, size_t k, int32_t obj)
+{
+  if (!vector->is_s32vector())
+    throw wrong_type("pmt_s32vector_set", vector);
+  _s32vector(vector)->set(k, obj);
+}
+
+const int32_t *
+s32vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s32vector())
+    throw wrong_type("pmt_s32vector_elements", vector);
+  return _s32vector(vector)->elements(len);
+}
+
+const std::vector< int32_t >
+s32vector_elements(pmt_t vector)
+{
+  if (!vector->is_s32vector())
+    throw wrong_type("pmt_s32vector_elements", vector);
+  size_t len;
+  const int32_t *array = _s32vector(vector)->elements(len);
+  const std::vector< int32_t > vec(array, array+len);
+  return vec;
+}
+
+
+int32_t *
+s32vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s32vector())
+    throw wrong_type("pmt_s32vector_writable_elements", vector);
+  return _s32vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_s32vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, int32_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u64vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_u64vector *
+_u64vector(pmt_t x)
+{
+  return dynamic_cast<pmt_u64vector*>(x.get());
+}
+
+
+pmt_u64vector::pmt_u64vector(size_t k, uint64_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_u64vector::pmt_u64vector(size_t k, const uint64_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(uint64_t) );
+}
+
+uint64_t
+pmt_u64vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_u64vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_u64vector::set(size_t k, uint64_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_u64vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const uint64_t *
+pmt_u64vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+uint64_t *
+pmt_u64vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_u64vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(uint64_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_u64vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(uint64_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_u64vector(pmt_t obj)
+{
+  return obj->is_u64vector();
+}
+
+pmt_t
+make_u64vector(size_t k, uint64_t fill)
+{
+  return pmt_t(new pmt_u64vector(k, fill));
+}
+
+pmt_t
+init_u64vector(size_t k, const uint64_t *data)
+{
+  return pmt_t(new pmt_u64vector(k, data));
+}
+
+pmt_t
+init_u64vector(size_t k, const std::vector< uint64_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_u64vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_u64vector(k, static_cast< uint64_t >(0))); // fills an empty vector with 0
+}
+
+uint64_t
+u64vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_u64vector())
+    throw wrong_type("pmt_u64vector_ref", vector);
+  return _u64vector(vector)->ref(k);
+}
+
+void
+u64vector_set(pmt_t vector, size_t k, uint64_t obj)
+{
+  if (!vector->is_u64vector())
+    throw wrong_type("pmt_u64vector_set", vector);
+  _u64vector(vector)->set(k, obj);
+}
+
+const uint64_t *
+u64vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u64vector())
+    throw wrong_type("pmt_u64vector_elements", vector);
+  return _u64vector(vector)->elements(len);
+}
+
+const std::vector< uint64_t >
+u64vector_elements(pmt_t vector)
+{
+  if (!vector->is_u64vector())
+    throw wrong_type("pmt_u64vector_elements", vector);
+  size_t len;
+  const uint64_t *array = _u64vector(vector)->elements(len);
+  const std::vector< uint64_t > vec(array, array+len);
+  return vec;
+}
+
+
+uint64_t *
+u64vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_u64vector())
+    throw wrong_type("pmt_u64vector_writable_elements", vector);
+  return _u64vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_u64vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, uint64_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s64vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_s64vector *
+_s64vector(pmt_t x)
+{
+  return dynamic_cast<pmt_s64vector*>(x.get());
+}
+
+
+pmt_s64vector::pmt_s64vector(size_t k, int64_t fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_s64vector::pmt_s64vector(size_t k, const int64_t *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(int64_t) );
+}
+
+int64_t
+pmt_s64vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_s64vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_s64vector::set(size_t k, int64_t x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_s64vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const int64_t *
+pmt_s64vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+int64_t *
+pmt_s64vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_s64vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(int64_t);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_s64vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(int64_t);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_s64vector(pmt_t obj)
+{
+  return obj->is_s64vector();
+}
+
+pmt_t
+make_s64vector(size_t k, int64_t fill)
+{
+  return pmt_t(new pmt_s64vector(k, fill));
+}
+
+pmt_t
+init_s64vector(size_t k, const int64_t *data)
+{
+  return pmt_t(new pmt_s64vector(k, data));
+}
+
+pmt_t
+init_s64vector(size_t k, const std::vector< int64_t > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_s64vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_s64vector(k, static_cast< int64_t >(0))); // fills an empty vector with 0
+}
+
+int64_t
+s64vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_s64vector())
+    throw wrong_type("pmt_s64vector_ref", vector);
+  return _s64vector(vector)->ref(k);
+}
+
+void
+s64vector_set(pmt_t vector, size_t k, int64_t obj)
+{
+  if (!vector->is_s64vector())
+    throw wrong_type("pmt_s64vector_set", vector);
+  _s64vector(vector)->set(k, obj);
+}
+
+const int64_t *
+s64vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s64vector())
+    throw wrong_type("pmt_s64vector_elements", vector);
+  return _s64vector(vector)->elements(len);
+}
+
+const std::vector< int64_t >
+s64vector_elements(pmt_t vector)
+{
+  if (!vector->is_s64vector())
+    throw wrong_type("pmt_s64vector_elements", vector);
+  size_t len;
+  const int64_t *array = _s64vector(vector)->elements(len);
+  const std::vector< int64_t > vec(array, array+len);
+  return vec;
+}
+
+
+int64_t *
+s64vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_s64vector())
+    throw wrong_type("pmt_s64vector_writable_elements", vector);
+  return _s64vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_s64vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, int64_t > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_f32vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_f32vector *
+_f32vector(pmt_t x)
+{
+  return dynamic_cast<pmt_f32vector*>(x.get());
+}
+
+
+pmt_f32vector::pmt_f32vector(size_t k, float fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_f32vector::pmt_f32vector(size_t k, const float *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(float) );
+}
+
+float
+pmt_f32vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_f32vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_f32vector::set(size_t k, float x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_f32vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const float *
+pmt_f32vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+float *
+pmt_f32vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_f32vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(float);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_f32vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(float);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_f32vector(pmt_t obj)
+{
+  return obj->is_f32vector();
+}
+
+pmt_t
+make_f32vector(size_t k, float fill)
+{
+  return pmt_t(new pmt_f32vector(k, fill));
+}
+
+pmt_t
+init_f32vector(size_t k, const float *data)
+{
+  return pmt_t(new pmt_f32vector(k, data));
+}
+
+pmt_t
+init_f32vector(size_t k, const std::vector< float > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_f32vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_f32vector(k, static_cast< float >(0))); // fills an empty vector with 0
+}
+
+float
+f32vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_f32vector())
+    throw wrong_type("pmt_f32vector_ref", vector);
+  return _f32vector(vector)->ref(k);
+}
+
+void
+f32vector_set(pmt_t vector, size_t k, float obj)
+{
+  if (!vector->is_f32vector())
+    throw wrong_type("pmt_f32vector_set", vector);
+  _f32vector(vector)->set(k, obj);
+}
+
+const float *
+f32vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_f32vector())
+    throw wrong_type("pmt_f32vector_elements", vector);
+  return _f32vector(vector)->elements(len);
+}
+
+const std::vector< float >
+f32vector_elements(pmt_t vector)
+{
+  if (!vector->is_f32vector())
+    throw wrong_type("pmt_f32vector_elements", vector);
+  size_t len;
+  const float *array = _f32vector(vector)->elements(len);
+  const std::vector< float > vec(array, array+len);
+  return vec;
+}
+
+
+float *
+f32vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_f32vector())
+    throw wrong_type("pmt_f32vector_writable_elements", vector);
+  return _f32vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_f32vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, float > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_f64vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_f64vector *
+_f64vector(pmt_t x)
+{
+  return dynamic_cast<pmt_f64vector*>(x.get());
+}
+
+
+pmt_f64vector::pmt_f64vector(size_t k, double fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_f64vector::pmt_f64vector(size_t k, const double *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(double) );
+}
+
+double
+pmt_f64vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_f64vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_f64vector::set(size_t k, double x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_f64vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const double *
+pmt_f64vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+double *
+pmt_f64vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_f64vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(double);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_f64vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(double);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_f64vector(pmt_t obj)
+{
+  return obj->is_f64vector();
+}
+
+pmt_t
+make_f64vector(size_t k, double fill)
+{
+  return pmt_t(new pmt_f64vector(k, fill));
+}
+
+pmt_t
+init_f64vector(size_t k, const double *data)
+{
+  return pmt_t(new pmt_f64vector(k, data));
+}
+
+pmt_t
+init_f64vector(size_t k, const std::vector< double > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_f64vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_f64vector(k, static_cast< double >(0))); // fills an empty vector with 0
+}
+
+double
+f64vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_f64vector())
+    throw wrong_type("pmt_f64vector_ref", vector);
+  return _f64vector(vector)->ref(k);
+}
+
+void
+f64vector_set(pmt_t vector, size_t k, double obj)
+{
+  if (!vector->is_f64vector())
+    throw wrong_type("pmt_f64vector_set", vector);
+  _f64vector(vector)->set(k, obj);
+}
+
+const double *
+f64vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_f64vector())
+    throw wrong_type("pmt_f64vector_elements", vector);
+  return _f64vector(vector)->elements(len);
+}
+
+const std::vector< double >
+f64vector_elements(pmt_t vector)
+{
+  if (!vector->is_f64vector())
+    throw wrong_type("pmt_f64vector_elements", vector);
+  size_t len;
+  const double *array = _f64vector(vector)->elements(len);
+  const std::vector< double > vec(array, array+len);
+  return vec;
+}
+
+
+double *
+f64vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_f64vector())
+    throw wrong_type("pmt_f64vector_writable_elements", vector);
+  return _f64vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_f64vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, double > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_c32vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_c32vector *
+_c32vector(pmt_t x)
+{
+  return dynamic_cast<pmt_c32vector*>(x.get());
+}
+
+
+pmt_c32vector::pmt_c32vector(size_t k, std::complex<float> fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_c32vector::pmt_c32vector(size_t k, const std::complex<float> *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(std::complex<float>) );
+}
+
+std::complex<float>
+pmt_c32vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_c32vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_c32vector::set(size_t k, std::complex<float> x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_c32vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const std::complex<float> *
+pmt_c32vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+std::complex<float> *
+pmt_c32vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_c32vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(std::complex<float>);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_c32vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(std::complex<float>);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_c32vector(pmt_t obj)
+{
+  return obj->is_c32vector();
+}
+
+pmt_t
+make_c32vector(size_t k, std::complex<float> fill)
+{
+  return pmt_t(new pmt_c32vector(k, fill));
+}
+
+pmt_t
+init_c32vector(size_t k, const std::complex<float> *data)
+{
+  return pmt_t(new pmt_c32vector(k, data));
+}
+
+pmt_t
+init_c32vector(size_t k, const std::vector< std::complex<float> > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_c32vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_c32vector(k, static_cast< std::complex<float> >(0))); // fills an empty vector with 0
+}
+
+std::complex<float>
+c32vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_c32vector())
+    throw wrong_type("pmt_c32vector_ref", vector);
+  return _c32vector(vector)->ref(k);
+}
+
+void
+c32vector_set(pmt_t vector, size_t k, std::complex<float> obj)
+{
+  if (!vector->is_c32vector())
+    throw wrong_type("pmt_c32vector_set", vector);
+  _c32vector(vector)->set(k, obj);
+}
+
+const std::complex<float> *
+c32vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_c32vector())
+    throw wrong_type("pmt_c32vector_elements", vector);
+  return _c32vector(vector)->elements(len);
+}
+
+const std::vector< std::complex<float> >
+c32vector_elements(pmt_t vector)
+{
+  if (!vector->is_c32vector())
+    throw wrong_type("pmt_c32vector_elements", vector);
+  size_t len;
+  const std::complex<float> *array = _c32vector(vector)->elements(len);
+  const std::vector< std::complex<float> > vec(array, array+len);
+  return vec;
+}
+
+
+std::complex<float> *
+c32vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_c32vector())
+    throw wrong_type("pmt_c32vector_writable_elements", vector);
+  return _c32vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_c32vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, std::complex<float> > (ref(k));
+}
+
+} /* namespace pmt */
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_c64vector
+////////////////////////////////////////////////////////////////////////////
+
+namespace pmt {
+
+static pmt_c64vector *
+_c64vector(pmt_t x)
+{
+  return dynamic_cast<pmt_c64vector*>(x.get());
+}
+
+
+pmt_c64vector::pmt_c64vector(size_t k, std::complex<double> fill)
+  : d_v(k)
+{
+  for (size_t i = 0; i < k; i++)
+    d_v[i] = fill;
+}
+
+pmt_c64vector::pmt_c64vector(size_t k, const std::complex<double> *data)
+  : d_v(k)
+{
+  if(k)
+    memcpy( &d_v[0], data, k * sizeof(std::complex<double>) );
+}
+
+std::complex<double>
+pmt_c64vector::ref(size_t k) const
+{
+  if (k >= length())
+    throw out_of_range("pmt_c64vector_ref", from_long(k));
+  return d_v[k];
+}
+
+void
+pmt_c64vector::set(size_t k, std::complex<double> x)
+{
+  if (k >= length())
+    throw out_of_range("pmt_c64vector_set", from_long(k));
+  d_v[k] = x;
+}
+
+const std::complex<double> *
+pmt_c64vector::elements(size_t &len)
+{
+  len = length();
+  return len ?  &d_v[0] : nullptr;
+}
+
+std::complex<double> *
+pmt_c64vector::writable_elements(size_t &len)
+{
+  len = length();
+  return len ? &d_v[0] : nullptr;
+}
+
+const void*
+pmt_c64vector::uniform_elements(size_t &len)
+{
+  len = length() * sizeof(std::complex<double>);
+  return len ? &d_v[0] : nullptr;
+}
+
+void*
+pmt_c64vector::uniform_writable_elements(size_t &len)
+{
+  len = length() * sizeof(std::complex<double>);
+  return len ? (&d_v[0]) : nullptr;
+}
+
+bool
+is_c64vector(pmt_t obj)
+{
+  return obj->is_c64vector();
+}
+
+pmt_t
+make_c64vector(size_t k, std::complex<double> fill)
+{
+  return pmt_t(new pmt_c64vector(k, fill));
+}
+
+pmt_t
+init_c64vector(size_t k, const std::complex<double> *data)
+{
+  return pmt_t(new pmt_c64vector(k, data));
+}
+
+pmt_t
+init_c64vector(size_t k, const std::vector< std::complex<double> > &data)
+{
+  if(k) {
+    return pmt_t(new pmt_c64vector(k, &data[0]));
+  }
+  return pmt_t(new pmt_c64vector(k, static_cast< std::complex<double> >(0))); // fills an empty vector with 0
+}
+
+std::complex<double>
+c64vector_ref(pmt_t vector, size_t k)
+{
+  if (!vector->is_c64vector())
+    throw wrong_type("pmt_c64vector_ref", vector);
+  return _c64vector(vector)->ref(k);
+}
+
+void
+c64vector_set(pmt_t vector, size_t k, std::complex<double> obj)
+{
+  if (!vector->is_c64vector())
+    throw wrong_type("pmt_c64vector_set", vector);
+  _c64vector(vector)->set(k, obj);
+}
+
+const std::complex<double> *
+c64vector_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_c64vector())
+    throw wrong_type("pmt_c64vector_elements", vector);
+  return _c64vector(vector)->elements(len);
+}
+
+const std::vector< std::complex<double> >
+c64vector_elements(pmt_t vector)
+{
+  if (!vector->is_c64vector())
+    throw wrong_type("pmt_c64vector_elements", vector);
+  size_t len;
+  const std::complex<double> *array = _c64vector(vector)->elements(len);
+  const std::vector< std::complex<double> > vec(array, array+len);
+  return vec;
+}
+
+
+std::complex<double> *
+c64vector_writable_elements(pmt_t vector, size_t &len)
+{
+  if (!vector->is_c64vector())
+    throw wrong_type("pmt_c64vector_writable_elements", vector);
+  return _c64vector(vector)->writable_elements(len);
+}
+
+const std::string
+pmt_c64vector::string_ref(size_t k) const
+{
+  return boost::lexical_cast< std::string, std::complex<double> > (ref(k));
+}
+
+} /* namespace pmt */
diff --git a/gnuradio-runtime/lib/pmt/pmt_unv_int.h b/gnuradio-runtime/lib/pmt/pmt_unv_int.h
new file mode 100644
index 0000000000..4b4364b411
--- /dev/null
+++ b/gnuradio-runtime/lib/pmt/pmt_unv_int.h
@@ -0,0 +1,331 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2006,2009,2018 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef INCLUDED_PMT_UNV_INT_H
+#define INCLUDED_PMT_UNV_INT_H
+
+#include "pmt_int.h"
+
+#include <vector>
+#include <cstdint>
+
+namespace pmt{
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u8vector
+////////////////////////////////////////////////////////////////////////////
+class PMT_API pmt_u8vector : public pmt_uniform_vector
+{
+  std::vector< uint8_t >	d_v;
+
+public:
+  pmt_u8vector(size_t k, uint8_t fill);
+  pmt_u8vector(size_t k, const uint8_t *data);
+  // ~pmt_u8vector();
+
+  bool is_u8vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(uint8_t); }
+  uint8_t ref(size_t k) const;
+  void set(size_t k, uint8_t x);
+  const uint8_t *elements(size_t &len);
+  uint8_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s8vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_s8vector : public pmt_uniform_vector
+{
+  std::vector< int8_t >	d_v;
+
+public:
+  pmt_s8vector(size_t k, int8_t fill);
+  pmt_s8vector(size_t k, const int8_t *data);
+  // ~pmt_s8vector();
+
+  bool is_s8vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(int8_t); }
+  int8_t ref(size_t k) const;
+  void set(size_t k, int8_t x);
+  const int8_t *elements(size_t &len);
+  int8_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u16vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_u16vector : public pmt_uniform_vector
+{
+  std::vector< uint16_t >	d_v;
+
+public:
+  pmt_u16vector(size_t k, uint16_t fill);
+  pmt_u16vector(size_t k, const uint16_t *data);
+  // ~pmt_u16vector();
+
+  bool is_u16vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(uint16_t); }
+  uint16_t ref(size_t k) const;
+  void set(size_t k, uint16_t x);
+  const uint16_t *elements(size_t &len);
+  uint16_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s16vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_s16vector : public pmt_uniform_vector
+{
+  std::vector< int16_t >	d_v;
+
+public:
+  pmt_s16vector(size_t k, int16_t fill);
+  pmt_s16vector(size_t k, const int16_t *data);
+  // ~pmt_s16vector();
+
+  bool is_s16vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(int16_t); }
+  int16_t ref(size_t k) const;
+  void set(size_t k, int16_t x);
+  const int16_t *elements(size_t &len);
+  int16_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u32vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_u32vector : public pmt_uniform_vector
+{
+  std::vector< uint32_t >	d_v;
+
+public:
+  pmt_u32vector(size_t k, uint32_t fill);
+  pmt_u32vector(size_t k, const uint32_t *data);
+  // ~pmt_u32vector();
+
+  bool is_u32vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(uint32_t); }
+  uint32_t ref(size_t k) const;
+  void set(size_t k, uint32_t x);
+  const uint32_t *elements(size_t &len);
+  uint32_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s32vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_s32vector : public pmt_uniform_vector
+{
+  std::vector< int32_t >	d_v;
+
+public:
+  pmt_s32vector(size_t k, int32_t fill);
+  pmt_s32vector(size_t k, const int32_t *data);
+  // ~pmt_s32vector();
+
+  bool is_s32vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(int32_t); }
+  int32_t ref(size_t k) const;
+  void set(size_t k, int32_t x);
+  const int32_t *elements(size_t &len);
+  int32_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_u64vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_u64vector : public pmt_uniform_vector
+{
+  std::vector< uint64_t >	d_v;
+
+public:
+  pmt_u64vector(size_t k, uint64_t fill);
+  pmt_u64vector(size_t k, const uint64_t *data);
+  // ~pmt_u64vector();
+
+  bool is_u64vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(uint64_t); }
+  uint64_t ref(size_t k) const;
+  void set(size_t k, uint64_t x);
+  const uint64_t *elements(size_t &len);
+  uint64_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_s64vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_s64vector : public pmt_uniform_vector
+{
+  std::vector< int64_t >	d_v;
+
+public:
+  pmt_s64vector(size_t k, int64_t fill);
+  pmt_s64vector(size_t k, const int64_t *data);
+  // ~pmt_s64vector();
+
+  bool is_s64vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(int64_t); }
+  int64_t ref(size_t k) const;
+  void set(size_t k, int64_t x);
+  const int64_t *elements(size_t &len);
+  int64_t *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_f32vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_f32vector : public pmt_uniform_vector
+{
+  std::vector< float >	d_v;
+
+public:
+  pmt_f32vector(size_t k, float fill);
+  pmt_f32vector(size_t k, const float *data);
+  // ~pmt_f32vector();
+
+  bool is_f32vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(float); }
+  float ref(size_t k) const;
+  void set(size_t k, float x);
+  const float *elements(size_t &len);
+  float *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_f64vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_f64vector : public pmt_uniform_vector
+{
+  std::vector< double >	d_v;
+
+public:
+  pmt_f64vector(size_t k, double fill);
+  pmt_f64vector(size_t k, const double *data);
+  // ~pmt_f64vector();
+
+  bool is_f64vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(double); }
+  double ref(size_t k) const;
+  void set(size_t k, double x);
+  const double *elements(size_t &len);
+  double *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_c32vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_c32vector : public pmt_uniform_vector
+{
+  std::vector< std::complex<float> >	d_v;
+
+public:
+  pmt_c32vector(size_t k, std::complex<float> fill);
+  pmt_c32vector(size_t k, const std::complex<float> *data);
+  // ~pmt_c32vector();
+
+  bool is_c32vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(std::complex<float>); }
+  std::complex<float> ref(size_t k) const;
+  void set(size_t k, std::complex<float> x);
+  const std::complex<float> *elements(size_t &len);
+  std::complex<float> *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+
+////////////////////////////////////////////////////////////////////////////
+//                           pmt_c64vector
+////////////////////////////////////////////////////////////////////////////
+
+class pmt_c64vector : public pmt_uniform_vector
+{
+  std::vector< std::complex<double> >	d_v;
+
+public:
+  pmt_c64vector(size_t k, std::complex<double> fill);
+  pmt_c64vector(size_t k, const std::complex<double> *data);
+  // ~pmt_c64vector();
+
+  bool is_c64vector() const { return true; }
+  size_t length() const { return d_v.size(); }
+  size_t itemsize() const { return sizeof(std::complex<double>); }
+  std::complex<double> ref(size_t k) const;
+  void set(size_t k, std::complex<double> x);
+  const std::complex<double> *elements(size_t &len);
+  std::complex<double> *writable_elements(size_t &len);
+  const void *uniform_elements(size_t &len);
+  void *uniform_writable_elements(size_t &len);
+  virtual const std::string string_ref(size_t k) const;
+};
+} /* namespace pmt */
+#endif
diff --git a/gnuradio-runtime/lib/pmt/qa_pmt_unv.cc b/gnuradio-runtime/lib/pmt/qa_pmt_unv.cc
new file mode 100644
index 0000000000..9751f5e610
--- /dev/null
+++ b/gnuradio-runtime/lib/pmt/qa_pmt_unv.cc
@@ -0,0 +1,448 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2006,2009 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <qa_pmt_unv.h>
+#include <cppunit/TestAssert.h>
+#include <pmt/pmt.h>
+#include <stdio.h>
+
+using namespace pmt;
+void
+qa_pmt_unv::test_u8vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_u8vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  uint8_t s0 = uint8_t(10);
+  uint8_t s1 = uint8_t(20);
+  uint8_t s2 = uint8_t(30);
+
+  pmt::u8vector_set(v1, 0, s0);
+  pmt::u8vector_set(v1, 1, s1);
+  pmt::u8vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::u8vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::u8vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::u8vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::u8vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::u8vector_set(v1, N, uint8_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const uint8_t *rd = pmt::u8vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  uint8_t *wr = pmt::u8vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = uint8_t(0);
+  CPPUNIT_ASSERT_EQUAL(uint8_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_s8vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_s8vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  int8_t s0 = int8_t(10);
+  int8_t s1 = int8_t(20);
+  int8_t s2 = int8_t(30);
+
+  pmt::s8vector_set(v1, 0, s0);
+  pmt::s8vector_set(v1, 1, s1);
+  pmt::s8vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::s8vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::s8vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::s8vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::s8vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::s8vector_set(v1, N, int8_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const int8_t *rd = pmt::s8vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  int8_t *wr = pmt::s8vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = int8_t(0);
+  CPPUNIT_ASSERT_EQUAL(int8_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_u16vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_u16vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  uint16_t s0 = uint16_t(10);
+  uint16_t s1 = uint16_t(20);
+  uint16_t s2 = uint16_t(30);
+
+  pmt::u16vector_set(v1, 0, s0);
+  pmt::u16vector_set(v1, 1, s1);
+  pmt::u16vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::u16vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::u16vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::u16vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::u16vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::u16vector_set(v1, N, uint16_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const uint16_t *rd = pmt::u16vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  uint16_t *wr = pmt::u16vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = uint16_t(0);
+  CPPUNIT_ASSERT_EQUAL(uint16_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_s16vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_s16vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  int16_t s0 = int16_t(10);
+  int16_t s1 = int16_t(20);
+  int16_t s2 = int16_t(30);
+
+  pmt::s16vector_set(v1, 0, s0);
+  pmt::s16vector_set(v1, 1, s1);
+  pmt::s16vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::s16vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::s16vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::s16vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::s16vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::s16vector_set(v1, N, int16_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const int16_t *rd = pmt::s16vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  int16_t *wr = pmt::s16vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = int16_t(0);
+  CPPUNIT_ASSERT_EQUAL(int16_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_u32vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_u32vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  uint32_t s0 = uint32_t(10);
+  uint32_t s1 = uint32_t(20);
+  uint32_t s2 = uint32_t(30);
+
+  pmt::u32vector_set(v1, 0, s0);
+  pmt::u32vector_set(v1, 1, s1);
+  pmt::u32vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::u32vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::u32vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::u32vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::u32vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::u32vector_set(v1, N, uint32_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const uint32_t *rd = pmt::u32vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  uint32_t *wr = pmt::u32vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = uint32_t(0);
+  CPPUNIT_ASSERT_EQUAL(uint32_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_s32vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_s32vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  int32_t s0 = int32_t(10);
+  int32_t s1 = int32_t(20);
+  int32_t s2 = int32_t(30);
+
+  pmt::s32vector_set(v1, 0, s0);
+  pmt::s32vector_set(v1, 1, s1);
+  pmt::s32vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::s32vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::s32vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::s32vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::s32vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::s32vector_set(v1, N, int32_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const int32_t *rd = pmt::s32vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  int32_t *wr = pmt::s32vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = int32_t(0);
+  CPPUNIT_ASSERT_EQUAL(int32_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_u64vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_u64vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  uint64_t s0 = uint64_t(10);
+  uint64_t s1 = uint64_t(20);
+  uint64_t s2 = uint64_t(30);
+
+  pmt::u64vector_set(v1, 0, s0);
+  pmt::u64vector_set(v1, 1, s1);
+  pmt::u64vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::u64vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::u64vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::u64vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::u64vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::u64vector_set(v1, N, uint64_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const uint64_t *rd = pmt::u64vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  uint64_t *wr = pmt::u64vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = uint64_t(0);
+  CPPUNIT_ASSERT_EQUAL(uint64_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_s64vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_s64vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  int64_t s0 = int64_t(10);
+  int64_t s1 = int64_t(20);
+  int64_t s2 = int64_t(30);
+
+  pmt::s64vector_set(v1, 0, s0);
+  pmt::s64vector_set(v1, 1, s1);
+  pmt::s64vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::s64vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::s64vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::s64vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::s64vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::s64vector_set(v1, N, int64_t(0)), pmt::out_of_range);
+
+  size_t	len;
+  const int64_t *rd = pmt::s64vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  int64_t *wr = pmt::s64vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = int64_t(0);
+  CPPUNIT_ASSERT_EQUAL(int64_t(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_f32vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_f32vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  float s0 = float(10);
+  float s1 = float(20);
+  float s2 = float(30);
+
+  pmt::f32vector_set(v1, 0, s0);
+  pmt::f32vector_set(v1, 1, s1);
+  pmt::f32vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::f32vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::f32vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::f32vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::f32vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::f32vector_set(v1, N, float(0)), pmt::out_of_range);
+
+  size_t	len;
+  const float *rd = pmt::f32vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  float *wr = pmt::f32vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = float(0);
+  CPPUNIT_ASSERT_EQUAL(float(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_f64vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_f64vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  double s0 = double(10);
+  double s1 = double(20);
+  double s2 = double(30);
+
+  pmt::f64vector_set(v1, 0, s0);
+  pmt::f64vector_set(v1, 1, s1);
+  pmt::f64vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::f64vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::f64vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::f64vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::f64vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::f64vector_set(v1, N, double(0)), pmt::out_of_range);
+
+  size_t	len;
+  const double *rd = pmt::f64vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  double *wr = pmt::f64vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = double(0);
+  CPPUNIT_ASSERT_EQUAL(double(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_c32vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_c32vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  std::complex<float> s0 = std::complex<float>(10);
+  std::complex<float> s1 = std::complex<float>(20);
+  std::complex<float> s2 = std::complex<float>(30);
+
+  pmt::c32vector_set(v1, 0, s0);
+  pmt::c32vector_set(v1, 1, s1);
+  pmt::c32vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::c32vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::c32vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::c32vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::c32vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::c32vector_set(v1, N, std::complex<float>(0)), pmt::out_of_range);
+
+  size_t	len;
+  const std::complex<float> *rd = pmt::c32vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  std::complex<float> *wr = pmt::c32vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = std::complex<float>(0);
+  CPPUNIT_ASSERT_EQUAL(std::complex<float>(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
+void
+qa_pmt_unv::test_c64vector()
+{
+  static const size_t N = 3;
+  pmt::pmt_t v1 = pmt::make_c64vector(N, 0);
+  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
+  std::complex<double> s0 = std::complex<double>(10);
+  std::complex<double> s1 = std::complex<double>(20);
+  std::complex<double> s2 = std::complex<double>(30);
+
+  pmt::c64vector_set(v1, 0, s0);
+  pmt::c64vector_set(v1, 1, s1);
+  pmt::c64vector_set(v1, 2, s2);
+
+  CPPUNIT_ASSERT_EQUAL(s0, pmt::c64vector_ref(v1, 0));
+  CPPUNIT_ASSERT_EQUAL(s1, pmt::c64vector_ref(v1, 1));
+  CPPUNIT_ASSERT_EQUAL(s2, pmt::c64vector_ref(v1, 2));
+
+  CPPUNIT_ASSERT_THROW(pmt::c64vector_ref(v1, N), pmt::out_of_range);
+  CPPUNIT_ASSERT_THROW(pmt::c64vector_set(v1, N, std::complex<double>(0)), pmt::out_of_range);
+
+  size_t	len;
+  const std::complex<double> *rd = pmt::c64vector_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
+
+  std::complex<double> *wr = pmt::c64vector_writable_elements(v1, len);
+  CPPUNIT_ASSERT_EQUAL(len, N);
+  wr[0] = std::complex<double>(0);
+  CPPUNIT_ASSERT_EQUAL(std::complex<double>(0), wr[0]);
+  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
+  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
+}
diff --git a/gnuradio-runtime/lib/pmt/qa_pmt_unv.h b/gnuradio-runtime/lib/pmt/qa_pmt_unv.h
new file mode 100644
index 0000000000..71462a9212
--- /dev/null
+++ b/gnuradio-runtime/lib/pmt/qa_pmt_unv.h
@@ -0,0 +1,61 @@
+/* -*- c++ -*- */
+/*
+ * Copyright 2006,2009 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNU Radio; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef INCLUDED_QA_PMT_UNV_H
+#define INCLUDED_QA_PMT_UNV_H
+
+#include <cppunit/extensions/HelperMacros.h>
+#include <cppunit/TestCase.h>
+
+class qa_pmt_unv : public CppUnit::TestCase {
+
+  CPPUNIT_TEST_SUITE(qa_pmt_unv);
+  CPPUNIT_TEST(test_u8vector);
+  CPPUNIT_TEST(test_s8vector);
+  CPPUNIT_TEST(test_u16vector);
+  CPPUNIT_TEST(test_s16vector);
+  CPPUNIT_TEST(test_u32vector);
+  CPPUNIT_TEST(test_s32vector);
+  CPPUNIT_TEST(test_u64vector);
+  CPPUNIT_TEST(test_s64vector);
+  CPPUNIT_TEST(test_f32vector);
+  CPPUNIT_TEST(test_f64vector);
+  CPPUNIT_TEST(test_c32vector);
+  CPPUNIT_TEST(test_c64vector);
+  CPPUNIT_TEST_SUITE_END();
+
+ private:
+  void test_u8vector();
+  void test_s8vector();
+  void test_u16vector();
+  void test_s16vector();
+  void test_u32vector();
+  void test_s32vector();
+  void test_u64vector();
+  void test_s64vector();
+  void test_f32vector();
+  void test_f64vector();
+  void test_c32vector();
+  void test_c64vector();
+};
+
+#endif
diff --git a/gnuradio-runtime/lib/pmt/unv_qa_template.cc.t b/gnuradio-runtime/lib/pmt/unv_qa_template.cc.t
deleted file mode 100644
index ea675cee16..0000000000
--- a/gnuradio-runtime/lib/pmt/unv_qa_template.cc.t
+++ /dev/null
@@ -1,35 +0,0 @@
-void
-qa_pmt_unv::test_@TAG@vector()
-{
-  static const size_t N = 3;
-  pmt::pmt_t v1 = pmt::make_@TAG@vector(N, 0);
-  CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1));
-  @TYPE@ s0 = @TYPE@(10);
-  @TYPE@ s1 = @TYPE@(20);
-  @TYPE@ s2 = @TYPE@(30);
-
-  pmt::@TAG@vector_set(v1, 0, s0);
-  pmt::@TAG@vector_set(v1, 1, s1);
-  pmt::@TAG@vector_set(v1, 2, s2);
-
-  CPPUNIT_ASSERT_EQUAL(s0, pmt::@TAG@vector_ref(v1, 0));
-  CPPUNIT_ASSERT_EQUAL(s1, pmt::@TAG@vector_ref(v1, 1));
-  CPPUNIT_ASSERT_EQUAL(s2, pmt::@TAG@vector_ref(v1, 2));
-
-  CPPUNIT_ASSERT_THROW(pmt::@TAG@vector_ref(v1, N), pmt::out_of_range);
-  CPPUNIT_ASSERT_THROW(pmt::@TAG@vector_set(v1, N, @TYPE@(0)), pmt::out_of_range);
-
-  size_t	len;
-  const @TYPE@ *rd = pmt::@TAG@vector_elements(v1, len);
-  CPPUNIT_ASSERT_EQUAL(len, N);
-  CPPUNIT_ASSERT_EQUAL(s0, rd[0]);
-  CPPUNIT_ASSERT_EQUAL(s1, rd[1]);
-  CPPUNIT_ASSERT_EQUAL(s2, rd[2]);
-
-  @TYPE@ *wr = pmt::@TAG@vector_writable_elements(v1, len);
-  CPPUNIT_ASSERT_EQUAL(len, N);
-  wr[0] = @TYPE@(0);
-  CPPUNIT_ASSERT_EQUAL(@TYPE@(0), wr[0]);
-  CPPUNIT_ASSERT_EQUAL(s1, wr[1]);
-  CPPUNIT_ASSERT_EQUAL(s2, wr[2]);
-}
diff --git a/gnuradio-runtime/lib/pmt/unv_template.cc.t b/gnuradio-runtime/lib/pmt/unv_template.cc.t
deleted file mode 100644
index b6c9d05c1d..0000000000
--- a/gnuradio-runtime/lib/pmt/unv_template.cc.t
+++ /dev/null
@@ -1,149 +0,0 @@
-////////////////////////////////////////////////////////////////////////////
-//                           pmt_@TAG@vector
-////////////////////////////////////////////////////////////////////////////
-
-namespace pmt {
-
-static pmt_@TAG@vector *
-_@TAG@vector(pmt_t x)
-{
-  return dynamic_cast<pmt_@TAG@vector*>(x.get());
-}
-
-
-pmt_@TAG@vector::pmt_@TAG@vector(size_t k, @TYPE@ fill)
-  : d_v(k)
-{
-  for (size_t i = 0; i < k; i++)
-    d_v[i] = fill;
-}
-
-pmt_@TAG@vector::pmt_@TAG@vector(size_t k, const @TYPE@ *data)
-  : d_v(k)
-{
-  if(k)
-    memcpy( &d_v[0], data, k * sizeof(@TYPE@) );
-}
-
-@TYPE@
-pmt_@TAG@vector::ref(size_t k) const
-{
-  if (k >= length())
-    throw out_of_range("pmt_@TAG@vector_ref", from_long(k));
-  return d_v[k];
-}
-
-void
-pmt_@TAG@vector::set(size_t k, @TYPE@ x)
-{
-  if (k >= length())
-    throw out_of_range("pmt_@TAG@vector_set", from_long(k));
-  d_v[k] = x;
-}
-
-const @TYPE@ *
-pmt_@TAG@vector::elements(size_t &len)
-{
-  len = length();
-  return len ?  &d_v[0] : nullptr;
-}
-
-@TYPE@ *
-pmt_@TAG@vector::writable_elements(size_t &len)
-{
-  len = length();
-  return len ? &d_v[0] : nullptr;
-}
-
-const void*
-pmt_@TAG@vector::uniform_elements(size_t &len)
-{
-  len = length() * sizeof(@TYPE@);
-  return len ? &d_v[0] : nullptr;
-}
-
-void*
-pmt_@TAG@vector::uniform_writable_elements(size_t &len)
-{
-  len = length() * sizeof(@TYPE@);
-  return len ? (&d_v[0]) : nullptr;
-}
-
-bool
-is_@TAG@vector(pmt_t obj)
-{
-  return obj->is_@TAG@vector();
-}
-
-pmt_t
-make_@TAG@vector(size_t k, @TYPE@ fill)
-{
-  return pmt_t(new pmt_@TAG@vector(k, fill));
-}
-
-pmt_t
-init_@TAG@vector(size_t k, const @TYPE@ *data)
-{
-  return pmt_t(new pmt_@TAG@vector(k, data));
-}
-
-pmt_t
-init_@TAG@vector(size_t k, const std::vector< @TYPE@ > &data)
-{
-  if(k) {
-    return pmt_t(new pmt_@TAG@vector(k, &data[0]));
-  }
-  return pmt_t(new pmt_@TAG@vector(k, static_cast< @TYPE@ >(0))); // fills an empty vector with 0
-}
-
-@TYPE@
-@TAG@vector_ref(pmt_t vector, size_t k)
-{
-  if (!vector->is_@TAG@vector())
-    throw wrong_type("pmt_@TAG@vector_ref", vector);
-  return _@TAG@vector(vector)->ref(k);
-}
-
-void
-@TAG@vector_set(pmt_t vector, size_t k, @TYPE@ obj)
-{
-  if (!vector->is_@TAG@vector())
-    throw wrong_type("pmt_@TAG@vector_set", vector);
-  _@TAG@vector(vector)->set(k, obj);
-}
-
-const @TYPE@ *
-@TAG@vector_elements(pmt_t vector, size_t &len)
-{
-  if (!vector->is_@TAG@vector())
-    throw wrong_type("pmt_@TAG@vector_elements", vector);
-  return _@TAG@vector(vector)->elements(len);
-}
-
-const std::vector< @TYPE@ >
-@TAG@vector_elements(pmt_t vector)
-{
-  if (!vector->is_@TAG@vector())
-    throw wrong_type("pmt_@TAG@vector_elements", vector);
-  size_t len;
-  const @TYPE@ *array = _@TAG@vector(vector)->elements(len);
-  const std::vector< @TYPE@ > vec(array, array+len);
-  return vec;
-}
-
-
-@TYPE@ *
-@TAG@vector_writable_elements(pmt_t vector, size_t &len)
-{
-  if (!vector->is_@TAG@vector())
-    throw wrong_type("pmt_@TAG@vector_writable_elements", vector);
-  return _@TAG@vector(vector)->writable_elements(len);
-}
-
-const std::string
-pmt_@TAG@vector::string_ref(size_t k) const
-{
-  return boost::lexical_cast< std::string, @TYPE@ > (ref(k));
-}
-
-} /* namespace pmt */
diff --git a/gnuradio-runtime/lib/pmt/unv_template.h.t b/gnuradio-runtime/lib/pmt/unv_template.h.t
deleted file mode 100644
index ab5c163570..0000000000
--- a/gnuradio-runtime/lib/pmt/unv_template.h.t
+++ /dev/null
@@ -1,25 +0,0 @@
-
-////////////////////////////////////////////////////////////////////////////
-//                           pmt_@TAG@vector
-////////////////////////////////////////////////////////////////////////////
-
-class pmt_@TAG@vector : public pmt_uniform_vector
-{
-  std::vector< @TYPE@ >	d_v;
-
-public:
-  pmt_@TAG@vector(size_t k, @TYPE@ fill);
-  pmt_@TAG@vector(size_t k, const @TYPE@ *data);
-  // ~pmt_@TAG@vector();
-
-  bool is_@TAG@vector() const { return true; }
-  size_t length() const { return d_v.size(); }
-  size_t itemsize() const { return sizeof(@TYPE@); }
-  @TYPE@ ref(size_t k) const;
-  void set(size_t k, @TYPE@ x);
-  const @TYPE@ *elements(size_t &len);
-  @TYPE@ *writable_elements(size_t &len);
-  const void *uniform_elements(size_t &len);
-  void *uniform_writable_elements(size_t &len);
-  virtual const std::string string_ref(size_t k) const;
-};
diff --git a/gnuradio-runtime/swig/CMakeLists.txt b/gnuradio-runtime/swig/CMakeLists.txt
index 9135f311c6..a48aaeb9f3 100644
--- a/gnuradio-runtime/swig/CMakeLists.txt
+++ b/gnuradio-runtime/swig/CMakeLists.txt
@@ -45,7 +45,6 @@ set(GR_SWIG_LIBRARIES
 set(GR_SWIG_DOC_FILE ${CMAKE_CURRENT_BINARY_DIR}/pmt_swig_doc.i)
 set(GR_SWIG_DOC_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../include/pmt
   ${CMAKE_CURRENT_BINARY_DIR}/../include/pmt)
-list(APPEND GR_SWIG_TARGET_DEPS pmt_generated)
 GR_SWIG_MAKE(pmt_swig pmt_swig.i)
 
 GR_SWIG_INSTALL(